rack 1.0.1 → 2.2.21

data/lib/rack/common_logger.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Rack
+  # Rack::CommonLogger forwards every request to the given +app+, and
+  # logs a line in the
+  # {Apache common log format}[http://httpd.apache.org/docs/1.3/logs.html#common]
+  # to the configured logger.
+  class CommonLogger
+    # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+    #
+    #   lilith.local - - [07/Aug/2006 23:58:02 -0400] "GET / HTTP/1.1" 500 -
+    #
+    #   %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
+    #
+    # The actual format is slightly different than the above due to the
+    # separation of SCRIPT_NAME and PATH_INFO, and because the elapsed
+    # time in seconds is included at the end.
+    FORMAT = %{%s - %s [%s] "%s %s%s%s %s" %d %s %0.4f }
+
+    # +logger+ can be any object that supports the +write+ or +<<+ methods,
+    # which includes the standard library Logger.  These methods are called
+    # with a single string argument, the log message.
+    # If +logger+ is nil, CommonLogger will fall back <tt>env['rack.errors']</tt>.
+    def initialize(app, logger = nil)
+      @app = app
+      @logger = logger
+    end
+
+    # Log all requests in common_log format after a response has been
+    # returned.  Note that if the app raises an exception, the request
+    # will not be logged, so if exception handling middleware are used,
+    # they should be loaded after this middleware.  Additionally, because
+    # the logging happens after the request body has been fully sent, any
+    # exceptions raised during the sending of the response body will
+    # cause the request not to be logged.
+    def call(env)
+      began_at = Utils.clock_time
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash[headers]
+      body = BodyProxy.new(body) { log(env, status, headers, began_at) }
+      [status, headers, body]
+    end
+
+    private
+
+    # Log the request to the configured logger.
+    def log(env, status, header, began_at)
+      length = extract_content_length(header)
+
+      msg = FORMAT % [
+        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+        env["REMOTE_USER"] || "-",
+        Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
+        env[REQUEST_METHOD],
+        env[SCRIPT_NAME],
+        env[PATH_INFO],
+        env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
+        env[SERVER_PROTOCOL],
+        status.to_s[0..3],
+        length,
+        Utils.clock_time - began_at ]
+
+      msg.gsub!(/[^[:print:]]/) { |c| sprintf("\\x%x", c.ord) }
+      msg[-1] = "\n"
+
+      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
+
+    # Attempt to determine the content length for the response to
+    # include it in the logged data.
+    def extract_content_length(headers)
+      value = headers[CONTENT_LENGTH]
+      !value || value.to_s == '0' ? '-' : value
+    end
+  end
+end

data/lib/rack/conditional_get.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Rack
+
+  # Middleware that enables conditional GET using If-None-Match and
+  # If-Modified-Since. The application should set either or both of the
+  # Last-Modified or Etag response headers according to RFC 2616. When
+  # either of the conditions is met, the response body is set to be zero
+  # length and the response status is set to 304 Not Modified.
+  #
+  # Applications that defer response body generation until the body's each
+  # message is received will avoid response body generation completely when
+  # a conditional GET matches.
+  #
+  # Adapted from Michael Klishin's Merb implementation:
+  # 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
+
+    # Return empty 304 response if the response has not been
+    # modified since the last request.
+    def call(env)
+      case env[REQUEST_METHOD]
+      when "GET", "HEAD"
+        status, headers, body = @app.call(env)
+        headers = Utils::HeaderHash[headers]
+        if status == 200 && fresh?(env, headers)
+          status = 304
+          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
+        @app.call(env)
+      end
+    end
+
+  private
+
+    # Return whether the response has not been modified since the
+    # last request.
+    def fresh?(env, headers)
+      # If-None-Match has priority over If-Modified-Since per RFC 7232
+      if none_match = env['HTTP_IF_NONE_MATCH']
+        etag_matches?(none_match, headers)
+      elsif (modified_since = env['HTTP_IF_MODIFIED_SINCE']) && (modified_since = to_rfc2822(modified_since))
+        modified_since?(modified_since, headers)
+      end
+    end
+
+    # Whether the ETag response header matches the If-None-Match request header.
+    # If so, the request has not been modified.
+    def etag_matches?(none_match, headers)
+      headers['ETag'] == none_match
+    end
+
+    # Whether the Last-Modified response header matches the If-Modified-Since
+    # request header.  If so, the request has not been modified.
+    def modified_since?(modified_since, headers)
+      last_modified = to_rfc2822(headers['Last-Modified']) and
+        modified_since >= last_modified
+    end
+
+    # Return a Time object for the given string (which should be in RFC2822
+    # format), or nil if the string cannot be parsed.
+    def to_rfc2822(since)
+      # 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
+      end
+    end
+  end
+end

data/lib/rack/config.rb

