rack 1.6.13 → 2.2.3

data/lib/rack/content_length.rb

@@ -1,9 +1,11 @@
-require 'rack/utils'
-require 'rack/body_proxy'
+# 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
 
@@ -13,16 +15,15 @@ module Rack
 
     def call(env)
       status, headers, body = @app.call(env)
-      headers = HeaderHash.new(headers)
+      headers = HeaderHash[headers]
 
-      if !STATUS_WITH_NO_ENTITY_BODY.include?(status.to_i) &&
+      if !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
          !headers[CONTENT_LENGTH] &&
-         !headers['Transfer-Encoding'] &&
-         body.respond_to?(:to_ary)
+         !headers[TRANSFER_ENCODING]
 
         obody = body
         body, length = [], 0
-        obody.each { |part| body << part; length += bytesize(part) }
+        obody.each { |part| body << part; length += part.bytesize }
 
         body = BodyProxy.new(body) do
           obody.close if obody.respond_to?(:close)

data/lib/rack/content_type.rb

@@ -1,4 +1,4 @@
-require 'rack/utils'
+# frozen_string_literal: true
 
 module Rack
 
@@ -7,7 +7,8 @@ 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
 
@@ -17,9 +18,9 @@ module Rack
 
     def call(env)
       status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash.new(headers)
+      headers = Utils::HeaderHash[headers]
 
-      unless STATUS_WITH_NO_ENTITY_BODY.include?(status)
+      unless STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i)
         headers[CONTENT_TYPE] ||= @content_type
       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,39 +1,48 @@
+# frozen_string_literal: true
+
 require "zlib"
 require "time"  # for Time.httpdate
-require 'rack/utils'
 
 module Rack
-  # This middleware enables compression of http responses.
+  # This middleware enables content encoding of http responses,
+  # usually for purposes of compression.
+  #
+  # Currently supported encodings:
   #
-  # Currently supported compression algorithms:
+  # * gzip
+  # * identity (no transformation)
   #
-  #   * gzip
-  #   * deflate
-  #   * 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.
   #
-  # The middleware automatically detects when compression is supported
-  # and allowed. For example no transformation is made when a cache
-  # directive of 'no-transform' is present, or when the response status
-  # code is one that doesn't allow an entity body.
+  # Note that despite the name, Deflater does not support the +deflate+
+  # encoding.
   class Deflater
-    ##
-    # Creates Rack::Deflater middleware.
+    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
+
+    # Creates Rack::Deflater middleware. Options:
     #
-    # [app] rack app instance
-    # [options] hash of deflater options, i.e.
-    #           'if' - a lambda enabling / disabling deflation based on returned boolean value
-    #                  e.g use Rack::Deflater, :if => lambda { |env, status, headers, body| body.length > 512 }
-    #           'include' - a list of content types that should be compressed
+    # :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]
 
       unless should_deflate?(env, status, headers, body)
         return [status, headers, body]
@@ -41,11 +50,11 @@ module Rack
 
       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
@@ -54,91 +63,68 @@ module Rack
       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)]
+        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."
         bp = Rack::BodyProxy.new([message]) { body.close if body.respond_to?(:close) }
-        [406, {CONTENT_TYPE => "text/plain", CONTENT_LENGTH => message.length.to_s}, bp]
+        [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
-        @closed = false
+        @sync = sync
       end
 
+      # Yield gzip compressed strings to the given block.
       def each(&block)
         @writer = block
-        gzip  =::Zlib::GzipWriter.new(self)
-        gzip.mtime = @mtime
+        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
+          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
-        return if @closed
-        @closed = true
-        @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
-      ]
-
-      def initialize(body)
-        @body = body
-        @closed = false
-      end
-
-      def each
-        deflator = ::Zlib::Deflate.new(*DEFLATE_ARGS)
-        @body.each { |part| yield deflator.deflate(part, Zlib::SYNC_FLUSH) }
-        yield deflator.finish
-        nil
-      ensure
-        deflator.close
-      end
-
-      def close
-        return if @closed
-        @closed = true
         @body.close if @body.respond_to?(:close)
       end
     end
 
     private
 
+    # 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.include?(status) ||
-          headers[CACHE_CONTROL].to_s =~ /\bno-transform\b/ ||
-         (headers['Content-Encoding'] && headers['Content-Encoding'] !~ /\bidentity\b/)
+      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
 
@@ -148,6 +134,10 @@ module Rack
       # 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

data/lib/rack/directory.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
+
 require 'time'
-require 'rack/utils'
-require 'rack/mime'
 
 module Rack
   # Rack::Directory serves entries below the +root+ given, according to the
@@ -8,11 +8,11 @@ module Rack
   # will be presented in an html based index. If a file is found, the env will
   # be passed to the specified +app+.
   #
-  # If +app+ is not specified, a Rack::File of the same +root+ will be used.
+  # If +app+ is not specified, a Rack::Files of the same +root+ will be used.
 
   class Directory
