actionpack 3.2.19 → 4.2.11.3

data/lib/action_dispatch/http/response.rb

@@ -1,7 +1,8 @@
-require 'digest/md5'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/class/attribute_accessors'
+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 'monitor'
 
 module ActionDispatch # :nodoc:
   # Represents an HTTP response generated by a controller action. Use it to
@@ -29,19 +30,26 @@ module ActionDispatch # :nodoc:
   #  class DemoControllerTest < ActionDispatch::IntegrationTest
   #    def test_print_root_path_to_console
   #      get('/')
-  #      puts @response.body
+  #      puts response.body
   #    end
   #  end
   class Response
-    attr_accessor :request, :header
+    # The request that the response is responding to.
+    attr_accessor :request
+
+    # The HTTP status code.
     attr_reader :status
+
     attr_writer :sending_file
 
+    # Get and set headers for this response.
+    attr_accessor :header
+
     alias_method :headers=, :header=
     alias_method :headers,  :header
 
     delegate :[], :[]=, :to => :@header
-    delegate :each, :to => :@body
+    delegate :each, :to => :@stream
 
     # Sets the HTTP response's content MIME type. For example, in the controller
     # you could write this:
@@ -51,22 +59,78 @@ module ActionDispatch # :nodoc:
     # 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_accessor :charset, :content_type
+    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
 
     CONTENT_TYPE = "Content-Type".freeze
     SET_COOKIE   = "Set-Cookie".freeze
     LOCATION     = "Location".freeze
- 
+    NO_CONTENT_CODES = [204, 304]
+
     cattr_accessor(:default_charset) { "utf-8" }
+    cattr_accessor(:default_headers)
 
     include Rack::Response::Helpers
+    include ActionDispatch::Http::FilterRedirect
     include ActionDispatch::Http::Cache::Response
+    include MonitorMixin
+
+    class Buffer # :nodoc:
+      def initialize(response, buf)
+        @response = response
+        @buf      = buf
+        @closed   = false
+      end
+
+      def write(string)
+        raise IOError, "closed stream" if closed?
+
+        @response.commit!
+        @buf.push string
+      end
+
+      def each(&block)
+        @response.sending!
+        x = @buf.each(&block)
+        @response.sent!
+        x
+      end
+
+      def abort
+      end
+
+      def close
+        @response.commit!
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+    end
+
+    # The underlying body, as a streamable object.
+    attr_reader :stream
+
+    def initialize(status = 200, header = {}, body = [], options = {})
+      super()
+
+      default_headers = options.fetch(:default_headers, self.class.default_headers)
+      header = merge_default_headers(header, default_headers)
 
-    def initialize(status = 200, header = {}, body = [])
       self.body, self.header, self.status = body, header, status
 
       @sending_file = false
-      @blank = 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=/)
@@ -79,37 +143,78 @@ module ActionDispatch # :nodoc:
       yield self if block_given?
     end
 
+    def await_commit
+      synchronize do
+        @cv.wait_until { @committed }
+      end
+    end
+
+    def await_sent
+      synchronize { @cv.wait_until { @sent } }
+    end
+
+    def commit!
+      synchronize do
+        before_committed
+        @committed = true
+        @cv.broadcast
+      end
+    end
+
+    def sending!
+      synchronize do
+        before_sending
+        @sending = true
+        @cv.broadcast
+      end
+    end
+
+    def sent!
+      synchronize do
+        @sent = true
+        @cv.broadcast
+      end
+    end
+
+    def sending?;   synchronize { @sending };   end
+    def committed?; synchronize { @committed }; end
+    def sent?;      synchronize { @sent };      end
+
+    # Sets the HTTP status code.
     def status=(status)
       @status = Rack::Utils.status_code(status)
     end
 
-    # The response code of the request
+    # Sets the HTTP content type.
+    def content_type=(content_type)
+      @content_type = content_type.to_s
+    end
+
+    # The response code of the request.
     def response_code
       @status
     end
 
