rack 1.0.1 → 2.2.21

data/lib/rack/auth/digest/params.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 module Rack
   module Auth
     module Digest
       class Params < Hash
 
         def self.parse(str)
-          split_header_value(str).inject(new) do |header, param|
+          Params[*split_header_value(str).map do |param|
             k, v = param.split('=', 2)
-            header[k] = dequote(v)
-            header
-          end
+            [k, dequote(v)]
+          end.flatten]
         end
 
         def self.dequote(str) # From WEBrick::HTTPUtils
@@ -18,11 +19,11 @@ module Rack
         end
 
         def self.split_header_value(str)
-          str.scan( /(\w+\=(?:"[^\"]+"|[^,]+))/n ).collect{ |v| v[0] }
+          str.scan(/\w+\=(?:"[^\"]+"|[^,]+)/n)
         end
 
         def initialize
-          super
+          super()
 
           yield self if block_given?
         end
@@ -35,21 +36,19 @@ module Rack
           super k.to_s, v.to_s
         end
 
-        UNQUOTED = ['qop', 'nc', 'stale']
+        UNQUOTED = ['nc', 'stale']
 
         def to_s
-          inject([]) do |parts, (k, v)|
-            parts << "#{k}=" + (UNQUOTED.include?(k) ? v.to_s : quote(v))
-            parts
+          map do |k, v|
+            "#{k}=#{(UNQUOTED.include?(k) ? v.to_s : quote(v))}"
           end.join(', ')
         end
 
         def quote(str) # From WEBrick::HTTPUtils
