actionpack 4.2.10 → 5.0.0

data/lib/action_dispatch/http/response.rb

@@ -1,7 +1,6 @@
 require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/string/filters'
-require 'active_support/deprecation'
 require 'action_dispatch/http/filter_redirect'
+require 'action_dispatch/http/cache'
 require 'monitor'
 
 module ActionDispatch # :nodoc:
@@ -34,46 +33,62 @@ module ActionDispatch # :nodoc:
   #    end
   #  end
   class Response
+    class Header < DelegateClass(Hash) # :nodoc:
+      def initialize(response, header)
+        @response = response
+        super(header)
+      end
+
+      def []=(k,v)
+        if @response.sending? || @response.sent?
+          raise ActionDispatch::IllegalStateError, 'header already sent'
+        end
+
+        super
+      end
+
+      def merge(other)
+        self.class.new @response, __getobj__.merge(other)
+      end
+
+      def to_hash
+        __getobj__.dup
+      end
+    end
+
     # The request that the response is responding to.
     attr_accessor :request
 
     # The HTTP status code.
     attr_reader :status
 
-    attr_writer :sending_file
+    # Get headers for this response.
+    attr_reader :header
 
-    # Get and set headers for this response.
-    attr_accessor :header
-
-    alias_method :headers=, :header=
     alias_method :headers,  :header
 
     delegate :[], :[]=, :to => :@header
-    delegate :each, :to => :@stream
-
-    # Sets the HTTP response's content MIME type. For example, in the controller
-    # you could write this:
-    #
-    #  response.content_type = "text/plain"
-    #
-    # If a character set has been defined for this response (see charset=) then
-    # the character set information will also be included in the content type
-    # information.
-    attr_reader   :content_type
 
-    # The charset of the response. HTML wants to know the encoding of the
-    # content you're giving them, so we need to send that along.
-    attr_accessor :charset
+    def each(&block)
+      sending!
+      x = @stream.each(&block)
+      sent!
+      x
+    end
 
     CONTENT_TYPE = "Content-Type".freeze
     SET_COOKIE   = "Set-Cookie".freeze
     LOCATION     = "Location".freeze
-    NO_CONTENT_CODES = [204, 304]
+    NO_CONTENT_CODES = [100, 101, 102, 204, 205, 304]
 
     cattr_accessor(:default_charset) { "utf-8" }
     cattr_accessor(:default_headers)
 
     include Rack::Response::Helpers
+    # Aliasing these off because AD::Http::Cache::Response defines them
+    alias :_cache_control :cache_control
+    alias :_cache_control= :cache_control=
+
     include ActionDispatch::Http::FilterRedirect
     include ActionDispatch::Http::Cache::Response
     include MonitorMixin
@@ -83,20 +98,33 @@ module ActionDispatch # :nodoc:
         @response = response
         @buf      = buf
         @closed   = false
+        @str_body = nil
+      end
+
+      def body
+        @str_body ||= begin
+          buf = ''
+            each { |chunk| buf << chunk }
+          buf
+        end
       end
 
       def write(string)
         raise IOError, "closed stream" if closed?
 
+        @str_body = nil
         @response.commit!
         @buf.push string
       end
 
       def each(&block)
-        @response.sending!
-        x = @buf.each(&block)
-        @response.sent!
-        x
+        if @str_body
+          return enum_for(:each) unless block_given?
+
+          yield @str_body
+        else
+          each_chunk(&block)
+        end
       end
 
       def abort
@@ -110,39 +138,48 @@ module ActionDispatch # :nodoc:
       def closed?
         @closed
       end
+
+      private
+
+        def each_chunk(&block)
+          @buf.each(&block) # extract into own method
+        end
+    end
+
+    def self.create(status = 200, header = {}, body = [], default_headers: self.default_headers)
+      header = merge_default_headers(header, default_headers)
+      new status, header, body
+    end
+
+    def self.merge_default_headers(original, default)
+      default.respond_to?(:merge) ? default.merge(original) : original
     end
 
     # The underlying body, as a streamable object.
     attr_reader :stream
 
-    def initialize(status = 200, header = {}, body = [], options = {})
+    def initialize(status = 200, header = {}, body = [])
       super()
 
-      default_headers = options.fetch(:default_headers, self.class.default_headers)
-      header = merge_default_headers(header, default_headers)
+      @header = Header.new(self, header)
 
-      self.body, self.header, self.status = body, header, status
+      self.body, self.status = body, status
 
-      @sending_file = false
-      @blank        = false
       @cv           = new_cond
       @committed    = false
       @sending      = false
       @sent         = false
