rack 1.0.1 → 2.2.21

data/lib/rack/response.rb

@@ -1,183 +1,318 @@
-require 'rack/request'
-require 'rack/utils'
+# frozen_string_literal: true
+
+require 'time'
 
 module Rack
   # Rack::Response provides a convenient interface to create a Rack
   # response.
   #
   # It allows setting of headers and cookies, and provides useful
-  # defaults (a OK response containing HTML).
+  # defaults (an OK response with empty headers and body).
   #
   # You can use Response#write to iteratively generate your response,
   # but note that this is buffered by Rack::Response until you call
   # +finish+.  +finish+ however can take a block inside which calls to
-  # +write+ are syncronous with the Rack response.
+  # +write+ are synchronous with the Rack response.
   #
   # Your application's +call+ should end returning Response#finish.
-
   class Response
-    attr_accessor :length
-
-    def initialize(body=[], status=200, header={}, &block)
-      @status = status
-      @header = Utils::HeaderHash.new({"Content-Type" => "text/html"}.
-                                      merge(header))
-
-      @writer = lambda { |x| @body << x }
-      @block = nil
-      @length = 0
+    def self.[](status, headers, body)
+      self.new(body, status, headers)
+    end
 
-      @body = []
+    CHUNKED = 'chunked'
+    STATUS_WITH_NO_ENTITY_BODY = Utils::STATUS_WITH_NO_ENTITY_BODY
 
-      if body.respond_to? :to_str
-        write body.to_str
-      elsif body.respond_to?(:each)
-        body.each { |part|
-          write part.to_s
-        }
-      else
-        raise TypeError, "stringable or iterable required"
-      end
-
-      yield self  if block_given?
-    end
+    attr_accessor :length, :status, :body
+    attr_reader :headers
 
-    attr_reader :header
-    attr_accessor :status, :body
+    # @deprecated Use {#headers} instead.
+    alias header headers
 
-    def [](key)
-      header[key]
-    end
+    # Initialize the response object with the specified body, status
+    # and headers.
+    #
+    # @param body [nil, #each, #to_str] the response body.
+    # @param status [Integer] the integer status as defined by the
+    # HTTP protocol RFCs.
+    # @param headers [#each] a list of key-value header pairs which
+    # conform to the HTTP protocol RFCs.
+    #
+    # Providing a body which responds to #to_str is legacy behaviour.
+    def initialize(body = nil, status = 200, headers = {})
+      @status = status.to_i
+      @headers = Utils::HeaderHash[headers]
 
-    def []=(key, value)
-      header[key] = value
-    end
+      @writer = self.method(:append)
 
-    def set_cookie(key, value)
-      case value
-      when Hash
-        domain  = "; domain="  + value[:domain]    if value[:domain]
-        path    = "; path="    + value[:path]      if value[:path]
-        # According to RFC 2109, we need dashes here.
-        # N.B.: cgi.rb uses spaces...
-        expires = "; expires=" + value[:expires].clone.gmtime.
-          strftime("%a, %d-%b-%Y %H:%M:%S GMT")    if value[:expires]
-        secure = "; secure"  if value[:secure]
-        httponly = "; HttpOnly" if value[:httponly]
-        value = value[:value]
-      end
-      value = [value]  unless Array === value
-      cookie = Utils.escape(key) + "=" +
-        value.map { |v| Utils.escape v }.join("&") +
-        "#{domain}#{path}#{expires}#{secure}#{httponly}"
-
-      case self["Set-Cookie"]
-      when Array
-        self["Set-Cookie"] << cookie
-      when String
-        self["Set-Cookie"] = [self["Set-Cookie"], cookie]
-      when nil
-        self["Set-Cookie"] = cookie
-      end
-    end
+      @block = nil
 
-    def delete_cookie(key, value={})
-      unless Array === self["Set-Cookie"]
-        self["Set-Cookie"] = [self["Set-Cookie"]].compact
+      # Keep track of whether we have expanded the user supplied body.
+      if body.nil?
+        @body = []
+        @buffered = true
+        @length = 0
+      elsif body.respond_to?(:to_str)
+        @body = [body]
+        @buffered = true
+        @length = body.to_str.bytesize
+      else
+        @body = body
+        @buffered = false
+        @length = 0
       end
 
