actionpack 3.2.22.5 → 4.0.0.beta1

data/lib/action_dispatch/http/parameters.rb

@@ -4,10 +4,19 @@ require 'active_support/core_ext/hash/indifferent_access'
 module ActionDispatch
   module Http
     module Parameters
+      def initialize(env)
+        super
+        @symbolized_path_params = nil
+      end
+
       # Returns both GET and POST \parameters in a single hash.
       def parameters
         @env["action_dispatch.request.parameters"] ||= begin
-          params = request_parameters.merge(query_parameters)
+          params = begin
+            request_parameters.merge(query_parameters)
+          rescue EOFError
+            query_parameters.dup
+          end
           params.merge!(path_parameters)
           encode_params(params).with_indifferent_access
         end
@@ -45,10 +54,8 @@ module ActionDispatch
       # you'll get a weird error down the road, but our form handling
       # should really prevent that from happening
       def encode_params(params)
-        return params unless "ruby".encoding_aware?
-
         if params.is_a?(String)
-          return params.force_encoding("UTF-8").encode!
+          return params.force_encoding(Encoding::UTF_8).encode!
         elsif !params.is_a?(Hash)
           return params
         end
@@ -65,7 +72,7 @@ module ActionDispatch
         end
       end
 
-      # Convert nested Hash to HashWithIndifferentAccess
+      # Convert nested Hash to ActiveSupport::HashWithIndifferentAccess
       def normalize_parameters(value)
         case value
         when Hash

data/lib/action_dispatch/http/rack_cache.rb

@@ -8,8 +8,7 @@ module ActionDispatch
       new
     end
 
-    # TODO: Finally deal with the RAILS_CACHE global
-    def initialize(store = RAILS_CACHE)
+    def initialize(store = Rails.cache)
       @store = store
     end
 
@@ -33,7 +32,7 @@ module ActionDispatch
       new
     end
 
-    def initialize(store = RAILS_CACHE)
+    def initialize(store = Rails.cache)
       @store = store
     end
 

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:
@@ -195,7 +220,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 +238,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_parameters(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_parameters(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 +281,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,64 @@ 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
- 
+
     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 +119,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 +190,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 +225,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 +253,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 [204, 304].include?(@status)
+        header.delete CONTENT_TYPE
+        [status, header, []]
+      else
+        [status, header, self]
+      end
+    end
   end
 end