-      @content_type = nil
-      @charset      = nil
-
-      if content_type = self[CONTENT_TYPE]
-        type, charset = content_type.split(/;\s*charset=/)
-        @content_type = Mime::Type.lookup(type)
-        @charset = charset || self.class.default_charset
-      end
 
       prepare_cache_control!
 
       yield self if block_given?
     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
+
     def await_commit
       synchronize do
         @cv.wait_until { @committed }
@@ -187,7 +224,49 @@ module ActionDispatch # :nodoc:
 
     # Sets the HTTP content type.
     def content_type=(content_type)
-      @content_type = content_type.to_s
+      header_info = parse_content_type
+      set_content_type content_type.to_s, header_info.charset || self.class.default_charset
+    end
+
+    # Sets the HTTP response's content MIME type. For example, in the controller
+    # you could write this:
+    #
+    #  response.content_type = "text/plain"
+    #
+    # If a character set has been defined for this response (see charset=) then
+    # the character set information will also be included in the content type
+    # information.
+
+    def content_type
+      parse_content_type.mime_type
+    end
+
+    def sending_file=(v)
+      if true == v
+        self.charset = false
+      end
+    end
+
+    # Sets the HTTP character set. In case of nil parameter
+    # it sets the charset to utf-8.
+    #
+    #   response.charset = 'utf-16' # => 'utf-16'
+    #   response.charset = nil      # => 'utf-8'
+    def charset=(charset)
+      header_info = parse_content_type
+      if false == charset
+        set_header CONTENT_TYPE, header_info.mime_type
+      else
+        content_type = header_info.mime_type
+        set_content_type content_type, charset || self.class.default_charset
+      end
+    end
+
+    # The charset of the response. HTML wants to know the encoding of the
+    # content you're giving them, so we need to send that along.
+    def charset
+      header_info = parse_content_type
+      header_info.charset || self.class.default_charset
     end
 
     # The response code of the request.
@@ -216,17 +295,15 @@ module ActionDispatch # :nodoc:
     # Returns the content of the response as a string. This contains the contents
     # of any calls to <tt>render</tt>.
     def body
-      strings = []
-      each { |part| strings << part.to_s }
-      strings.join
+      @stream.body
     end
 
-    EMPTY = " "
+    def write(string)
+      @stream.write string
+    end
 
     # Allows you to manually set or override the response body.
     def body=(body)
-      @blank = true if body == EMPTY
-
       if body.respond_to?(:to_path)
         @stream = body
       else
@@ -236,31 +313,49 @@ module ActionDispatch # :nodoc:
       end
     end
 
-    def body_parts
-      parts = []
-      @stream.each { |x| parts << x }
-      parts
-    end
+    # Avoid having to pass an open file handle as the response body.
+    # Rack::Sendfile will usually intercept the response and uses
+    # the path directly, so there is no reason to open the file.
+    class FileBody #:nodoc:
+      attr_reader :to_path
+
+      def initialize(path)
+        @to_path = path
+      end
 
-    def set_cookie(key, value)
-      ::Rack::Utils.set_cookie_header!(header, key, value)
+      def body
+        File.binread(to_path)
+      end
+
+      # Stream the file's contents if Rack::Sendfile isn't present.
+      def each
+        File.open(to_path, 'rb') do |file|
+          while chunk = file.read(16384)
+            yield chunk
+          end
+        end
+      end
     end
 
-    def delete_cookie(key, value={})
-      ::Rack::Utils.delete_cookie_header!(header, key, value)
+    # Send the file stored at +path+ as the response body.
+    def send_file(path)
+      commit!
+      @stream = FileBody.new(path)
     end
 
-    # The location header we'll be responding with.
-    def location
-      headers[LOCATION]
+    def reset_body!
+      @stream = build_buffer(self, [])
     end
-    alias_method :redirect_url, :location
 
-    # Sets the location header we'll be responding with.
-    def location=(url)
-      headers[LOCATION] = url
+    def body_parts
+      parts = []
+      @stream.each { |x| parts << x }
+      parts
     end
 
+    # The location header we'll be responding with.
+    alias_method :redirect_url, :location
+
     def close
       stream.close if stream.respond_to?(:close)
     end
@@ -277,34 +372,21 @@ module ActionDispatch # :nodoc:
     end
 
     # Turns the Response into a Rack-compatible array of the status, headers,
-    # and body. Allows explict splatting:
+    # and body. Allows explicit splatting:
     #
     #   status, headers, body = *response
     def to_a
+      commit!
       rack_response @status, @header.to_hash
     end
     alias prepare! to_a
 