-          '"' << str.gsub(/[\\\"]/o, "\\\1") << '"'
+          '"' + str.gsub(/[\\\"]/o, "\\\1") + '"'
         end
 
       end
     end
   end
 end
-

data/lib/rack/auth/digest/request.rb

@@ -1,22 +1,23 @@
-require 'rack/auth/abstract/request'
-require 'rack/auth/digest/params'
-require 'rack/auth/digest/nonce'
+# frozen_string_literal: true
+
+require_relative '../abstract/request'
+require_relative 'params'
+require_relative 'nonce'
 
 module Rack
   module Auth
     module Digest
       class Request < Auth::AbstractRequest
-
         def method
-          @env['rack.methodoverride.original_method'] || @env['REQUEST_METHOD']
+          @env[RACK_METHODOVERRIDE_ORIGINAL_METHOD] || @env[REQUEST_METHOD]
         end
 
         def digest?
-          :digest == scheme
+          "digest" == scheme
         end
 
         def correct_uri?
-          (@env['SCRIPT_NAME'].to_s + @env['PATH_INFO'].to_s) == uri
+          request.fullpath == uri
         end
 
         def nonce
@@ -27,13 +28,15 @@ module Rack
           @params ||= Params.parse(parts.last)
         end
 
-        def method_missing(sym)
-          if params.has_key? key = sym.to_s
-            return params[key]
-          end
-          super
+        def respond_to?(sym, *)
+          super or params.has_key? sym.to_s
         end
 
+        def method_missing(sym, *args)
+          return super unless params.has_key?(key = sym.to_s)
+          return params[key] if args.size == 0
+          raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
+        end
       end
     end
   end

data/lib/rack/body_proxy.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rack
+  # Proxy for response bodies allowing calling a block when
+  # the response body is closed (after the response has been fully
+  # sent to the client).
+  class BodyProxy
+    # Set the response body to wrap, and the block to call when the
+    # response has been fully sent.
+    def initialize(body, &block)
+      @body = body
+      @block = block
+      @closed = false
+    end
+
+    # Return whether the wrapped body responds to the method.
+    def respond_to_missing?(method_name, include_all = false)
+      super or @body.respond_to?(method_name, include_all)
+    end
+
+    # If not already closed, close the wrapped body and
+    # then call the block the proxy was initialized with.
+    def close
+      return if @closed
+      @closed = true
+      begin
+        @body.close if @body.respond_to? :close
+      ensure
+        @block.call
+      end
+    end
+
+    # Whether the proxy is closed.  The proxy starts as not closed,
+    # and becomes closed on the first call to close.
+    def closed?
+      @closed
+    end
+
+    # Delegate missing methods to the wrapped body.
+    def method_missing(method_name, *args, &block)
+      @body.__send__(method_name, *args, &block)
+    end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+  end
+end

data/lib/rack/builder.rb

@@ -1,63 +1,257 @@
+# frozen_string_literal: true
+
 module Rack
   # Rack::Builder implements a small DSL to iteratively construct Rack
   # applications.
   #
   # Example:
   #
-  #  app = Rack::Builder.new {
+  #  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
-  #    lambda { |env| [200, {'Content-Type' => 'text/plain'}, 'OK'] }
+  #    run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
   #  end
   #
-  # +use+ adds a middleware to the stack, +run+ dispatches to an application.
+  #  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 initialize(&block)
-      @ins = []
+
+    # https://stackoverflow.com/questions/2223882/whats-the-difference-between-utf-8-and-utf-8-without-bom
+    UTF_8_BOM = '\xef\xbb\xbf'
+
+    # Parse the given config file to get a Rack application.
+    #
+    # If the config file ends in +.ru+, it is treated as a
+    # rackup file and the contents will be treated as if
+    # specified inside a Rack::Builder block, using the given
+    # options.
+    #
+    # If the config file does not end in +.ru+, it is
+    # required and Rack will use the basename of the file
+    # to guess which constant will be the Rack application to run.
+    # The options given will be ignored in this case.
+    #
+    # Examples:
+    #
+    #   Rack::Builder.parse_file('config.ru')
+    #   # Rack application built using Rack::Builder.new
+    #
+    #   Rack::Builder.parse_file('app.rb')
+    #   # requires app.rb, which can be anywhere in Ruby's
+    #   # load path. After requiring, assumes App constant
+    #   # contains Rack application
+    #
+    #   Rack::Builder.parse_file('./my_app.rb')
+    #   # requires ./my_app.rb, which should be in the
+    #   # process's current directory.  After requiring,
+    #   # assumes MyApp constant contains Rack application
+    def self.parse_file(config, opts = Server::Options.new)
+      if config.end_with?('.ru')
+        return self.load_file(config, opts)
+      else
+        require config
+        app = Object.const_get(::File.basename(config, '.rb').split('_').map(&:capitalize).join(''))
+        return app, {}
+      end
+    end
+
+    # Load the given file as a rackup file, treating the
+    # contents as if specified inside a Rack::Builder block.
+    #
+    # Treats the first comment at the beginning of a line
+    # that starts with a backslash as options similar to
+    # options passed on a rackup command line.
+    #
+    # Ignores content in the file after +__END__+, so that
+    # use of +__END__+ will not result in a syntax error.
+    #
+    # Example config.ru file:
+    #
+    #   $ cat config.ru
+    #
+    #   #\ -p 9393
+    #
+    #   use Rack::ContentLength
+    #   require './app.rb'
+    #   run App
+    def self.load_file(path, opts = Server::Options.new)
+      options = {}
+
+      cfgfile = ::File.read(path)
+      cfgfile.slice!(/\A#{UTF_8_BOM}/) if cfgfile.encoding == Encoding::UTF_8
+
+      if cfgfile[/^#\\(.*)/] && opts
+        warn "Parsing options from the first comment line is deprecated!"
+        options = opts.parse! $1.split(/\s+/)
+      end
+
+      cfgfile.sub!(/^__END__\n.*\Z/m, '')
+      app = new_from_string cfgfile, path
+
+      return app, options
+    end
+
+    # Evaluate the given +builder_script+ string in the context of
+    # a Rack::Builder block, returning a Rack application.
+    def self.new_from_string(builder_script, file = "(rackup)")
+      # We want to build a variant of TOPLEVEL_BINDING with self as a Rack::Builder instance.
+      # We cannot use instance_eval(String) as that would resolve constants differently.
+      binding, builder = TOPLEVEL_BINDING.eval('Rack::Builder.new.instance_eval { [binding, self] }')
+      eval builder_script, binding, file
+      builder.to_app
+    end
+
+    # Initialize a new Rack::Builder instance.  +default_app+ specifies the
+    # default application if +run+ is not called later.  If a block
+    # is given, it is evaluted in the context of the instance.
+    def initialize(default_app = nil, &block)
+      @use, @map, @run, @warmup, @freeze_app = [], nil, default_app, nil, false
       instance_eval(&block) if block_given?
     end
 
-    def self.app(&block)
-      self.new(&block).to_app
+    # Create a new Rack::Builder instance and return the Rack application
+    # generated from it.
+    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)
-      @ins << lambda { |app| middleware.new(app, *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
+    ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
 
+    # 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)
-      @ins << app #lambda { |nothing| app }
+      @run = app
+    end
+
+    # Takes a lambda or block that is used to warm-up the application. This block is called
+    # before the Rack application is returned by to_app.
+    #
+    #   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.  Routes under the mapped path will be sent to
+    # the Rack application specified by run inside the block.  Other requests will be sent to the
+    # default application specified by run outside the block.
+    #
+    #   Rack::Builder.app do
+    #     map '/heartbeat' do
+    #       run Heartbeat
+    #     end
+    #     run App
+    #   end
+    #
+    # The +use+ method can also be used inside the block to specify middleware to run under a specific path:
+    #
+    #   Rack::Builder.app do
+    #     map '/heartbeat' do
+    #       use Middleware
+    #       run Heartbeat
+    #     end
+    #     run App
+    #   end
+    #
+    # This example includes a piece of middleware which will run before +/heartbeat+ requests hit +Heartbeat+.
+    #
+    # Note that providing a +path+ of +/+ will ignore any default application given in a +run+ statement
+    # outside the block.
     def map(path, &block)
-      if @ins.last.kind_of? Hash
-        @ins.last[path] = self.class.new(&block).to_app
-      else
-        @ins << {}
-        map(path, &block)
-      end
+      @map ||= {}
+      @map[path] = block
+    end
+
+    # Freeze the app (set using run) and all middleware instances when building the application
+    # in to_app.
+    def freeze_app
+      @freeze_app = true
     end
 
+    # Return the Rack application generated by this instance.
     def to_app
-      @ins[-1] = Rack::URLMap.new(@ins.last)  if Hash === @ins.last
-      inner_app = @ins.last
-      @ins[0...-1].reverse.inject(inner_app) { |a, e| e.call(a) }
+      app = @map ? generate_map(@run, @map) : @run
+      fail "missing run or map statement" unless app
+      app.freeze if @freeze_app
+      app = @use.reverse.inject(app) { |a, e| e[a].tap { |x| x.freeze if @freeze_app } }
+      @warmup.call(app) if @warmup
+      app
     end
 
+    # Call the Rack application generated by this builder instance. Note that
+    # this rebuilds the Rack application and runs the warmup code (if any)
+    # every time it is called, so it should not be used if performance is important.
     def call(env)
       to_app.call(env)
     end
+
+    private
+
+    # Generate a URLMap instance by generating new Rack applications for each
+    # map block in this instance.
+    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

data/lib/rack/cascade.rb

@@ -1,34 +1,66 @@
+# frozen_string_literal: true
+
 module Rack
-  # Rack::Cascade tries an request on several apps, and returns the
-  # first response that is not 404 (or in a list of configurable
-  # status codes).
+  # Rack::Cascade tries a request on several apps, and returns the
+  # first response that is not 404 or 405 (or in a list of configured
+  # status codes).  If all applications tried return one of the configured
+  # status codes, return the last response.
 
   class Cascade
+    # deprecated, no longer used
+    NotFound = [404, { CONTENT_TYPE => "text/plain" }, []]
+
+    # An array of applications to try in order.
     attr_reader :apps
 
-    def initialize(apps, catch=404)
-      @apps = apps
-      @catch = [*catch]
+    # Set the apps to send requests to, and what statuses result in
+    # cascading.  Arguments:
+    #
+    # apps: An enumerable of rack applications.
+    # cascade_for: The statuses to use cascading for.  If a response is received
+    #              from an app, the next app is tried.
+    def initialize(apps, cascade_for = [404, 405])
+      @apps = []
+      apps.each { |app| add app }
+
+      @cascade_for = {}
+      [*cascade_for].each { |status| @cascade_for[status] = true }
     end
 
+    # Call each app in order.  If the responses uses a status that requires
+    # cascading, try the next app.  If all responses require cascading,
+    # return the response from the last app.
     def call(env)
-      status = headers = body = nil
-      raise ArgumentError, "empty cascade"  if @apps.empty?
-      @apps.each { |app|
-        begin
-          status, headers, body = app.call(env)
-          break  unless @catch.include?(status.to_i)
-        end
-      }
-      [status, headers, body]
+      return [404, { CONTENT_TYPE => "text/plain" }, []] if @apps.empty?
+      result = nil
+      last_body = nil
+
+      @apps.each do |app|
+        # The SPEC says that the body must be closed after it has been iterated
+        # by the server, or if it is replaced by a middleware action. Cascade
+        # replaces the body each time a cascade happens. It is assumed that nil
+        # does not respond to close, otherwise the previous application body
+        # will be closed. The final application body will not be closed, as it
+        # will be passed to the server as a result.
+        last_body.close if last_body.respond_to? :close
+
+        result = app.call(env)
+        return result unless @cascade_for.include?(result[0].to_i)
+        last_body = result[2]
+      end
+
+      result
     end
 
-    def add app
+    # Append an app to the list of apps to cascade.  This app will
+    # be tried last.
+    def add(app)
       @apps << app
     end
 
-    def include? app
-      @apps.include? app
+    # Whether the given app is one of the apps to cascade to.
+    def include?(app)
+      @apps.include?(app)
     end
 
     alias_method :<<, :add

data/lib/rack/chunked.rb

@@ -1,49 +1,117 @@
-require 'rack/utils'
+# frozen_string_literal: true
 
 module Rack
 
   # Middleware that applies chunked transfer encoding to response bodies
   # when the response does not include a Content-Length header.
+  #
+  # This supports the Trailer response header to allow the use of trailing
+  # headers in the chunked encoding.  However, using this requires you manually
+  # specify a response body that supports a +trailers+ method.  Example:
+  #
+  #   [200, { 'Trailer' => 'Expires'}, ["Hello", "World"]]
+  #   # error raised
+  #
+  #   body = ["Hello", "World"]
+  #   def body.trailers
+  #     { 'Expires' => Time.now.to_s }
+  #   end
+  #   [200, { 'Trailer' => 'Expires'}, body]
+  #   # No exception raised
   class Chunked
     include Rack::Utils
 
-    def initialize(app)
-      @app = app
+    # A body wrapper that emits chunked responses.
+    class Body
+      TERM = "\r\n"
+      TAIL = "0#{TERM}"
+
+      # Store the response body to be chunked.
+      def initialize(body)
+        @body = body
+      end
+
+      # For each element yielded by the response body, yield
+      # the element in chunked encoding.
+      def each(&block)
+        term = TERM
+        @body.each do |chunk|
+          size = chunk.bytesize
+          next if size == 0
+
+          yield [size.to_s(16), term, chunk.b, term].join
+        end
+        yield TAIL
+        yield_trailers(&block)
+        yield term
+      end
+
+      # Close the response body if the response body supports it.
+      def close
+        @body.close if @body.respond_to?(:close)
+      end
+
+      private
+
+      # Do nothing as this class does not support trailer headers.
+      def yield_trailers
+      end
     end
 
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = HeaderHash.new(headers)
+    # A body wrapper that emits chunked responses and also supports
+    # sending Trailer headers.  Note that the response body provided to
+    # initialize must have a +trailers+ method that returns a hash
+    # of trailer headers, and the rack response itself should have a
+    # Trailer header listing the headers that the +trailers+ method
+    # will return.
+    class TrailerBody < Body
+      private
 
-      if env['HTTP_VERSION'] == 'HTTP/1.0' ||
-         STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
-         headers['Content-Length'] ||
-         headers['Transfer-Encoding']
-        [status, headers.to_hash, body]
-      else
-        dup.chunk(status, headers, body)
+      # Yield strings for each trailer header.
+      def yield_trailers
+        @body.trailers.each_pair do |k, v|
+          yield "#{k}: #{v}\r\n"
+        end
       end
     end
 
-    def chunk(status, headers, body)
-      @body = body
-      headers.delete('Content-Length')
-      headers['Transfer-Encoding'] = 'chunked'
-      [status, headers.to_hash, self]
+    def initialize(app)
+      @app = app
     end
 
-    def each
-      term = "\r\n"
-      @body.each do |chunk|
-        size = bytesize(chunk)
-        next if size == 0
-        yield [size.to_s(16), term, chunk, term].join
+    # Whether the HTTP version supports chunked encoding (HTTP 1.1 does).
+    def chunkable_version?(ver)
+      case ver
+      # pre-HTTP/1.0 (informally "HTTP/0.9") HTTP requests did not have
+      # a version (nor response headers)
+      when 'HTTP/1.0', nil, 'HTTP/0.9'
+        false
+      else
+        true
       end
-      yield ["0", term, "", term].join
     end
 
-    def close
-      @body.close if @body.respond_to?(:close)
+    # If the rack app returns a response that should have a body,
+    # but does not have Content-Length or Transfer-Encoding headers,
+    # modify the response to use chunked Transfer-Encoding.
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = HeaderHash[headers]
+
+      if chunkable_version?(env[SERVER_PROTOCOL]) &&
+         !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
+         !headers[CONTENT_LENGTH] &&
+         !headers[TRANSFER_ENCODING]
+
+        headers[TRANSFER_ENCODING] = 'chunked'
+        if headers['Trailer']
+          body = TrailerBody.new(body)
+        else
+          body = Body.new(body)
+        end
+      end
+
+      [status, headers, body]
     end
   end
 end