rack 2.1.3 → 2.2.1

data/lib/rack/etag.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rack'
+require_relative '../rack'
 require 'digest/sha2'
 
 module Rack
@@ -57,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)

data/lib/rack/events.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'rack/response'
-require 'rack/body_proxy'
-
 module Rack
   ### This middleware provides hooks to certain places in the request /
   # response lifecycle.  This is so that middleware that don't need to filter
@@ -59,26 +56,26 @@ module Rack
 
   class Events
     module Abstract
-      def on_start req, res
+      def on_start(req, res)
       end
 
-      def on_commit req, res
+      def on_commit(req, res)
       end
 
-      def on_send req, res
+      def on_send(req, res)
       end
 
-      def on_finish req, res
+      def on_finish(req, res)
       end
 
-      def on_error req, res, e
+      def on_error(req, res, e)
       end
     end
 
     class EventedBodyProxy < Rack::BodyProxy # :nodoc:
       attr_reader :request, :response
 
-      def initialize body, request, response, handlers, &block
+      def initialize(body, request, response, handlers, &block)
         super(body, &block)
         @request  = request
         @response = response
@@ -94,7 +91,7 @@ module Rack
     class BufferedResponse < Rack::Response::Raw # :nodoc:
       attr_reader :body
 
-      def initialize status, headers, body
+      def initialize(status, headers, body)
         super(status, headers)
         @body = body
       end
@@ -102,12 +99,12 @@ module Rack
       def to_a; [status, headers, body]; end
     end
 
-    def initialize app, handlers
+    def initialize(app, handlers)
       @app      = app
       @handlers = handlers
     end
 
-    def call env
+    def call(env)
       request = make_request env
       on_start request, nil
 
@@ -129,27 +126,27 @@ module Rack
 
     private
 
-    def on_error request, response, e
+    def on_error(request, response, e)
       @handlers.reverse_each { |handler| handler.on_error request, response, e }
     end
 
-    def on_commit request, response
+    def on_commit(request, response)
       @handlers.reverse_each { |handler| handler.on_commit request, response }
     end
 
-    def on_start request, response
+    def on_start(request, response)
       @handlers.each { |handler| handler.on_start request, nil }
     end
 
-    def on_finish request, response
+    def on_finish(request, response)
       @handlers.reverse_each { |handler| handler.on_finish request, response }
     end
 
-    def make_request env
+    def make_request(env)
       Rack::Request.new env
     end
 
-    def make_response status, headers, body
+    def make_response(status, headers, body)
       BufferedResponse.new status, headers, body
     end
   end

data/lib/rack/file.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rack/files'
+require_relative 'files'
 
 module Rack
   File = Files

data/lib/rack/files.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
 require 'time'
-require 'rack/utils'
-require 'rack/mime'
-require 'rack/request'
-require 'rack/head'
 
 module Rack
   # Rack::Files serves files below the +root+ directory given, according to the
@@ -18,6 +14,15 @@ module Rack
   class Files
     ALLOWED_VERBS = %w[GET HEAD OPTIONS]
     ALLOW_HEADER = ALLOWED_VERBS.join(', ')
+    MULTIPART_BOUNDARY = 'AaB03x'
+
+    # @todo remove in 3.0
+    def self.method_added(name)
+      if name == :response_body
+        raise "#{self.class}\#response_body is no longer supported."
+      end
+      super
+    end
 
     attr_reader :root
 
@@ -48,7 +53,11 @@ module Rack
       available = begin
         ::File.file?(path) && ::File.readable?(path)
       rescue SystemCallError
+        # Not sure in what conditions this exception can occur, but this
+        # is a safe way to handle such an error.
+        # :nocov:
         false
+        # :nocov:
       end
 
       if available
@@ -70,75 +79,116 @@ module Rack
       headers[CONTENT_TYPE] = mime_type if mime_type
 
       # Set custom headers
-      @headers.each { |field, content| headers[field] = content } if @headers
-
-      response = [ 200, headers ]
+      headers.merge!(@headers) if @headers
 