-    # Be super clear that a response object is not an Array. Defining this
-    # would make implicit splatting work, but it also makes adding responses
-    # as arrays work, and "flattening" responses, cascading to the rack body!
-    # Not sensible behavior.
-    def to_ary
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        `ActionDispatch::Response#to_ary` no longer performs implicit conversion
-        to an array. Please use `response.to_a` instead, or a splat like `status,
-        headers, body = *response`.
-      MSG
-
-      to_a
-    end
-
     # Returns the response cookies, converted to a Hash of (name => value) pairs
     #
     #   assert_equal 'AuthorOfNewPage', r.cookies['author']
     def cookies
       cookies = {}
-      if header = self[SET_COOKIE]
+      if header = get_header(SET_COOKIE)
         header = header.split("\n") if header.respond_to?(:to_str)
         header.each do |cookie|
           if pair = cookie.split(';').first
@@ -318,14 +400,43 @@ module ActionDispatch # :nodoc:
 
   private
 
+    ContentTypeHeader = Struct.new :mime_type, :charset
+    NullContentTypeHeader = ContentTypeHeader.new nil, nil
+
+    def parse_content_type
+      content_type = get_header CONTENT_TYPE
+      if content_type
+        type, charset = content_type.split(/;\s*charset=/)
+        type = nil if type.empty?
+        ContentTypeHeader.new(type, charset)
+      else
+        NullContentTypeHeader
+      end
+    end
+
+    def set_content_type(content_type, charset)
+      type = (content_type || '').dup
+      type << "; charset=#{charset}" if charset
+      set_header CONTENT_TYPE, type
+    end
+
     def before_committed
+      return if committed?
+      assign_default_content_type_and_charset!
+      handle_conditional_get!
+      handle_no_content!
     end
 
     def before_sending
-    end
+      # Normally we've already committed by now, but it's possible
+      # (e.g., if the controller action tries to read back its own
+      # response) to get here before that. In that case, we must force
+      # an "early" commit: we're about to freeze the headers, so this is
+      # our last chance.
+      commit! unless committed?
 
-    def merge_default_headers(original, default)
-      default.respond_to?(:merge) ? default.merge(original) : original
+      headers.freeze
+      request.commit_cookie_jar! unless committed?
     end
 
     def build_buffer(response, body)
@@ -336,20 +447,12 @@ module ActionDispatch # :nodoc:
       body.respond_to?(:each) ? body : [body]
     end
 
-    def assign_default_content_type_and_charset!(headers)
-      return if headers[CONTENT_TYPE].present?
-
-      @content_type ||= Mime::HTML
-      @charset      ||= self.class.default_charset unless @charset == false
+    def assign_default_content_type_and_charset!
+      return if content_type
 
-      type = @content_type.to_s.dup
-      type << "; charset=#{@charset}" if append_charset?
-
-      headers[CONTENT_TYPE] = type
-    end
-
-    def append_charset?
-      !@sending_file && @charset != false
+      ct = parse_content_type
+      set_content_type(ct.mime_type || Mime[:html].to_s,
+                       ct.charset || self.class.default_charset)
     end
 
     class RackBody
@@ -388,14 +491,15 @@ module ActionDispatch # :nodoc:
       end
     end
 
-    def rack_response(status, header)
-      assign_default_content_type_and_charset!(header)
-      handle_conditional_get!
-
-      header[SET_COOKIE] = header[SET_COOKIE].join("\n") if header[SET_COOKIE].respond_to?(:join)
-
+    def handle_no_content!
       if NO_CONTENT_CODES.include?(@status)
-        header.delete CONTENT_TYPE
+        @header.delete CONTENT_TYPE
+        @header.delete 'Content-Length'
+      end
+    end
+
+    def rack_response(status, header)
+      if NO_CONTENT_CODES.include?(status)
         [status, header, []]
       else
         [status, header, RackBody.new(self)]

data/lib/action_dispatch/http/url.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/hash/slice'
 
 module ActionDispatch
   module Http
@@ -12,10 +11,22 @@ module ActionDispatch
       self.tld_length = 1
 
       class << self
+        # Returns the domain part of a host given the domain level.
+        #
+        #    # Top-level domain example
+        #    extract_domain('www.example.com', 1) # => "example.com"
+        #    # Second-level domain example
+        #    extract_domain('dev.www.example.co.uk', 2) # => "example.co.uk"
         def extract_domain(host, tld_length)
           extract_domain_from(host, tld_length) if named_host?(host)
         end
 
+        # Returns the subdomains of a host as an Array given the domain level.
+        #
+        #    # Top-level domain example
+        #    extract_subdomains('www.example.com', 1) # => ["www"]
+        #    # Second-level domain example
+        #    extract_subdomains('dev.www.example.co.uk', 2) # => ["dev", "www"]
         def extract_subdomains(host, tld_length)
           if named_host?(host)
             extract_subdomains_from(host, tld_length)
@@ -24,6 +35,12 @@ module ActionDispatch
           end
         end
 