-      self["Set-Cookie"].reject! { |cookie|
-        cookie =~ /\A#{Utils.escape(key)}=/
-      }
-
-      set_cookie(key,
-                 {:value => '', :path => nil, :domain => nil,
-                   :expires => Time.at(0) }.merge(value))
+      yield self if block_given?
     end
 
-    def redirect(target, status=302)
+    def redirect(target, status = 302)
       self.status = status
-      self["Location"] = target
+      self.location = target
     end
 
-    def finish(&block)
-      @block = block
+    def chunked?
+      CHUNKED == get_header(TRANSFER_ENCODING)
+    end
 
-      if [204, 304].include?(status.to_i)
-        header.delete "Content-Type"
-        [status.to_i, header.to_hash, []]
+    # Generate a response array consistent with the requirements of the SPEC.
+    # @return [Array] a 3-tuple suitable of `[status, headers, body]`
+    # which is suitable to be returned from the middleware `#call(env)` method.
+    def finish(&block)
+      if STATUS_WITH_NO_ENTITY_BODY[status.to_i]
+        delete_header CONTENT_TYPE
+        delete_header CONTENT_LENGTH
+        close
+        return [@status, @headers, []]
       else
-        [status.to_i, header.to_hash, self]
+        if block_given?
+          @block = block
+          return [@status, @headers, self]
+        else
+          return [@status, @headers, @body]
+        end
       end
     end
+
     alias to_a finish           # For *response
 
     def each(&callback)
       @body.each(&callback)
-      @writer = callback
-      @block.call(self)  if @block
+      @buffered = true
+
+      if @block
+        @writer = callback
+        @block.call(self)
+      end
     end
 
     # Append to body and update Content-Length.
     #
     # NOTE: Do not mix #write and direct #body access!
     #
-    def write(str)
-      s = str.to_s
-      @length += Rack::Utils.bytesize(s)
-      @writer.call s
+    def write(chunk)
+      buffered_body!
 
-      header["Content-Length"] = @length.to_s
-      str
+      @writer.call(chunk.to_s)
     end
 
     def close
-      body.close if body.respond_to?(:close)
+      @body.close if @body.respond_to?(:close)
     end
 
     def empty?
       @block == nil && @body.empty?
     end
 
-    alias headers header
+    def has_header?(key);   headers.key? key;   end
+    def get_header(key);    headers[key];       end
+    def set_header(key, v); headers[key] = v;   end
+    def delete_header(key); headers.delete key; end
+
+    alias :[] :get_header
+    alias :[]= :set_header
 
     module Helpers
-      def invalid?;       @status < 100 || @status >= 600;       end
+      def invalid?;             status < 100 || status >= 600;        end
+
+      def informational?;       status >= 100 && status < 200;        end
+      def successful?;          status >= 200 && status < 300;        end
+      def redirection?;         status >= 300 && status < 400;        end
+      def client_error?;        status >= 400 && status < 500;        end
+      def server_error?;        status >= 500 && status < 600;        end
+
+      def ok?;                  status == 200;                        end
+      def created?;             status == 201;                        end
+      def accepted?;            status == 202;                        end
+      def no_content?;          status == 204;                        end
+      def moved_permanently?;   status == 301;                        end
+      def bad_request?;         status == 400;                        end
+      def unauthorized?;        status == 401;                        end
+      def forbidden?;           status == 403;                        end
+      def not_found?;           status == 404;                        end
+      def method_not_allowed?;  status == 405;                        end
+      def precondition_failed?; status == 412;                        end
+      def unprocessable?;       status == 422;                        end
+
+      def redirect?;            [301, 302, 303, 307, 308].include? status; end
 