-    # Returns a String to ensure compatibility with Net::HTTPResponse
+    # Returns a string to ensure compatibility with <tt>Net::HTTPResponse</tt>.
     def code
       @status.to_s
     end
 
+    # Returns the corresponding message for the current HTTP status code:
+    #
+    #   response.status = 200
+    #   response.message # => "OK"
+    #
+    #   response.status = 404
+    #   response.message # => "Not Found"
+    #
     def message
       Rack::Utils::HTTP_STATUS_CODES[@status]
     end
     alias_method :status_message, :message
 
-    def respond_to?(method)
-      if method.to_sym == :to_path
-        @body.respond_to?(:to_path)
-      else
-        super
-      end
-    end
-
-    def to_path
-      @body.to_path
-    end
-
+    # 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 }
@@ -118,21 +223,23 @@ module ActionDispatch # :nodoc:
 
     EMPTY = " "
 
+    # Allows you to manually set or override the response body.
     def body=(body)
       @blank = true if body == EMPTY
 
-      # Explicitly check for strings. This is *wrong* theoretically
-      # but if we don't check this, the performance on string bodies
-      # is bad on Ruby 1.8 (because strings responds to each then).
-      @body = if body.respond_to?(:to_str) || !body.respond_to?(:each)
-        [body]
+      if body.respond_to?(:to_path)
+        @stream = body
       else
-        body
+        synchronize do
+          @stream = build_buffer self, munge_body_object(body)
+        end
       end
     end
 
     def body_parts
-      @body
+      parts = []
+      @stream.each { |x| parts << x }
+      parts
     end
 
     def set_cookie(key, value)
@@ -143,34 +250,54 @@ module ActionDispatch # :nodoc:
       ::Rack::Utils.delete_cookie_header!(header, key, value)
     end
 
+    # The location header we'll be responding with.
     def location
       headers[LOCATION]
     end
     alias_method :redirect_url, :location
 
+    # Sets the location header we'll be responding with.
     def location=(url)
       headers[LOCATION] = url
     end
 
     def close
-      @body.close if @body.respond_to?(:close)
+      stream.close if stream.respond_to?(:close)
     end
 
-    def to_a
-      assign_default_content_type_and_charset!
-      handle_conditional_get!
-
-      @header[SET_COOKIE] = @header[SET_COOKIE].join("\n") if @header[SET_COOKIE].respond_to?(:join)
-
-      if [204, 304].include?(@status)
-        @header.delete CONTENT_TYPE
-        [@status, @header, []]
-      else
-        [@status, @header, self]
+    def abort
+      if stream.respond_to?(:abort)
+        stream.abort
+      elsif stream.respond_to?(:close)
+        # `stream.close` should really be reserved for a close from the
+        # other direction, but we must fall back to it for
+        # compatibility.
+        stream.close
       end
     end
+
+    # Turns the Response into a Rack-compatible array of the status, headers,
+    # and body. Allows explict splatting:
+    #
+    #   status, headers, body = *response
+    def to_a
+      rack_response @status, @header.to_hash
+    end
     alias prepare! to_a
-    alias to_ary   to_a # For implicit splat on 1.9.2
+
+    # 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
     #
@@ -191,16 +318,88 @@ module ActionDispatch # :nodoc:
 
   private
 
-    def assign_default_content_type_and_charset!
+    def before_committed
+    end
+
+    def before_sending
+    end
+
+    def merge_default_headers(original, default)
+      default.respond_to?(:merge) ? default.merge(original) : original
+    end
+
+    def build_buffer(response, body)
+      Buffer.new response, body
+    end
+
+    def munge_body_object(body)
+      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
+      @charset      ||= self.class.default_charset unless @charset == false
 
       type = @content_type.to_s.dup
-      type << "; charset=#{@charset}" unless @sending_file
+      type << "; charset=#{@charset}" if append_charset?
 
       headers[CONTENT_TYPE] = type
     end
