File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby19/lib64/ruby/gems/1.9.1/gems/rack-1.6.4/lib/rack

opt / alt / ruby19 / lib64 / ruby / gems / 1.9.1 / gems / rack-1.6.4 / lib / rack /

?? ..
?? auth
?? backports
?? body_proxy.rb(958 B)
?? builder.rb(4.27 KB)
?? cascade.rb(1.34 KB)
?? chunked.rb(1.58 KB)
?? commonlogger.rb(2.28 KB)
?? conditionalget.rb(2.5 KB)
?? config.rb(379 B)
?? content_length.rb(840 B)
?? content_type.rb(670 B)
?? deflater.rb(4.57 KB)
?? directory.rb(4.2 KB)
?? etag.rb(2.11 KB)
?? file.rb(4.09 KB)
?? handler
?? handler.rb(3.25 KB)
?? head.rb(484 B)
?? lint.rb(29.26 KB)
?? lobster.rb(1.97 KB)
?? lock.rb(601 B)
?? logger.rb(357 B)
?? methodoverride.rb(1.01 KB)
?? mime.rb(30.94 KB)
?? mock.rb(5.68 KB)
?? multipart
?? multipart.rb(1.14 KB)
?? nulllogger.rb(951 B)
?? recursive.rb(1.73 KB)
?? reloader.rb(2.97 KB)
?? request.rb(12.59 KB)
?? response.rb(4.33 KB)
?? rewindable_input.rb(3.19 KB)
?? runtime.rb(961 B)
?? sendfile.rb(5.18 KB)
?? server.rb(10.8 KB)
?? session
?? showexceptions.rb(11.7 KB)
?? showstatus.rb(3.46 KB)
?? static.rb(4.88 KB)
?? tempfile_reaper.rb(670 B)
?? urlmap.rb(2.46 KB)
?? utils
?? utils.rb(20.86 KB)

Editing: builder.rb

module Rack
  # 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.

class Builder
    def self.parse_file(config, opts = Server::Options.new)
      options = {}
      if config =~ /\.ru$/
        cfgfile = ::File.read(config)
        if cfgfile[/^#\\(.*)/] && opts
          options = opts.parse! $1.split(/\s+/)
        end
        cfgfile.sub!(/^__END__\n.*\Z/m, '')
        app = new_from_string cfgfile, config
      else
        require config
        app = Object.const_get(::File.basename(config, '.rb').capitalize)
      end
      return app, options
    end

def self.new_from_string(builder_script, file="(rackup)")
      eval "Rack::Builder.new {\n" + builder_script + "\n}.to_app",
        TOPLEVEL_BINDING, file, 0
    end

def initialize(default_app = nil,&block)
      @use, @map, @run, @warmup = [], nil, default_app, nil
      instance_eval(&block) if block_given?
    end

def self.app(default_app = nil, &block)
      self.new(default_app, &block).to_app
    end

# 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.
    def use(middleware, *args, &block)
      if @map
        mapping, @map = @map, nil
        @use << proc { |app| generate_map app, mapping }
      end
      @use << proc { |app| middleware.new(app, *args, &block) }
    end

# 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
    def run(app)
      @run = app
    end

# 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
    def warmup(prc=nil, &block)
      @warmup = prc || block
    end

# 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+.
    #
    def map(path, &block)
      @map ||= {}
      @map[path] = block
    end

def to_app
      app = @map ? generate_map(@run, @map) : @run
      fail "missing run or map statement" unless app
      app = @use.reverse.inject(app) { |a,e| e[a] }
      @warmup.call(app) if @warmup
      app
    end

def call(env)
      to_app.call(env)
    end

private

def generate_map(default_app, mapping)
      mapped = default_app ? {'/' => default_app} : {}
      mapping.each { |r,b| mapped[r] = self.class.new(default_app, &b).to_app }
      URLMap.new(mapped)
    end
  end
end

X7ROOT File Manager

Editing: builder.rb

Upload File

Create Folder