-      def informational?; @status >= 100 && @status < 200;       end
-      def successful?;    @status >= 200 && @status < 300;       end
-      def redirection?;   @status >= 300 && @status < 400;       end
-      def client_error?;  @status >= 400 && @status < 500;       end
-      def server_error?;  @status >= 500 && @status < 600;       end
+      def include?(header)
+        has_header? header
+      end
 
-      def ok?;            @status == 200;                        end
-      def forbidden?;     @status == 403;                        end
-      def not_found?;     @status == 404;                        end
+      # Add a header that may have multiple values.
+      #
+      # Example:
+      #   response.add_header 'Vary', 'Accept-Encoding'
+      #   response.add_header 'Vary', 'Cookie'
+      #
+      #   assert_equal 'Accept-Encoding,Cookie', response.get_header('Vary')
+      #
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+      def add_header(key, v)
+        if v.nil?
+          get_header key
+        elsif has_header? key
+          set_header key, "#{get_header key},#{v}"
+        else
+          set_header key, v
+        end
+      end
 
-      def redirect?;      [301, 302, 303, 307].include? @status; end
-      def empty?;         [201, 204, 304].include?      @status; end
+      # Get the content type of the response.
+      def content_type
+        get_header CONTENT_TYPE
+      end
 
-      # Headers
-      attr_reader :headers, :original_headers
+      # Set the content type of the response.
+      def content_type=(content_type)
+        set_header CONTENT_TYPE, content_type
+      end
 
-      def include?(header)
-        !!headers[header]
+      def media_type
+        MediaType.type(content_type)
       end
 
-      def content_type
-        headers["Content-Type"]
+      def media_type_params
+        MediaType.params(content_type)
       end
 
       def content_length
-        cl = headers["Content-Length"]
+        cl = get_header CONTENT_LENGTH
         cl ? cl.to_i : cl
       end
 
       def location
-        headers["Location"]
+        get_header "Location"
+      end
+
+      def location=(location)
+        set_header "Location", location
+      end
+
+      def set_cookie(key, value)
+        cookie_header = get_header SET_COOKIE
+        set_header SET_COOKIE, ::Rack::Utils.add_cookie_to_header(cookie_header, key, value)
+      end
+
+      def delete_cookie(key, value = {})
+        set_header SET_COOKIE, ::Rack::Utils.add_remove_cookie_to_header(get_header(SET_COOKIE), key, value)
+      end
+
+      def set_cookie_header
+        get_header SET_COOKIE
+      end
+
+      def set_cookie_header=(v)
+        set_header SET_COOKIE, v
+      end
+
+      def cache_control
+        get_header CACHE_CONTROL
+      end
+
+      def cache_control=(v)
+        set_header CACHE_CONTROL, v
+      end
+
+      # Specifies that the content shouldn't be cached. Overrides `cache!` if already called.
+      def do_not_cache!
+        set_header CACHE_CONTROL, "no-cache, must-revalidate"
+        set_header EXPIRES, Time.now.httpdate
+      end
+
+      # Specify that the content should be cached.
+      # @param duration [Integer] The number of seconds until the cache expires.
+      # @option directive [String] The cache control directive, one of "public", "private", "no-cache" or "no-store".
+      def cache!(duration = 3600, directive: "public")
+        unless headers[CACHE_CONTROL] =~ /no-cache/
+          set_header CACHE_CONTROL, "#{directive}, max-age=#{duration}"
+          set_header EXPIRES, (Time.now + duration).httpdate
+        end
+      end
+
+      def etag
+        get_header ETAG
+      end
+
+      def etag=(v)
+        set_header ETAG, v
+      end
+
+    protected
+
+      def buffered_body!
+        return if @buffered
+
+        if @body.is_a?(Array)
+          # The user supplied body was an array:
+          @body = @body.compact
+          @body.each do |part|
+            @length += part.to_s.bytesize
+          end
+        else
+          # Turn the user supplied body into a buffered array:
+          body = @body
+          @body = Array.new
+
+          body.each do |part|
+            @writer.call(part.to_s)
+          end
+
+          body.close if body.respond_to?(:close)
+        end
+
+        @buffered = true
+      end
+
+      def append(chunk)
+        @body << chunk
+
+        unless chunked?
+          @length += chunk.bytesize
+          set_header(CONTENT_LENGTH, @length.to_s)
+        end
+
+        return chunk
       end
     end
 
     include Helpers