@@ -0,0 +1,22 @@
+# 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
+      @block = block
+    end
+
+    def call(env)
+      @block.call(env)
+      @app.call(env)
+    end
+  end
+end

data/lib/rack/content_length.rb

@@ -1,7 +1,11 @@
-require 'rack/utils'
+# frozen_string_literal: true
 
 module Rack
-  # Sets the Content-Length header on responses with fixed-length bodies.
+
+  # Sets the Content-Length header on responses that do not specify
+  # a Content-Length or Transfer-Encoding header.  Note that this
+  # does not fix responses that have an invalid Content-Length
+  # header specified.
   class ContentLength
     include Rack::Utils
 
@@ -11,16 +15,21 @@ module Rack
 
     def call(env)
       status, headers, body = @app.call(env)
-      headers = HeaderHash.new(headers)
+      headers = HeaderHash[headers]
+
+      if !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
+         !headers[CONTENT_LENGTH] &&
+         !headers[TRANSFER_ENCODING]
+
+        obody = body
+        body, length = [], 0
+        obody.each { |part| body << part; length += part.bytesize }
 
-      if !STATUS_WITH_NO_ENTITY_BODY.include?(status) &&
-         !headers['Content-Length'] &&
-         !headers['Transfer-Encoding'] &&
-         (body.respond_to?(:to_ary) || body.respond_to?(:to_str))
+        body = BodyProxy.new(body) do
+          obody.close if obody.respond_to?(:close)
+        end
 
-        body = [body] if body.respond_to?(:to_str) # rack 0.4 compat
-        length = body.to_ary.inject(0) { |len, part| len + bytesize(part) }
-        headers['Content-Length'] = length.to_s
+        headers[CONTENT_LENGTH] = length.to_s
       end
 
       [status, headers, body]

data/lib/rack/content_type.rb

@@ -1,4 +1,4 @@
-require 'rack/utils'
+# frozen_string_literal: true
 
 module Rack
 
@@ -7,17 +7,24 @@ module Rack
   # Builder Usage:
   #   use Rack::ContentType, "text/plain"
   #
-  # When no content type argument is provided, "text/html" is assumed.
+  # When no content type argument is provided, "text/html" is the
+  # default.
   class ContentType
+    include Rack::Utils
+
     def initialize(app, content_type = "text/html")
       @app, @content_type = app, content_type
     end
 
     def call(env)
       status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash.new(headers)
-      headers['Content-Type'] ||= @content_type
-      [status, headers.to_hash, body]
+      headers = Utils::HeaderHash[headers]
+
+      unless STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i)
+        headers[CONTENT_TYPE] ||= @content_type
+      end
+
+      [status, headers, body]
     end
   end
 end

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

data/lib/rack/deflater.rb

@@ -1,32 +1,60 @@
+# frozen_string_literal: true
+
 require "zlib"
-require "stringio"
 require "time"  # for Time.httpdate
-require 'rack/utils'
 
 module Rack
+  # This middleware enables content encoding of http responses,
+  # usually for purposes of compression.
+  #
+  # Currently supported encodings:
+  #
+  # * gzip
+  # * identity (no transformation)
+  #
+  # This middleware automatically detects when encoding is supported
+  # and allowed. For example no encoding is made when a cache
+  # directive of 'no-transform' is present, when the response status
+  # code is one that doesn't allow an entity body, or when the body
+  # is empty.
+  #
+  # Note that despite the name, Deflater does not support the +deflate+
+  # encoding.
   class Deflater
-    def initialize(app)
+    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
+
+    # Creates Rack::Deflater middleware. Options:
+    #
+    # :if :: a lambda enabling / disabling deflation based on returned boolean value
+    #        (e.g <tt>use Rack::Deflater, :if => lambda { |*, body| sum=0; body.each { |i| sum += i.length }; sum > 512 }</tt>).
+    #        However, be aware that calling `body.each` inside the block will break cases where `body.each` is not idempotent,
+    #        such as when it is an +IO+ instance.
+    # :include :: a list of content types that should be compressed. By default, all content types are compressed.
+    # :sync :: determines if the stream is going to be flushed after every chunk.  Flushing after every chunk reduces
+    #          latency for time-sensitive streaming applications, but hurts compression and throughput.
+    #          Defaults to +true+.
+    def initialize(app, options = {})
       @app = app
+      @condition = options[:if]
+      @compressible_types = options[:include]
+      @sync = options.fetch(:sync, true)
     end
 
     def call(env)
       status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash.new(headers)
+      headers = Utils::HeaderHash[headers]
 
-      # Skip compressing empty entity body responses and responses with
-      # no-transform set.
-      if Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
-          headers['Cache-Control'].to_s =~ /\bno-transform\b/
+      unless should_deflate?(env, status, headers, body)
         return [status, headers, body]
       end
 
       request = Request.new(env)
 