+        # Returns the subdomains of a host as a String given the domain level.
+        #
+        #    # Top-level domain example
+        #    extract_subdomain('www.example.com', 1) # => "www"
+        #    # Second-level domain example
+        #    extract_subdomain('dev.www.example.co.uk', 2) # => "dev.www"
         def extract_subdomain(host, tld_length)
           extract_subdomains(host, tld_length).join('.')
         end
@@ -49,7 +66,7 @@ module ActionDispatch
         end
 
         def path_for(options)
-          path  = options[:script_name].to_s.chomp("/")
+          path  = options[:script_name].to_s.chomp("/".freeze)
           path << options[:path] if options.key?(:path)
 
           add_trailing_slash(path) if options[:trailing_slash]
@@ -64,7 +81,8 @@ module ActionDispatch
         def add_params(path, params)
           params = { params: params } unless params.is_a?(Hash)
           params.reject! { |_,v| v.to_param.nil? }
-          path << "?#{params.to_query}" unless params.empty?
+          query = params.to_query
+          path << "?#{query}" unless query.empty?
         end
 
         def add_anchor(path, anchor)
@@ -166,43 +184,97 @@ module ActionDispatch
         end
       end
 
-      def initialize(env)
+      def initialize
         super
         @protocol = nil
         @port     = nil
       end
 
       # Returns the complete URL used for this request.
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com'
+      #   req.url # => "http://example.com"
       def url
         protocol + host_with_port + fullpath
       end
 
       # Returns 'https://' if this is an SSL request and 'http://' otherwise.
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com'
+      #   req.protocol # => "http://"
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com', 'HTTPS' => 'on'
+      #   req.protocol # => "https://"
       def protocol
         @protocol ||= ssl? ? 'https://' : 'http://'
       end
 
       # Returns the \host for this request, such as "example.com".
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com'
+      #   req.raw_host_with_port # => "example.com"
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:8080'
+      #   req.raw_host_with_port # => "example.com:8080"
       def raw_host_with_port
-        if forwarded = env["HTTP_X_FORWARDED_HOST"].presence
+        if forwarded = x_forwarded_host.presence
           forwarded.split(/,\s?/).last
         else
-          env['HTTP_HOST'] || "#{env['SERVER_NAME'] || env['SERVER_ADDR']}:#{env['SERVER_PORT']}"
+          get_header('HTTP_HOST') || "#{server_name || server_addr}:#{get_header('SERVER_PORT')}"
         end
       end
 
       # Returns the host for this request, such as example.com.
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:8080'
+      #   req.host # => "example.com"
       def host
-        raw_host_with_port.sub(/:\d+$/, '')
+        raw_host_with_port.sub(/:\d+$/, ''.freeze)
       end
 
       # Returns a \host:\port string for this request, such as "example.com" or
       # "example.com:8080".
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:80'
+      #   req.host_with_port # => "example.com"
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:8080'
+      #   req.host_with_port # => "example.com:8080"
       def host_with_port
         "#{host}#{port_string}"
       end
 
       # Returns the port number of this request as an integer.
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com'
+      #   req.port # => 80
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:8080'
+      #   req.port # => 8080
       def port
         @port ||= begin
           if raw_host_with_port =~ /:(\d+)$/
@@ -214,6 +286,13 @@ module ActionDispatch
       end
 
       # Returns the standard \port number for this request's protocol.
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:8080'
+      #   req.standard_port # => 80
       def standard_port
         case protocol
           when 'https://' then 443
@@ -222,24 +301,54 @@ module ActionDispatch
       end
 
       # Returns whether this request is using the standard port
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:80'
+      #   req.standard_port? # => true
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:8080'
+      #   req.standard_port? # => false
       def standard_port?
         port == standard_port
       end
 
       # Returns a number \port suffix like 8080 if the \port number of this request
       # is not the default HTTP \port 80 or HTTPS \port 443.
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:80'
+      #   req.optional_port # => nil
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:8080'
+      #   req.optional_port # => 8080
       def optional_port
         standard_port? ? nil : port
       end
 
       # Returns a string \port suffix, including colon, like ":8080" if the \port
       # number of this request is not the default HTTP \port 80 or HTTPS \port 443.
+      #
+      #   class Request < Rack::Request
+      #     include ActionDispatch::Http::URL
+      #   end
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:80'
+      #   req.port_string # => ""
+      #
+      #   req = Request.new 'HTTP_HOST' => 'example.com:8080'
+      #   req.port_string # => ":8080"
       def port_string
         standard_port? ? '' : ":#{port}"
       end
 
       def server_port
-        @env['SERVER_PORT'].to_i
+        get_header('SERVER_PORT').to_i
       end
 
       # Returns the \domain part of a \host, such as "rubyonrails.org" in "www.rubyonrails.org". You can specify