+
+    class Raw
+      include Helpers
+
+      attr_reader :headers
+      attr_accessor :status
+
+      def initialize(status, headers)
+        @status = status
+        @headers = headers
+      end
+
+      def has_header?(key);   headers.key? key;   end
+      def get_header(key);    headers[key];       end
+      def set_header(key, v); headers[key] = v;   end
+      def delete_header(key); headers.delete key; end
+    end
   end
 end

data/lib/rack/rewindable_input.rb

@@ -1,3 +1,6 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: true
+
 require 'tempfile'
 
 module Rack
@@ -16,29 +19,29 @@ module Rack
       @rewindable_io = nil
       @unlinked = false
     end
-    
+
     def gets
       make_rewindable unless @rewindable_io
       @rewindable_io.gets
     end
-    
+
     def read(*args)
       make_rewindable unless @rewindable_io
       @rewindable_io.read(*args)
     end
-    
+
     def each(&block)
       make_rewindable unless @rewindable_io
       @rewindable_io.each(&block)
     end
-    
+
     def rewind
       make_rewindable unless @rewindable_io
       @rewindable_io.rewind
     end
-    
+
     # Closes this RewindableInput object without closing the originally
-    # wrapped IO oject. Cleans up any temporary resources that this RewindableInput
+    # wrapped IO object. Cleans up any temporary resources that this RewindableInput
     # has created.
     #
     # This method may be called multiple times. It does nothing on subsequent calls.
@@ -52,17 +55,8 @@ module Rack
         @rewindable_io = nil
       end
     end
-    
+
     private
-    
-    # Ruby's Tempfile class has a bug. Subclass it and fix it.
-    class Tempfile < ::Tempfile
-      def _close
-        @tmpfile.close if @tmpfile
-        @data[1] = nil if @data
-        @tmpfile = nil
-      end
-    end
 
     def make_rewindable
       # Buffer all data into a tempfile. Since this tempfile is private to this
@@ -75,16 +69,16 @@ module Rack
       @rewindable_io.set_encoding(Encoding::BINARY) if @rewindable_io.respond_to?(:set_encoding)
       @rewindable_io.binmode
       if filesystem_has_posix_semantics?
-        @rewindable_io.unlink
+        raise 'Unlink failed. IO closed.' if @rewindable_io.closed?
         @unlinked = true
       end
-      
-      buffer = ""
+
+      buffer = "".dup
       while @io.read(1024 * 4, buffer)
         entire_buffer_written_out = false
         while !entire_buffer_written_out
           written = @rewindable_io.write(buffer)
-          entire_buffer_written_out = written == buffer.size
+          entire_buffer_written_out = written == buffer.bytesize
           if !entire_buffer_written_out
             buffer.slice!(0 .. written - 1)
           end
@@ -92,7 +86,7 @@ module Rack
       end
       @rewindable_io.rewind
     end
-    
+
     def filesystem_has_posix_semantics?
       RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
     end

data/lib/rack/runtime.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rack
+  # Sets an "X-Runtime" response header, indicating the response
+  # time of the request, in seconds
+  #
+  # You can put it right before the application to see the processing
+  # time, or before all the other middlewares to include time for them,
+  # too.
+  class Runtime
+    FORMAT_STRING = "%0.6f" # :nodoc:
+    HEADER_NAME = "X-Runtime" # :nodoc:
+
+    def initialize(app, name = nil)
+      @app = app
+      @header_name = HEADER_NAME
+      @header_name += "-#{name}" if name
+    end
+
+    def call(env)
+      start_time = Utils.clock_time
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash[headers]
+
+      request_time = Utils.clock_time - start_time
+
+      unless headers.key?(@header_name)
+        headers[@header_name] = FORMAT_STRING % request_time
+      end
+
+      [status, headers, body]
+    end
+  end
+end