rack 1.4.7 → 2.1.4

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   module Auth
     module Digest
@@ -17,7 +19,7 @@ module Rack
         end
 
         def self.split_header_value(str)
-          str.scan( /(\w+\=(?:"[^\"]+"|[^,]+))/n ).collect{ |v| v[0] }
+          str.scan(/\w+\=(?:"[^\"]+"|[^,]+)/n)
         end
 
         def initialize
@@ -38,16 +40,15 @@ module Rack
 
         def to_s
           map do |k, v|
-            "#{k}=" + (UNQUOTED.include?(k) ? v.to_s : quote(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,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack/auth/abstract/request'
 require 'rack/auth/digest/params'
 require 'rack/auth/digest/nonce'
@@ -7,11 +9,11 @@ module Rack
     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?

data/lib/rack/body_proxy.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 module Rack
   class BodyProxy
     def initialize(body, &block)
-      @body, @block, @closed = body, block, false
+      @body = body
+      @block = block
+      @closed = false
     end
 
-    def respond_to?(*args)
-      return false if args.first.to_s =~ /^to_ary$/
-      super or @body.respond_to?(*args)
+    def respond_to?(method_name, include_all = false)
+      super or @body.respond_to?(method_name, include_all)
     end
 
     def close
@@ -27,13 +30,12 @@ module Rack
     # We are applying this special case for #each only. Future bugs of this
     # class will be handled by requesting users to patch their ruby
     # implementation, to save adding too many methods in this class.
-    def each(*args, &block)
-      @body.each(*args, &block)
+    def each
+      @body.each { |body| yield body }
     end
 
-    def method_missing(*args, &block)
-      super if args.first.to_s =~ /^to_ary$/
-      @body.__send__(*args, &block)
+    def method_missing(method_name, *args, &block)
+      @body.__send__(method_name, *args, &block)
     end
   end
 end

data/lib/rack/builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   # Rack::Builder implements a small DSL to iteratively construct Rack
   # applications.
@@ -25,29 +27,47 @@ module Rack
   #
   #  run app
   #
-  # +use+ adds a middleware to the stack, +run+ dispatches to an application.
+  # +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
+
+    # https://stackoverflow.com/questions/2223882/whats-the-difference-between-utf-8-and-utf-8-without-bom
+    UTF_8_BOM = '\xef\xbb\xbf'
+
     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 = eval "Rack::Builder.new {\n" + cfgfile + "\n}.to_app",
-          TOPLEVEL_BINDING, config, 0
+      if config.end_with?('.ru')
+        return self.load_file(config, opts)
       else
         require config
-        app = Object.const_get(::File.basename(config, '.rb').capitalize)
+        app = Object.const_get(::File.basename(config, '.rb').split('_').map(&:capitalize).join(''))
+        return app, {}
+      end
+    end
+
+    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
+        options = opts.parse! $1.split(/\s+/)
       end
+
+      cfgfile.sub!(/^__END__\n.*\Z/m, '')
+      app = new_from_string cfgfile, path
+
       return app, options
     end
 
-    def initialize(default_app = nil,&block)
-      @use, @map, @run = [], nil, default_app
+    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, @freeze_app = [], nil, default_app, nil, false
       instance_eval(&block) if block_given?
     end
 
@@ -55,7 +75,7 @@ module Rack
       self.new(default_app, &block).to_app
     end
 
-    # Specifies a middleware to use in a stack.
+    # Specifies middleware to use in a stack.
     #
     #   class Middleware
     #     def initialize(app)
@@ -69,7 +89,7 @@ module Rack
     #   end
     #
     #   use Middleware
-    #   run lambda { |env| [200, { "Content-Type => "text/plain" }, ["OK"]] }
+    #   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
@@ -77,10 +97,11 @@ module Rack
     def use(middleware, *args, &block)
       if @map
         mapping, @map = @map, nil
-        @use << proc { |app| generate_map app, mapping }
+        @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:
@@ -92,7 +113,7 @@ module Rack
     #   class Heartbeat
     #     def self.call(env)
     #      [200, { "Content-Type" => "text/plain" }, ["OK"]]
-    #    end
+    #     end
     #   end
     #
     #   run Heartbeat
@@ -100,6 +121,19 @@ module Rack
       @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
@@ -124,10 +158,19 @@ module Rack
       @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
+
     def to_app
       app = @map ? generate_map(@run, @map) : @run
       fail "missing run or map statement" unless app
-      @use.reverse.inject(app) { |a,e| e[a] }
+      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
 
     def call(env)
@@ -137,8 +180,8 @@ module Rack
     private
 
     def generate_map(default_app, mapping)
-      mapped = default_app ? {'/' => default_app} : {}
-      mapping.each { |r,b| mapped[r] = self.class.new(default_app, &b) }
+      mapped = default_app ? { '/' => default_app } : {}
+      mapping.each { |r, b| mapped[r] = self.class.new(default_app, &b).to_app }
       URLMap.new(mapped)
     end
   end

data/lib/rack/cascade.rb

@@ -1,15 +1,17 @@
+# 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
+  # Rack::Cascade tries a request on several apps, and returns the
+  # first response that is not 404 or 405 (or in a list of configurable
   # status codes).
 
   class Cascade
-    NotFound = [404, {"Content-Type" => "text/plain"}, []]
+    NotFound = [404, { CONTENT_TYPE => "text/plain" }, []]
 
     attr_reader :apps
 
-    def initialize(apps, catch=[404, 405])
-      @apps = []; @has_app = {}
+    def initialize(apps, catch = [404, 405])
+      @apps = []
       apps.each { |app| add app }
 
       @catch = {}
@@ -38,13 +40,12 @@ module Rack
       result
     end
 
-    def add app
-      @has_app[app] = true
+    def add(app)
       @apps << app
     end
 
-    def include? app
-      @has_app.include? app
+    def include?(app)
+      @apps.include?(app)
     end
 
     alias_method :<<, :add

data/lib/rack/chunked.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack/utils'
 
 module Rack
@@ -10,7 +12,7 @@ module Rack
     # A body wrapper that emits chunked responses
     class Body
       TERM = "\r\n"
-      TAIL = "0#{TERM}#{TERM}"
+      TAIL = "0#{TERM}"
 
       include Rack::Utils
 
@@ -18,40 +20,72 @@ module Rack
         @body = body
       end
 
-      def each
+      def each(&block)
         term = TERM
         @body.each do |chunk|
-          size = bytesize(chunk)
+          size = chunk.bytesize
           next if size == 0
 
-          chunk = chunk.dup.force_encoding(Encoding::BINARY) if chunk.respond_to?(:force_encoding)
+          chunk = chunk.b
           yield [size.to_s(16), term, chunk, term].join
         end
         yield TAIL
+        insert_trailers(&block)
+        yield TERM
       end
 
       def close
         @body.close if @body.respond_to?(:close)
       end
+
+      private
+
+      def insert_trailers(&block)
+      end
+    end
+
+    class TrailerBody < Body
+      private
+
+      def insert_trailers(&block)
+        @body.trailers.each_pair do |k, v|
+          yield "#{k}: #{v}\r\n"
+        end
+      end
     end
 
     def initialize(app)
       @app = app
     end
 
+    # pre-HTTP/1.0 (informally "HTTP/0.9") HTTP requests did not have
+    # a version (nor response headers)
+    def chunkable_version?(ver)
+      case ver
+      when 'HTTP/1.0', nil, 'HTTP/0.9'
+        false
+      else
+        true
+      end
+    end
+
     def call(env)
       status, headers, body = @app.call(env)
       headers = HeaderHash.new(headers)
 
-      if env['HTTP_VERSION'] == 'HTTP/1.0' ||
-         STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
-         headers['Content-Length'] ||
-         headers['Transfer-Encoding']
+      if ! chunkable_version?(env[SERVER_PROTOCOL]) ||
+         STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) ||
+         headers[CONTENT_LENGTH] ||
+         headers[TRANSFER_ENCODING]
         [status, headers, body]
       else
-        headers.delete('Content-Length')
-        headers['Transfer-Encoding'] = 'chunked'
-        [status, headers, Body.new(body)]
+        headers.delete(CONTENT_LENGTH)
+        headers[TRANSFER_ENCODING] = 'chunked'
+        if headers['Trailer']
+          [status, headers, TrailerBody.new(body)]
+        else
+          [status, headers, Body.new(body)]
+        end
       end
     end
   end

data/lib/rack/{commonlogger.rb → common_logger.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack/body_proxy'
 
 module Rack
@@ -10,7 +12,7 @@ module Rack
   # an instance of Rack::NullLogger.
   #
   # +logger+ can be any class, including the standard library Logger, and is
-  # expected to have a +write+ method, which accepts the CommonLogger::FORMAT.
+  # expected to have either +write+ or +<<+ method, which accepts the CommonLogger::FORMAT.
   # According to the SPEC, the error stream must also respond to +puts+
   # (which takes a single argument that responds to +to_s+), and +flush+
   # (which is called without arguments in order to make the error appear for
@@ -18,18 +20,18 @@ module Rack
   class CommonLogger
     # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
     #
-    #   lilith.local - - [07/Aug/2006 23:58:02] "GET / HTTP/1.1" 500 -
+    #   lilith.local - - [07/Aug/2006 23:58:02 -0400] "GET / HTTP/1.1" 500 -
     #
     #   %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
     FORMAT = %{%s - %s [%s] "%s %s%s %s" %d %s %0.4f\n}
 
-    def initialize(app, logger=nil)
+    def initialize(app, logger = nil)
       @app = app
       @logger = logger
     end
 
     def call(env)
-      began_at = Time.now
+      began_at = Utils.clock_time
       status, header, body = @app.call(env)
       header = Utils::HeaderHash.new(header)
       body = BodyProxy.new(body) { log(env, status, header, began_at) }
@@ -39,26 +41,33 @@ module Rack
     private
 
     def log(env, status, header, began_at)
-      now = Time.now
       length = extract_content_length(header)
 
-      logger = @logger || env['rack.errors']
-      logger.write FORMAT % [
+      msg = FORMAT % [
         env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
         env["REMOTE_USER"] || "-",
-        now.strftime("%d/%b/%Y %H:%M:%S"),
-        env["REQUEST_METHOD"],
-        env["PATH_INFO"],
-        env["QUERY_STRING"].empty? ? "" : "?"+env["QUERY_STRING"],
-        env["HTTP_VERSION"],
+        Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
+        env[REQUEST_METHOD],
+        env[PATH_INFO],
+        env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
+        env[SERVER_PROTOCOL],
         status.to_s[0..3],
         length,
-        now - began_at ]
+        Utils.clock_time - began_at ]
+
+      logger = @logger || env[RACK_ERRORS]
+      # Standard library logger doesn't support write but it supports << which actually
+      # calls to write on the log device without formatting
+      if logger.respond_to?(:write)
+        logger.write(msg)
+      else
+        logger << msg
+      end
     end
 
     def extract_content_length(headers)
-      value = headers['Content-Length'] or return '-'
-      value.to_s == '0' ? '-' : value
+      value = headers[CONTENT_LENGTH]
+      !value || value.to_s == '0' ? '-' : value
     end
   end
 end

data/lib/rack/{conditionalget.rb → conditional_get.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack/utils'
 
 module Rack
@@ -13,22 +15,25 @@ module Rack
   # a conditional GET matches.
   #
   # Adapted from Michael Klishin's Merb implementation:
-  # http://github.com/wycats/merb-core/tree/master/lib/merb-core/rack/middleware/conditional_get.rb
+  # https://github.com/wycats/merb/blob/master/merb-core/lib/merb-core/rack/middleware/conditional_get.rb
   class ConditionalGet
     def initialize(app)
       @app = app
     end
 
     def call(env)
-      case env['REQUEST_METHOD']
+      case env[REQUEST_METHOD]
       when "GET", "HEAD"
         status, headers, body = @app.call(env)
         headers = Utils::HeaderHash.new(headers)
         if status == 200 && fresh?(env, headers)
           status = 304
-          headers.delete('Content-Type')
-          headers.delete('Content-Length')
-          body = []
+          headers.delete(CONTENT_TYPE)
+          headers.delete(CONTENT_LENGTH)
+          original_body = body
+          body = Rack::BodyProxy.new([]) do
+            original_body.close if original_body.respond_to?(:close)
+          end
         end
         [status, headers, body]
       else
@@ -61,7 +66,16 @@ module Rack
     end
 
     def to_rfc2822(since)
-      Time.rfc2822(since) rescue nil
+      # shortest possible valid date is the obsolete: 1 Nov 97 09:55 A
+      # anything shorter is invalid, this avoids exceptions for common cases
+      # most common being the empty string
+      if since && since.length >= 16
+        # NOTE: there is no trivial way to write this in a non exception way
+        #   _rfc2822 returns a hash but is not that usable
+        Time.rfc2822(since) rescue nil
+      else
+        nil
+      end
     end
   end
 end

data/lib/rack/config.rb

@@ -1,6 +1,13 @@
+# frozen_string_literal: true
+
 module Rack
   # Rack::Config modifies the environment using the block given during
   # initialization.
+  #
+  # Example:
+  #     use Rack::Config do |env|
+  #       env['my-key'] = 'some-value'
+  #     end
   class Config
     def initialize(app, &block)
       @app = app

data/lib/rack/content_length.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'rack/utils'
+require 'rack/body_proxy'
 
 module Rack
 
@@ -14,17 +17,20 @@ module Rack
       status, headers, body = @app.call(env)
       headers = HeaderHash.new(headers)
 
-      if !STATUS_WITH_NO_ENTITY_BODY.include?(status.to_i) &&
-         !headers['Content-Length'] &&
-         !headers['Transfer-Encoding'] &&
+      if !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
+         !headers[CONTENT_LENGTH] &&
+         !headers[TRANSFER_ENCODING] &&
          body.respond_to?(:to_ary)
 
         obody = body
         body, length = [], 0
-        obody.each { |part| body << part; length += bytesize(part) }
-        obody.close if obody.respond_to?(:close)
+        obody.each { |part| body << part; length += part.bytesize }
+
+        body = BodyProxy.new(body) do
+          obody.close if obody.respond_to?(:close)
+        end
 
-        headers['Content-Length'] = length.to_s
+        headers[CONTENT_LENGTH] = length.to_s
       end
 
       [status, headers, body]

data/lib/rack/content_type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack/utils'
 
 module Rack
@@ -19,8 +21,8 @@ module Rack
       status, headers, body = @app.call(env)
       headers = Utils::HeaderHash.new(headers)
 
-      unless STATUS_WITH_NO_ENTITY_BODY.include?(status)
-        headers['Content-Type'] ||= @content_type
+      unless STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i)
+        headers[CONTENT_TYPE] ||= @content_type
       end
 
       [status, headers, body]

data/lib/rack/core_ext/regexp.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Regexp has `match?` since Ruby 2.4
+# so to support Ruby < 2.4 we need to define this method
+
+module Rack
+  module RegexpExtensions
+    refine Regexp do
+      def match?(string, pos = 0)
+        !!match(string, pos)
+      end
+    end unless //.respond_to?(:match?)
+  end
+end