+      status = 200
       size = filesize path
 
-      range = nil
       ranges = Rack::Utils.get_byte_ranges(request.get_header('HTTP_RANGE'), size)
-      if ranges.nil? || ranges.length > 1
-        # No ranges, or multiple ranges (which we don't support):
-        # TODO: Support multiple byte-ranges
-        response[0] = 200
-        range = 0..size - 1
+      if ranges.nil?
+        # No ranges:
+        ranges = [0..size - 1]
       elsif ranges.empty?
         # Unsatisfiable. Return error, and file size:
         response = fail(416, "Byte range unsatisfiable")
         response[1]["Content-Range"] = "bytes */#{size}"
         return response
-      else
-        # Partial content:
-        range = ranges[0]
-        response[0] = 206
-        response[1]["Content-Range"] = "bytes #{range.begin}-#{range.end}/#{size}"
-        size = range.end - range.begin + 1
+      elsif ranges.size >= 1
+        # Partial content
+        partial_content = true
+
+        if ranges.size == 1
+          range = ranges[0]
+          headers["Content-Range"] = "bytes #{range.begin}-#{range.end}/#{size}"
+        else
+          headers[CONTENT_TYPE] = "multipart/byteranges; boundary=#{MULTIPART_BOUNDARY}"
+        end
+
+        status = 206
+        body = BaseIterator.new(path, ranges, mime_type: mime_type, size: size)
+        size = body.bytesize
       end
 
-      response[2] = [response_body] unless response_body.nil?
+      headers[CONTENT_LENGTH] = size.to_s
 
-      response[1][CONTENT_LENGTH] = size.to_s
-      response[2] = make_body request, path, range
-      response
+      if request.head?
+        body = []
+      elsif !partial_content
+        body = Iterator.new(path, ranges, mime_type: mime_type, size: size)
+      end
+
+      [status, headers, body]
     end
 
-    class Iterator
-      attr_reader :path, :range
-      alias :to_path :path
+    class BaseIterator
+      attr_reader :path, :ranges, :options
 
-      def initialize path, range
-        @path  = path
-        @range = range
+      def initialize(path, ranges, options)
+        @path = path
+        @ranges = ranges
+        @options = options
       end
 
       def each
         ::File.open(path, "rb") do |file|
-          file.seek(range.begin)
-          remaining_len = range.end - range.begin + 1
-          while remaining_len > 0
-            part = file.read([8192, remaining_len].min)
-            break unless part
-            remaining_len -= part.length
-
-            yield part
+          ranges.each do |range|
+            yield multipart_heading(range) if multipart?
+
+            each_range_part(file, range) do |part|
+              yield part
+            end
           end
+
+          yield "\r\n--#{MULTIPART_BOUNDARY}--\r\n" if multipart?
         end
       end
 
+      def bytesize
+        size = ranges.inject(0) do |sum, range|
+          sum += multipart_heading(range).bytesize if multipart?
+          sum += range.size
+        end
+        size += "\r\n--#{MULTIPART_BOUNDARY}--\r\n".bytesize if multipart?
+        size
+      end
+
       def close; end
-    end
 
-    private
+      private
 
-    def make_body request, path, range
-      if request.head?
-        []
-      else
-        Iterator.new path, range
+      def multipart?
+        ranges.size > 1
+      end
+
+      def multipart_heading(range)
+<<-EOF
+\r
+--#{MULTIPART_BOUNDARY}\r
+Content-Type: #{options[:mime_type]}\r
+Content-Range: bytes #{range.begin}-#{range.end}/#{options[:size]}\r
+\r
+EOF
+      end
+
+      def each_range_part(file, range)
+        file.seek(range.begin)
+        remaining_len = range.end - range.begin + 1
+        while remaining_len > 0
+          part = file.read([8192, remaining_len].min)
+          break unless part
+          remaining_len -= part.length
+
+          yield part
+        end
       end
     end
 
