actionpack 3.2.19 → 4.0.0

data/lib/action_dispatch/http/request.rb

@@ -1,12 +1,16 @@
-require 'tempfile'
 require 'stringio'
-require 'strscan'
 
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/string/access'
 require 'active_support/inflector'
 require 'action_dispatch/http/headers'
 require 'action_controller/metal/exceptions'
+require 'rack/request'
+require 'action_dispatch/http/cache'
+require 'action_dispatch/http/mime_negotiation'
+require 'action_dispatch/http/parameters'
+require 'action_dispatch/http/filter_parameters'
+require 'action_dispatch/http/upload'
+require 'action_dispatch/http/url'
+require 'active_support/core_ext/array/conversions'
 
 module ActionDispatch
   class Request < Rack::Request
@@ -17,7 +21,10 @@ module ActionDispatch
     include ActionDispatch::Http::Upload
     include ActionDispatch::Http::URL
 
-    LOCALHOST   = [/^127\.0\.0\.\d{1,3}$/, "::1", /^0:0:0:0:0:0:0:1(%.*)?$/].freeze
+    autoload :Session, 'action_dispatch/request/session'
+
+    LOCALHOST   = Regexp.union [/^127\.0\.0\.\d{1,3}$/, /^::1$/, /^0:0:0:0:0:0:0:1(%.*)?$/]
+
     ENV_METHODS = %w[ AUTH_TYPE GATEWAY_INTERFACE
         PATH_TRANSLATED REMOTE_HOST
         REMOTE_IDENT REMOTE_USER REMOTE_ADDR
@@ -35,6 +42,17 @@ module ActionDispatch
       METHOD
     end
 
+    def initialize(env)
+      super
+      @method            = nil
+      @request_method    = nil
+      @remote_ip         = nil
+      @original_fullpath = nil
+      @fullpath          = nil
+      @ip                = nil
+      @uuid              = nil
+    end
+
     def key?(key)
       @env.key?(key)
     end
@@ -56,12 +74,13 @@ module ActionDispatch
     RFC5789 = %w(PATCH)
 
     HTTP_METHODS = RFC2616 + RFC2518 + RFC3253 + RFC3648 + RFC3744 + RFC5323 + RFC5789
+
     HTTP_METHOD_LOOKUP = {}
 
     # Populate the HTTP method lookup cache
-    HTTP_METHODS.each do |method|
+    HTTP_METHODS.each { |method|
       HTTP_METHOD_LOOKUP[method] = method.underscore.to_sym
-    end
+    }
 
     # Returns the HTTP \method that the application should see.
     # In the case where the \method was overridden by a middleware
@@ -102,6 +121,12 @@ module ActionDispatch
       HTTP_METHOD_LOOKUP[request_method] == :post
     end
 
+    # Is this a PATCH request?
+    # Equivalent to <tt>request.request_method == :patch</tt>.
+    def patch?
+      HTTP_METHOD_LOOKUP[request_method] == :patch
+    end
+
     # Is this a PUT request?
     # Equivalent to <tt>request.request_method_symbol == :put</tt>.
     def put?
@@ -115,9 +140,9 @@ module ActionDispatch
     end
 
     # Is this a HEAD request?
-    # Equivalent to <tt>request.method_symbol == :head</tt>.
+    # Equivalent to <tt>request.request_method_symbol == :head</tt>.
     def head?
-      HTTP_METHOD_LOOKUP[method] == :head
+      HTTP_METHOD_LOOKUP[request_method] == :head
     end
 
     # Provides access to the request's HTTP headers, for example:
@@ -131,14 +156,29 @@ module ActionDispatch
       @original_fullpath ||= (env["ORIGINAL_FULLPATH"] || fullpath)
     end
 
+    # Returns the +String+ full path including params of the last URL requested.
+    #
+    #    # get "/articles"
+    #    request.fullpath # => "/articles"
+    #
+    #    # get "/articles?page=2"
+    #    request.fullpath # => "/articles?page=2"
     def fullpath
       @fullpath ||= super
     end
 
+    # Returns the original request URL as a +String+.
+    #
+    #    # get "/articles?page=2"
+    #    request.original_url # => "http://www.example.com/articles?page=2"
     def original_url
       base_url + original_fullpath
     end
 
+    # The +String+ MIME type of the request.
+    #
+    #    # get "/articles"
+    #    request.media_type # => "application/x-www-form-urlencoded"
     def media_type
       content_mime_type.to_s
     end
@@ -195,7 +235,7 @@ module ActionDispatch
     # variable is already set, wrap it in a StringIO.
     def body
       if raw_post = @env['RAW_POST_DATA']
-        raw_post.force_encoding(Encoding::BINARY) if raw_post.respond_to?(:force_encoding)
+        raw_post.force_encoding(Encoding::BINARY)
         StringIO.new(raw_post)
       else
         @env['rack.input']
@@ -213,32 +253,38 @@ module ActionDispatch
     # TODO This should be broken apart into AD::Request::Session and probably
     # be included by the session middleware.
     def reset_session
-      session.destroy if session && session.respond_to?(:destroy)
-      self.session = {}
+      if session && session.respond_to?(:destroy)
+        session.destroy
+      else
+        self.session = {}
+      end
       @env['action_dispatch.request.flash_hash'] = nil
     end
 
     def session=(session) #:nodoc:
-      @env['rack.session'] = session
+      Session.set @env, session
     end
 
     def session_options=(options)
-      @env['rack.session.options'] = options
+      Session::Options.set @env, options
     end
 
     # Override Rack's GET method to support indifferent access
     def GET
-      @env["action_dispatch.request.query_parameters"] ||= deep_munge(normalize_parameters(super) || {})
+      @env["action_dispatch.request.query_parameters"] ||= (normalize_encode_params(super) || {})
+    rescue TypeError => e
+      raise ActionController::BadRequest.new(:query, e)
     end
     alias :query_parameters :GET
 
     # Override Rack's POST method to support indifferent access
     def POST
-      @env["action_dispatch.request.request_parameters"] ||= deep_munge(normalize_parameters(super) || {})
+      @env["action_dispatch.request.request_parameters"] ||= (normalize_encode_params(super) || {})
+    rescue TypeError => e
+      raise ActionController::BadRequest.new(:request, e)
     end
     alias :request_parameters :POST
 
-
     # Returns the authorization header regardless of whether it was specified directly or through one of the
     # proxy alternatives.
     def authorization
@@ -250,7 +296,7 @@ module ActionDispatch
 
     # True if the request came from localhost, 127.0.0.1.
     def local?
-      LOCALHOST.any? { |local_ip| local_ip === remote_addr && local_ip === remote_ip }
+      LOCALHOST =~ remote_addr && LOCALHOST =~ remote_ip
     end
 
     # Remove nils from the params hash

data/lib/action_dispatch/http/response.rb

@@ -1,7 +1,5 @@
-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 'monitor'
 
 module ActionDispatch # :nodoc:
   # Represents an HTTP response generated by a controller action. Use it to
@@ -29,7 +27,7 @@ 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
@@ -41,7 +39,7 @@ module ActionDispatch # :nodoc:
     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 +49,65 @@ 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_accessor :charset
+    attr_reader   :content_type
 
     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)