-    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>"
-    DIR_PAGE = <<-PAGE
+    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>\n"
+    DIR_PAGE_HEADER = <<-PAGE
 <html><head>
   <title>%s</title>
   <meta http-equiv="content-type" content="text/html; charset=utf-8" />
@@ -33,116 +33,153 @@ table { width:100%%; }
     <th class='type'>Type</th>
     <th class='mtime'>Last Modified</th>
   </tr>
-%s
+    PAGE
+    DIR_PAGE_FOOTER = <<-PAGE
 </table>
 <hr />
 </body></html>
     PAGE
 
-    attr_reader :files
-    attr_accessor :root, :path
+    # Body class for directory entries, showing an index page with links
+    # to each file.
+    class DirectoryBody < Struct.new(:root, :path, :files)
+      # Yield strings for each part of the directory entry
+      def each
+        show_path = Utils.escape_html(path.sub(/^#{root}/, ''))
+        yield(DIR_PAGE_HEADER % [ show_path, show_path ])
+
+        unless path.chomp('/') == root
+          yield(DIR_FILE % DIR_FILE_escape(files.call('..')))
+        end
+
+        Dir.foreach(path) do |basename|
+          next if basename.start_with?('.')
+          next unless f = files.call(basename)
+          yield(DIR_FILE % DIR_FILE_escape(f))
+        end
+
+        yield(DIR_PAGE_FOOTER)
+      end
+
+      private
 
-    def initialize(root, app=nil)
-      @root = F.expand_path(root)
-      @app = app || Rack::File.new(@root)
+      # Escape each element in the array of html strings.
+      def DIR_FILE_escape(htmls)
+        htmls.map { |e| Utils.escape_html(e) }
+      end
     end
 
-    def call(env)
-      dup._call(env)
+    # The root of the directory hierarchy.  Only requests for files and
+    # directories inside of the root directory are supported.
+    attr_reader :root
+
+    # Set the root directory and application for serving files.
+    def initialize(root, app = nil)
+      @root = ::File.expand_path(root)
+      @app = app || Files.new(@root)
+      @head = Head.new(method(:get))
     end
 
-    F = ::File
+    def call(env)
+      # strip body if this is a HEAD call
+      @head.call env
+    end
 
-    def _call(env)
-      @env = env
-      @script_name = env[SCRIPT_NAME]
-      @path_info = Utils.unescape(env[PATH_INFO])
+    # Internals of request handling.  Similar to call but does
+    # not remove body for HEAD requests.
+    def get(env)
+      script_name = env[SCRIPT_NAME]
+      path_info = Utils.unescape_path(env[PATH_INFO])
 
-      if forbidden = check_forbidden
-        forbidden
+      if client_error_response = check_bad_request(path_info) || check_forbidden(path_info)
+        client_error_response
       else
-        @path = F.join(@root, @path_info)
-        list_path
+        path = ::File.join(@root, path_info)
+        list_path(env, path, path_info, script_name)
       end
     end
 
-    def check_forbidden
-      return unless @path_info.include? ".."
+    # Rack response to use for requests with invalid paths, or nil if path is valid.
+    def check_bad_request(path_info)
+      return if Utils.valid_path?(path_info)
 
-      body = "Forbidden\n"
-      size = Rack::Utils.bytesize(body)
-      return [403, {"Content-Type" => "text/plain",
-        CONTENT_LENGTH => size.to_s,
-        "X-Cascade" => "pass"}, [body]]
+      body = "Bad Request\n"
+      [400, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "X-Cascade" => "pass" }, [body]]
     end
 
-    def list_directory
-      @files = [['../','Parent Directory','','','']]
-      glob = F.join(@path, '*')
+    # Rack response to use for requests with paths outside the root, or nil if path is inside the root.
+    def check_forbidden(path_info)
+      return unless path_info.include? ".."
+      return if ::File.expand_path(::File.join(@root, path_info)).start_with?(@root)
+
+      body = "Forbidden\n"
+      [403, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "X-Cascade" => "pass" }, [body]]
+    end
 
-      url_head = (@script_name.split('/') + @path_info.split('/')).map do |part|
-        Rack::Utils.escape part
+    # Rack response to use for directories under the root.
+    def list_directory(path_info, path, script_name)
+      url_head = (script_name.split('/') + path_info.split('/')).map do |part|
+        Utils.escape_path part
       end
 