+    class Iterator < BaseIterator
+      alias :to_path :path
+    end
+
+    private
+
     def fail(status, body, headers = {})
       body += "\n"
 
@@ -154,25 +204,15 @@ module Rack
     end
 
     # The MIME type for the contents of the file located at @path
-    def mime_type path, default_mime
+    def mime_type(path, default_mime)
       Mime.mime_type(::File.extname(path), default_mime)
     end
 
-    def filesize path
-      # If response_body is present, use its size.
-      return response_body.bytesize if response_body
-
+    def filesize(path)
       #   We check via File::size? whether this file provides size info
       #   via stat (e.g. /proc files often don't), otherwise we have to
       #   figure it out by reading the whole file into memory.
       ::File.size?(path) || ::File.read(path).bytesize
     end
-
-    # By default, the response body for file requests is nil.
-    # In this case, the response body will be generated later
-    # from the file at @path
-    def response_body
-      nil
-    end
   end
 end

data/lib/rack/handler/cgi.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
-require 'rack/content_length'
-require 'rack/rewindable_input'
-
 module Rack
   module Handler
     class CGI
-      def self.run(app, options = nil)
+      def self.run(app, **options)
         $stdin.binmode
         serve app
       end

data/lib/rack/handler/fastcgi.rb

@@ -2,8 +2,6 @@
 
 require 'fcgi'
 require 'socket'
-require 'rack/content_length'
-require 'rack/rewindable_input'
 
 if defined? FCGI::Stream
   class FCGI::Stream
@@ -20,7 +18,7 @@ end
 module Rack
   module Handler
     class FastCGI
-      def self.run(app, options = {})
+      def self.run(app, **options)
         if options[:File]
           STDIN.reopen(UNIXServer.new(options[:File]))
         elsif options[:Port]

data/lib/rack/handler/lsws.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
 require 'lsapi'
-require 'rack/content_length'
-require 'rack/rewindable_input'
 
 module Rack
   module Handler
     class LSWS
-      def self.run(app, options = nil)
+      def self.run(app, **options)
         while LSAPI.accept != nil
           serve app
         end

data/lib/rack/handler/scgi.rb

@@ -2,15 +2,13 @@
 
 require 'scgi'
 require 'stringio'
-require 'rack/content_length'
-require 'rack/chunked'
 
 module Rack
   module Handler
     class SCGI < ::SCGI::Processor
       attr_accessor :app
 
-      def self.run(app, options = nil)
+      def self.run(app, **options)
         options[:Socket] = UNIXServer.new(options[:File]) if options[:File]
         new(options.merge(app: app,
                           host: options[:Host],

data/lib/rack/handler/thin.rb

@@ -4,24 +4,28 @@ require "thin"
 require "thin/server"
 require "thin/logging"
 require "thin/backends/tcp_server"
-require "rack/content_length"
-require "rack/chunked"
 
 module Rack
   module Handler
     class Thin
-      def self.run(app, options = {})
+      def self.run(app, **options)
         environment  = ENV['RACK_ENV'] || 'development'
         default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
 
-        host = options.delete(:Host) || default_host
-        port = options.delete(:Port) || 8080
-        args = [host, port, app, options]
-        # Thin versions below 0.8.0 do not support additional options
-        args.pop if ::Thin::VERSION::MAJOR < 1 && ::Thin::VERSION::MINOR < 8
-        server = ::Thin::Server.new(*args)
-        yield server if block_given?
-        server.start
+        if block_given?
+          host = options.delete(:Host) || default_host
+          port = options.delete(:Port) || 8080
+          args = [host, port, app, options]
+          # Thin versions below 0.8.0 do not support additional options
+          args.pop if ::Thin::VERSION::MAJOR < 1 && ::Thin::VERSION::MINOR < 8
+          server = ::Thin::Server.new(*args)
+          yield server
+          server.start
+        else
+          options[:address] = options[:Host] || default_host
+          options[:port] = options[:Port] || 8080
+          ::Thin::Controllers::Controller.new(options).start
+        end
       end
 
       def self.valid_options