Parent

Class Index [+]

Quicksearch

Rack::Builder

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 a middleware to the stack, run dispatches to an application. You can use map to construct a Rack::URLMap in a convenient way.

Public Class Methods

app(default_app = nil, &block) click to toggle source
    # File lib/rack/builder.rb, line 54
54:     def self.app(default_app = nil, &block)
55:       self.new(default_app, &block).to_app
56:     end
new(default_app = nil,&block) click to toggle source
    # File lib/rack/builder.rb, line 49
49:     def initialize(default_app = nil,&block)
50:       @use, @map, @run = [], nil, default_app
51:       instance_eval(&block) if block_given?
52:     end
parse_file(config, opts = Server::Options.new) click to toggle source
    # File lib/rack/builder.rb, line 32
32:     def self.parse_file(config, opts = Server::Options.new)
33:       options = {}
34:       if config =~ /\.ru$/
35:         cfgfile = ::File.read(config)
36:         if cfgfile[/^#\\(.*)/] && opts
37:           options = opts.parse! $1.split(/\s+/)
38:         end
39:         cfgfile.sub!(/^__END__\n.*\Z/, '')
40:         app = eval "Rack::Builder.new {\n" + cfgfile + "\n}.to_app",
41:           TOPLEVEL_BINDING, config
42:       else
43:         require config
44:         app = Object.const_get(::File.basename(config, '.rb').capitalize)
45:       end
46:       return app, options
47:     end

Public Instance Methods

call(env) click to toggle source
     # File lib/rack/builder.rb, line 133
133:     def call(env)
134:       to_app.call(env)
135:     end
map(path, &block) click to toggle source

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.

     # File lib/rack/builder.rb, line 122
122:     def map(path, &block)
123:       @map ||= {}
124:       @map[path] = block
125:     end
run(app) click to toggle source

Takes an argument that is an object that responds to # 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
     # File lib/rack/builder.rb, line 99
 99:     def run(app)
100:       @run = app
101:     end
to_app() click to toggle source
     # File lib/rack/builder.rb, line 127
127:     def to_app
128:       app = @map ? generate_map(@run, @map) : @run
129:       fail "missing run or map statement" unless app
130:       @use.reverse.inject(app) { |a,e| e[a] }
131:     end
use(middleware, *args, &block) click to toggle source

Specifies a 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.

    # File lib/rack/builder.rb, line 77
77:     def use(middleware, *args, &block)
78:       if @map
79:         mapping, @map = @map, nil
80:         @use << proc { |app| generate_map app, mapping }
81:       end
82:       @use << proc { |app| middleware.new(app, *args, &block) }
83:     end

Private Instance Methods

generate_map(default_app, mapping) click to toggle source
     # File lib/rack/builder.rb, line 139
139:     def generate_map(default_app, mapping)
140:       mapped = default_app ? {'/' => default_app} : {}
141:       mapping.each { |r,b| mapped[r] = self.class.new(default_app, &b) }
142:       URLMap.new(mapped)
143:     end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.