-      Dir[glob].sort.each do |node|
-        stat = stat(node)
-        next  unless stat
-        basename = F.basename(node)
-        ext = F.extname(node)
+      # Globbing not safe as path could contain glob metacharacters
+      body = DirectoryBody.new(@root, path, ->(basename) do
+        stat = stat(::File.join(path, basename))
+        next unless stat
 
-        url = F.join(*url_head + [Rack::Utils.escape(basename)])
-        size = stat.size
-        type = stat.directory? ? 'directory' : Mime.mime_type(ext)
-        size = stat.directory? ? '-' : filesize_format(size)
+        url = ::File.join(*url_head + [Utils.escape_path(basename)])
         mtime = stat.mtime.httpdate
-        url << '/'  if stat.directory?
-        basename << '/'  if stat.directory?
-
-        @files << [ url, basename, size, type, mtime ]
-      end
-
-      return [ 200, { CONTENT_TYPE =>'text/html; charset=utf-8'}, self ]
+        if stat.directory?
+          type = 'directory'
+          size = '-'
+          url << '/'
+          if basename == '..'
+            basename = 'Parent Directory'
+          else
+            basename << '/'
+          end
+        else
+          type = Mime.mime_type(::File.extname(basename))
+          size = filesize_format(stat.size)
+        end
+
+        [ url, basename, size, type, mtime ]
+      end)
+
+      [ 200, { CONTENT_TYPE => 'text/html; charset=utf-8' }, body ]
     end
 
-    def stat(node, max = 10)
-      F.stat(node)
+    # File::Stat for the given path, but return nil for missing/bad entries.
+    def stat(path)
+      ::File.stat(path)
     rescue Errno::ENOENT, Errno::ELOOP
       return nil
     end
 
-    # TODO: add correct response if not readable, not sure if 404 is the best
-    #       option
-    def list_path
-      @stat = F.stat(@path)
-
-      if @stat.readable?
-        return @app.call(@env) if @stat.file?
-        return list_directory if @stat.directory?
-      else
-        raise Errno::ENOENT, 'No such file or directory'
+    # Rack response to use for files and directories under the root.
+    # Unreadable and non-file, non-directory entries will get a 404 response.
+    def list_path(env, path, path_info, script_name)
+      if (stat = stat(path)) && stat.readable?
+        return @app.call(env) if stat.file?
+        return list_directory(path_info, path, script_name) if stat.directory?
       end
 
-    rescue Errno::ENOENT, Errno::ELOOP
-      return entity_not_found
-    end
-
-    def entity_not_found
-      body = "Entity not found: #{@path_info}\n"
-      size = Rack::Utils.bytesize(body)
-      return [404, {"Content-Type" => "text/plain",
-        CONTENT_LENGTH => size.to_s,
-        "X-Cascade" => "pass"}, [body]]
+      entity_not_found(path_info)
     end
 
-    def each
-      show_path = Rack::Utils.escape_html(@path.sub(/^#{@root}/,''))
-      files = @files.map{|f| DIR_FILE % DIR_FILE_escape(*f) }*"\n"
-      page  = DIR_PAGE % [ show_path, show_path , files ]
-      page.each_line{|l| yield l }
+    # Rack response to use for unreadable and non-file, non-directory entries.
+    def entity_not_found(path_info)
+      body = "Entity not found: #{path_info}\n"
+      [404, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "X-Cascade" => "pass" }, [body]]
     end
 
     # Stolen from Ramaze
-
     FILESIZE_FORMAT = [
       ['%.1fT', 1 << 40],
       ['%.1fG', 1 << 30],
@@ -150,18 +187,13 @@ table { width:100%%; }
       ['%.1fK', 1 << 10],
     ]
 
+    # Provide human readable file sizes
     def filesize_format(int)
       FILESIZE_FORMAT.each do |format, size|
         return format % (int.to_f / size) if int >= size
       end
 
-      int.to_s + 'B'
-    end
-
-    private
-    # Assumes url is already escaped.
-    def DIR_FILE_escape url, *html
-      [url, *html.map { |e| Utils.escape_html(e) }]
+      "#{int}B"
     end
   end
 end

data/lib/rack/etag.rb

@@ -1,4 +1,7 @@
-require 'digest/md5'
+# frozen_string_literal: true
+
+require_relative '../rack'
+require 'digest/sha2'
 
 module Rack
   # Automatically sets the ETag header on all String bodies.
@@ -11,8 +14,8 @@ module Rack
   # used when Etag is absent and a directive when it is present. The first
   # defaults to nil, while the second defaults to "max-age=0, private, must-revalidate"
   class ETag
-    ETAG_STRING = 'ETag'.freeze
-    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate".freeze
+    ETAG_STRING = Rack::ETAG
+    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
 
     def initialize(app, no_cache_control = nil, cache_control = DEFAULT_CACHE_CONTROL)
       @app = app
@@ -54,8 +57,7 @@ module Rack
       end
 
       def skip_caching?(headers)
-        (headers[CACHE_CONTROL] && headers[CACHE_CONTROL].include?('no-cache')) ||
-          headers.key?(ETAG_STRING) || headers.key?('Last-Modified')
+        headers.key?(ETAG_STRING) || headers.key?('Last-Modified')
       end
 
       def digest_body(body)
@@ -64,10 +66,10 @@ module Rack
 
         body.each do |part|
           parts << part
-          (digest ||= Digest::MD5.new) << part unless part.empty?
+          (digest ||= Digest::SHA256.new) << part unless part.empty?
         end
 
-        [digest && digest.hexdigest, parts]
+        [digest && digest.hexdigest.byteslice(0, 32), parts]
       end
   end
 end