+        @buf.each(&block)
+      end
+
+      def close
+        @response.commit!
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+    end
+
+    attr_reader :stream
 
     def initialize(status = 200, header = {}, body = [])
+      super()
+
+      header = merge_default_headers(header, self.class.default_headers)
+
       self.body, self.header, self.status = body, header, status
 
       @sending_file = false
-      @blank = false
+      @blank        = false
+      @cv           = new_cond
+      @committed    = false
+      @content_type = nil
+      @charset      = nil
 
       if content_type = self[CONTENT_TYPE]
         type, charset = content_type.split(/;\s*charset=/)
@@ -79,37 +120,69 @@ module ActionDispatch # :nodoc:
       yield self if block_given?
     end
 
+    def await_commit
+      synchronize do
+        @cv.wait_until { @committed }
+      end
+    end
+
+    def commit!
+      synchronize do
+        @committed = true
+        @cv.broadcast
+      end
+    end
+
+    def committed?
+      @committed
+    end
+
+    # Sets the HTTP status code.
     def status=(status)
       @status = Rack::Utils.status_code(status)
     end
 
-    # The response code of the request
+    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)
+      if method.to_s == 'to_path'
+        stream.respond_to?(:to_path)
       else
         super
       end
     end
 
     def to_path
-      @body.to_path
+      stream.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 +191,21 @@ 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
+        @stream = build_buffer self, munge_body_object(body)
       end
     end
 
     def body_parts
-      @body
+      parts = []
+      @stream.each { |x| parts << x }
+      parts
     end
 
     def set_cookie(key, value)
@@ -153,21 +226,11 @@ module ActionDispatch # :nodoc:
     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]
-      end
+      rack_response @status, @header.to_hash
     end
     alias prepare! to_a
     alias to_ary   to_a # For implicit splat on 1.9.2
@@ -191,16 +254,48 @@ module ActionDispatch # :nodoc:
 
   private
 
-    def assign_default_content_type_and_charset!
+    def merge_default_headers(original, default)
+      return original unless default.respond_to?(:merge)
+
+      default.merge(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
+
+    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, self]
+      end
+    end
   end
 end

data/lib/action_dispatch/http/upload.rb

@@ -1,47 +1,90 @@
 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
+
+      # 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
+
+      # 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
 
-      def initialize(hash)
         @original_filename = encode_filename(hash[:filename])
         @content_type      = hash[:type]
         @headers           = hash[:head]
-        @tempfile          = hash[:tempfile]
-        raise(ArgumentError, ':tempfile is required') unless @tempfile
       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
+
+      # Shortcut for +tempfile.close+.
+      def close(unlink_now=false)
+        @tempfile.close(unlink_now)
+      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
+
       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
+        # Encode the filename in the utf8 encoding, unless it is nil
+        filename.force_encoding(Encoding::UTF_8).encode! if filename
       end
     end
 
-    module Upload
-      # Convert nested Hash to HashWithIndifferentAccess and replace
-      # file upload hash with UploadedFile objects
-      def normalize_parameters(value)
+    module Upload # :nodoc:
+      # Replace file upload hash with UploadedFile objects
+      # when normalize and encode parameters.
+      def normalize_encode_params(value)
         if Hash === value && value.has_key?(:tempfile)
           UploadedFile.new(value)
         else
           super
         end
       end
-      private :normalize_parameters
+      private :normalize_encode_params
     end
   end
 end