+
+    def append_charset?
+      !@sending_file && @charset != false
+    end
+
+    class RackBody
+      def initialize(response)
+        @response = response
+      end
+
+      def each(*args, &block)
+        @response.each(*args, &block)
+      end
+
+      def close
+        # Rack "close" maps to Response#abort, and *not* Response#close
+        # (which is used when the controller's finished writing)
+        @response.abort
+      end
+
+      def body
+        @response.body
+      end
+
+      def respond_to?(method, include_private = false)
+        if method.to_s == 'to_path'
+          @response.stream.respond_to?(method)
+        else
+          super
+        end
+      end
+
+      def to_path
+        @response.stream.to_path
+      end
+
+      def to_ary
+        nil
+      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)
+
+      if NO_CONTENT_CODES.include?(@status)
+        header.delete CONTENT_TYPE
+        [status, header, []]
+      else
+        [status, header, RackBody.new(self)]
+      end
+    end
   end
 end

data/lib/action_dispatch/http/upload.rb

@@ -1,47 +1,78 @@
 module ActionDispatch
   module Http
+    # Models uploaded files.
+    #
+    # The actual file is accessible via the +tempfile+ accessor, though some
+    # of its interface is available directly for convenience.
+    #
+    # Uploaded files are temporary files whose lifespan is one request. When
+    # the object is finalized Ruby unlinks the file, so there is no need to
+    # clean them with a separate maintenance task.
     class UploadedFile
-      attr_accessor :original_filename, :content_type, :tempfile, :headers
+      # The basename of the file in the client.
+      attr_accessor :original_filename
 
-      def initialize(hash)
-        @original_filename = encode_filename(hash[:filename])
-        @content_type      = hash[:type]
-        @headers           = hash[:head]
+      # A string with the MIME type of the file.
+      attr_accessor :content_type
+
+      # A +Tempfile+ object with the actual uploaded file. Note that some of
+      # its interface is available directly.
+      attr_accessor :tempfile
+      alias :to_io :tempfile
+
+      # A string with the headers of the multipart request.
+      attr_accessor :headers
+
+      def initialize(hash) # :nodoc:
         @tempfile          = hash[:tempfile]
         raise(ArgumentError, ':tempfile is required') unless @tempfile
+
+        @original_filename = hash[:filename]
+        if @original_filename
+          begin
+            @original_filename.encode!(Encoding::UTF_8)
+          rescue EncodingError
+            @original_filename.force_encoding(Encoding::UTF_8)
+          end
+        end
+        @content_type      = hash[:type]
+        @headers           = hash[:head]
       end
 
-      def read(*args)
-        @tempfile.read(*args)
+      # Shortcut for +tempfile.read+.
+      def read(length=nil, buffer=nil)
+        @tempfile.read(length, buffer)
       end
 
-      # Delegate these methods to the tempfile.
-      [:open, :path, :rewind, :size].each do |method|
-        class_eval "def #{method}; @tempfile.#{method}; end"
+      # Shortcut for +tempfile.open+.
+      def open
+        @tempfile.open
       end
 
-      private
-      def encode_filename(filename)
-        # Encode the filename in the utf8 encoding, unless it is nil or we're in 1.8
-        if "ruby".encoding_aware? && filename
-          filename.force_encoding("UTF-8").encode!
-        else
-          filename
-        end
+      # Shortcut for +tempfile.close+.
+      def close(unlink_now=false)
+        @tempfile.close(unlink_now)
       end
-    end
 
-    module Upload
-      # Convert nested Hash to HashWithIndifferentAccess and replace
-      # file upload hash with UploadedFile objects
-      def normalize_parameters(value)
-        if Hash === value && value.has_key?(:tempfile)
-          UploadedFile.new(value)
-        else
-          super
-        end
+      # Shortcut for +tempfile.path+.
+      def path
+        @tempfile.path
+      end
+
+      # Shortcut for +tempfile.rewind+.
+      def rewind
+        @tempfile.rewind
+      end
+
+      # Shortcut for +tempfile.size+.
+      def size
+        @tempfile.size
+      end
+
+      # Shortcut for +tempfile.eof?+.
+      def eof?
+        @tempfile.eof?
       end
-      private :normalize_parameters
     end
   end
 end