Class | Rack::Builder
In: | lib/rack/builder.rb
Parent: | Object

Rack::Builder implements a small DSL to iteratively construct Rack applications.

Example:

     require 'rack/lobster'
     app = Rack::Builder.new do
       use Rack::CommonLogger
       use Rack::ShowExceptions
       map "/lobster" do
         use Rack::Lint
         run Rack::Lobster.new
       end
     end

     run app

Or

     app = Rack::Builder.app do
       use Rack::CommonLogger
       run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
     end

     run app

`use` adds middleware to the stack, `run` dispatches to an application. You can use `map` to construct a Rack::URLMap in a convenient way.

### Methods

app call map new new_from_string parse_file run to_app use warmup

### Public Class methods

app(default_app = nil, &block)
new(default_app = nil,&block)
new_from_string(builder_script, file="(rackup)")
parse_file(config, opts = Server::Options.new)

### Public Instance methods

call(env)
map(path, &block)

Creates a route within the application.

      Rack::Builder.app do
        map '/' do
          run Heartbeat
        end
      end

The `use` method can also be used here to specify middleware to run under a specific path:

      Rack::Builder.app do
        map '/' do
          use Middleware
          run Heartbeat
        end
      end

This example includes a piece of middleware which will run before requests hit `Heartbeat`.

run(app)

Takes an argument that is an object that responds to call and returns a Rack response. The simplest form of this is a lambda object:

      run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }

However this could also be a class:

      class Heartbeat
        def self.call(env)
         [200, { "Content-Type" => "text/plain" }, ["OK"]]
       end
      end

      run Heartbeat

to_app()
use(middleware, *args, &block)

Specifies middleware to use in a stack.

      class Middleware
        def initialize(app)
          @app = app
        end

        def call(env)
          env["rack.some_header"] = "setting an example"
          @app.call(env)
        end
      end

      use Middleware
      run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }

All requests through to this application will first be processed by the middleware class. The `call` method in this example sets an additional environment key which then can be referenced in the application if required.

warmup(prc=nil, &block)

Takes a lambda or block that is used to warm-up the application.

      warmup do |app|
        client = Rack::MockRequest.new(app)
        client.get('/')
      end

      use SomeMiddleware
      run MyApp

[Validate]