-      encoding = Utils.select_best_encoding(%w(gzip deflate identity),
+      encoding = Utils.select_best_encoding(%w(gzip identity),
                                             request.accept_encoding)
 
       # Set the Vary HTTP header.
-      vary = headers["Vary"].to_s.split(",").map { |v| v.strip }
+      vary = headers["Vary"].to_s.split(",").map(&:strip)
       unless vary.include?("*") || vary.include?("Accept-Encoding")
         headers["Vary"] = vary.push("Accept-Encoding").join(",")
       end
@@ -34,63 +62,83 @@ module Rack
       case encoding
       when "gzip"
         headers['Content-Encoding'] = "gzip"
-        headers.delete('Content-Length')
-        mtime = headers.key?("Last-Modified") ?
-          Time.httpdate(headers["Last-Modified"]) : Time.now
-        [status, headers, GzipStream.new(body, mtime)]
-      when "deflate"
-        headers['Content-Encoding'] = "deflate"
-        headers.delete('Content-Length')
-        [status, headers, DeflateStream.new(body)]
+        headers.delete(CONTENT_LENGTH)
+        mtime = headers["Last-Modified"]
+        mtime = Time.httpdate(mtime).to_i if mtime
+        [status, headers, GzipStream.new(body, mtime, @sync)]
       when "identity"
         [status, headers, body]
       when nil
         message = "An acceptable encoding for the requested resource #{request.fullpath} could not be found."
-        [406, {"Content-Type" => "text/plain", "Content-Length" => message.length.to_s}, [message]]
+        bp = Rack::BodyProxy.new([message]) { body.close if body.respond_to?(:close) }
+        [406, { CONTENT_TYPE => "text/plain", CONTENT_LENGTH => message.length.to_s }, bp]
       end
     end
 
+    # Body class used for gzip encoded responses.
     class GzipStream
-      def initialize(body, mtime)
+      # Initialize the gzip stream.  Arguments:
+      # body :: Response body to compress with gzip
+      # mtime :: The modification time of the body, used to set the
+      #          modification time in the gzip header.
+      # sync :: Whether to flush each gzip chunk as soon as it is ready.
+      def initialize(body, mtime, sync)
         @body = body
         @mtime = mtime
+        @sync = sync
       end
 
+      # Yield gzip compressed strings to the given block.
       def each(&block)
         @writer = block
-        gzip  =::Zlib::GzipWriter.new(self)
-        gzip.mtime = @mtime
-        @body.each { |part| gzip.write(part) }
-        @body.close if @body.respond_to?(:close)
+        gzip = ::Zlib::GzipWriter.new(self)
+        gzip.mtime = @mtime if @mtime
+        @body.each { |part|
+          # Skip empty strings, as they would result in no output,
+          # and flushing empty parts would raise Zlib::BufError.
+          next if part.empty?
+
+          gzip.write(part)
+          gzip.flush if @sync
+        }
+      ensure
         gzip.close
-        @writer = nil
       end
 
+      # Call the block passed to #each with the the gzipped data.
       def write(data)
         @writer.call(data)
       end
+
+      # Close the original body if possible.
+      def close
+        @body.close if @body.respond_to?(:close)
+      end
     end
 
-    class DeflateStream
-      DEFLATE_ARGS = [
-        Zlib::DEFAULT_COMPRESSION,
-        # drop the zlib header which causes both Safari and IE to choke
-        -Zlib::MAX_WBITS,
-        Zlib::DEF_MEM_LEVEL,
-        Zlib::DEFAULT_STRATEGY
-      ]
+    private
 
-      def initialize(body)
-        @body = body
+    # Whether the body should be compressed.
+    def should_deflate?(env, status, headers, body)
+      # Skip compressing empty entity body responses and responses with
+      # no-transform set.
+      if Utils::STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) ||
+          /\bno-transform\b/.match?(headers['Cache-Control'].to_s) ||
+          headers['Content-Encoding']&.!~(/\bidentity\b/)
+        return false
       end
 
-      def each
-        deflater = ::Zlib::Deflate.new(*DEFLATE_ARGS)
-        @body.each { |part| yield deflater.deflate(part) }
-        @body.close if @body.respond_to?(:close)
-        yield deflater.finish
-        nil
-      end
+      # Skip if @compressible_types are given and does not include request's content type
+      return false if @compressible_types && !(headers.has_key?('Content-Type') && @compressible_types.include?(headers['Content-Type'][/[^;]*/]))
+
+      # Skip if @condition lambda is given and evaluates to false
+      return false if @condition && !@condition.call(env, status, headers, body)
+
+      # No point in compressing empty body, also handles usage with
+      # Rack::Sendfile.
+      return false if headers[CONTENT_LENGTH] == '0'
+
+      true
     end
   end
 end