actionpack 2.1.2 → 2.2.2

data/lib/action_controller/request.rb

@@ -2,33 +2,38 @@ require 'tempfile'
 require 'stringio'
 require 'strscan'
 
-module ActionController
-  # HTTP methods which are accepted by default. 
-  ACCEPTED_HTTP_METHODS = Set.new(%w( get head put post delete options ))
+require 'active_support/memoizable'
 
+module ActionController
   # CgiRequest and TestRequest provide concrete implementations.
   class AbstractRequest
-    cattr_accessor :relative_url_root
-    remove_method :relative_url_root
+    extend ActiveSupport::Memoizable
+
+    def self.relative_url_root=(relative_url_root)
+      ActiveSupport::Deprecation.warn(
+        "ActionController::AbstractRequest.relative_url_root= has been renamed." +
+        "You can now set it with config.action_controller.relative_url_root=", caller)
+      ActionController::Base.relative_url_root=relative_url_root
+    end
+
+    HTTP_METHODS = %w(get head put post delete options)
+    HTTP_METHOD_LOOKUP = HTTP_METHODS.inject({}) { |h, m| h[m] = h[m.upcase] = m.to_sym; h }
 
     # The hash of environment variables for this request,
     # such as { 'RAILS_ENV' => 'production' }.
     attr_reader :env
 
-    # The true HTTP request method as a lowercase symbol, such as <tt>:get</tt>.
+    # The true HTTP request \method as a lowercase symbol, such as <tt>:get</tt>.
     # UnknownHttpMethod is raised for invalid methods not listed in ACCEPTED_HTTP_METHODS.
     def request_method
-      @request_method ||= begin
-        method = ((@env['REQUEST_METHOD'] == 'POST' && !parameters[:_method].blank?) ? parameters[:_method].to_s : @env['REQUEST_METHOD']).downcase
-        if ACCEPTED_HTTP_METHODS.include?(method)
-          method.to_sym
-        else
-          raise UnknownHttpMethod, "#{method}, accepted HTTP methods are #{ACCEPTED_HTTP_METHODS.to_a.to_sentence}"
-        end
-      end
+      method = @env['REQUEST_METHOD']
+      method = parameters[:_method] if method == 'POST' && !parameters[:_method].blank?
+
+      HTTP_METHOD_LOOKUP[method] || raise(UnknownHttpMethod, "#{method}, accepted HTTP methods are #{HTTP_METHODS.to_sentence}")
     end
+    memoize :request_method
 
-    # The HTTP request method as a lowercase symbol, such as <tt>:get</tt>.
+    # The HTTP request \method as a lowercase symbol, such as <tt>:get</tt>.
     # Note, HEAD is returned as <tt>:get</tt> since the two are functionally
     # equivalent from the application's perspective.
     def method
@@ -55,57 +60,107 @@ module ActionController
       request_method == :delete
     end
 
-    # Is this a HEAD request? <tt>request.method</tt> sees HEAD as <tt>:get</tt>,
-    # so check the HTTP method directly.
+    # Is this a HEAD request? Since <tt>request.method</tt> sees HEAD as <tt>:get</tt>,
+    # this \method checks the actual HTTP \method directly.
     def head?
       request_method == :head
     end
 
-    # Provides acccess to the request's HTTP headers, for example:
-    #  request.headers["Content-Type"] # => "text/plain"
+    # Provides access to the request's HTTP headers, for example:
+    #
+    #   request.headers["Content-Type"] # => "text/plain"
     def headers
-      @headers ||= ActionController::Http::Headers.new(@env)
+      ActionController::Http::Headers.new(@env)
     end
+    memoize :headers
 
+    # Returns the content length of the request as an integer.
     def content_length
-      @content_length ||= env['CONTENT_LENGTH'].to_i
+      @env['CONTENT_LENGTH'].to_i
     end
+    memoize :content_length
 
     # The MIME type of the HTTP request, such as Mime::XML.
     #
-    # For backward compatibility, the post format is extracted from the
+    # For backward compatibility, the post \format is extracted from the
     # X-Post-Data-Format HTTP header if present.
     def content_type
-      @content_type ||= Mime::Type.lookup(content_type_without_parameters)
+      Mime::Type.lookup(content_type_without_parameters)
     end
+    memoize :content_type
 
-    # Returns the accepted MIME type for the request
+    # Returns the accepted MIME type for the request.
     def accepts
-      @accepts ||=
-        if @env['HTTP_ACCEPT'].to_s.strip.empty?
-          [ content_type, Mime::ALL ].compact # make sure content_type being nil is not included
-        else
-          Mime::Type.parse(@env['HTTP_ACCEPT'])
-        end
+      header = @env['HTTP_ACCEPT'].to_s.strip
+
+      if header.empty?
+        [content_type, Mime::ALL].compact
+      else
+        Mime::Type.parse(header)
+      end
+    end
+    memoize :accepts
+
+    def if_modified_since
+      if since = env['HTTP_IF_MODIFIED_SINCE']
+        Time.rfc2822(since) rescue nil
+      end
     end
+    memoize :if_modified_since
 
-    # Returns the Mime type for the format used in the request. If there is no format available, the first of the 
-    # accept types will be used. Examples:
+    def if_none_match
+      env['HTTP_IF_NONE_MATCH']
+    end
+
+    def not_modified?(modified_at)
+      if_modified_since && modified_at && if_modified_since >= modified_at
+    end
+
+    def etag_matches?(etag)
+      if_none_match && if_none_match == etag
+    end
+
+    # Check response freshness (Last-Modified and ETag) against request
+    # If-Modified-Since and If-None-Match conditions. If both headers are
+    # supplied, both must match, or the request is not considered fresh.
+    def fresh?(response)
+      case
+      when if_modified_since && if_none_match 
+        not_modified?(response.last_modified) && etag_matches?(response.etag) 
+      when if_modified_since 
+        not_modified?(response.last_modified) 
+      when if_none_match 
+        etag_matches?(response.etag) 
+      else 
+        false 
+      end 
+    end
+
+    # Returns the Mime type for the \format used in the request.
     #
     #   GET /posts/5.xml   | request.format => Mime::XML
     #   GET /posts/5.xhtml | request.format => Mime::HTML
-    #   GET /posts/5       | request.format => request.accepts.first (usually Mime::HTML for browsers)
+    #   GET /posts/5       | request.format => Mime::HTML or MIME::JS, or request.accepts.first depending on the value of <tt>ActionController::Base.use_accept_header</tt>
     def format
-      @format ||= parameters[:format] ? Mime::Type.lookup_by_extension(parameters[:format]) : accepts.first
+      @format ||=
+        if parameters[:format]
+          Mime::Type.lookup_by_extension(parameters[:format])
+        elsif ActionController::Base.use_accept_header
+          accepts.first
+        elsif xhr?
+          Mime::Type.lookup_by_extension("js")
+        else
+          Mime::Type.lookup_by_extension("html")
+        end
     end
-    
-    
-    # Sets the format by string extension, which can be used to force custom formats that are not controlled by the extension.
-    # Example:
+
+
+    # Sets the \format by string extension, which can be used to force custom formats
+    # that are not controlled by the extension.
     #
     #   class ApplicationController < ActionController::Base
     #     before_filter :adjust_format_for_iphone
-    #   
+    #
     #     private
     #       def adjust_format_for_iphone
     #         request.format = :iphone if request.env["HTTP_USER_AGENT"][/iPhone/]
@@ -116,6 +171,25 @@ module ActionController
       @format = Mime::Type.lookup_by_extension(parameters[:format])
     end
 
+    # Returns a symbolized version of the <tt>:format</tt> parameter of the request.
+    # If no \format is given it returns <tt>:js</tt>for Ajax requests and <tt>:html</tt>
+    # otherwise.
+    def template_format
+      parameter_format = parameters[:format]
+
+      if parameter_format
+        parameter_format
+      elsif xhr?
+        :js
+      else
+        :html
+      end
+    end
+
+    def cache_format
+      parameters[:format]
+    end
+
     # Returns true if the request's "X-Requested-With" header contains
     # "XMLHttpRequest". (The Prototype Javascript library sends this header with
     # every Ajax request.)
@@ -128,7 +202,7 @@ module ActionController
     # the right-hand-side of X-Forwarded-For
     TRUSTED_PROXIES = /^127\.0\.0\.1$|^(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\./i
 
-    # Determine originating IP address.  REMOTE_ADDR is the standard
+    # Determines originating IP address.  REMOTE_ADDR is the standard
     # but will fail if the user is behind a proxy.  HTTP_CLIENT_IP and/or
     # HTTP_X_FORWARDED_FOR are set by proxies so check for these if
     # REMOTE_ADDR is a proxy.  HTTP_X_FORWARDED_FOR may be a comma-
@@ -166,44 +240,65 @@ EOM
 
       @env['REMOTE_ADDR']
     end
+    memoize :remote_ip
 
     # Returns the lowercase name of the HTTP server software.
     def server_software
       (@env['SERVER_SOFTWARE'] && /^([a-zA-Z]+)/ =~ @env['SERVER_SOFTWARE']) ? $1.downcase : nil
     end
+    memoize :server_software
 
 
-    # Returns the complete URL used for this request
+    # Returns the complete URL used for this request.
     def url
       protocol + host_with_port + request_uri
     end
+    memoize :url
 
-    # Return 'https://' if this is an SSL request and 'http://' otherwise.
+    # Returns 'https://' if this is an SSL request and 'http://' otherwise.
     def protocol
       ssl? ? 'https://' : 'http://'
     end
+    memoize :protocol
 
     # Is this an SSL request?
     def ssl?
       @env['HTTPS'] == 'on' || @env['HTTP_X_FORWARDED_PROTO'] == 'https'
     end
 
+    # Returns the \host for this request, such as "example.com".
+    def raw_host_with_port
+      if forwarded = env["HTTP_X_FORWARDED_HOST"]
+        forwarded.split(/,\s?/).last
+      else
+        env['HTTP_HOST'] || env['SERVER_NAME'] || "#{env['SERVER_ADDR']}:#{env['SERVER_PORT']}"
+      end
+    end
+
     # Returns the host for this request, such as example.com.
     def host
+      raw_host_with_port.sub(/:\d+$/, '')
     end
+    memoize :host
 
-    # Returns a host:port string for this request, such as example.com or
-    # example.com:8080.
+    # Returns a \host:\port string for this request, such as "example.com" or
+    # "example.com:8080".
     def host_with_port
-      @host_with_port ||= host + port_string
+      "#{host}#{port_string}"
     end
+    memoize :host_with_port
 
     # Returns the port number of this request as an integer.
     def port
-      @port_as_int ||= @env['SERVER_PORT'].to_i
+      if raw_host_with_port =~ /:(\d+)$/
+        $1.to_i
+      else
+        standard_port
+      end
     end
+    memoize :port
 
-    # Returns the standard port number for this request's protocol
+    # Returns the standard \port number for this request's protocol.
     def standard_port
       case protocol
         when 'https://' then 443
@@ -211,13 +306,13 @@ EOM
       end
     end
 
-    # Returns a port suffix like ":8080" if the port number of this request
-    # is not the default HTTP port 80 or HTTPS port 443.
+    # Returns a \port suffix like ":8080" if the \port number of this request
+    # is not the default HTTP \port 80 or HTTPS \port 443.
     def port_string
-      (port == standard_port) ? '' : ":#{port}"
+      port == standard_port ? '' : ":#{port}"
     end
 
-    # Returns the domain part of a host, such as rubyonrails.org in "www.rubyonrails.org". You can specify
+    # Returns the \domain part of a \host, such as "rubyonrails.org" in "www.rubyonrails.org". You can specify
     # a different <tt>tld_length</tt>, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
     def domain(tld_length = 1)
       return nil unless named_host?(host)
@@ -225,8 +320,9 @@ EOM
       host.split('.').last(1 + tld_length).join('.')
     end
 
-    # Returns all the subdomains as an array, so ["dev", "www"] would be returned for "dev.www.rubyonrails.org".
-    # You can specify a different <tt>tld_length</tt>, such as 2 to catch ["www"] instead of ["www", "rubyonrails"]
+    # Returns all the \subdomains as an array, so <tt>["dev", "www"]</tt> would be
+    # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
+    # such as 2 to catch <tt>["www"]</tt> instead of <tt>["www", "rubyonrails"]</tt>
     # in "www.rubyonrails.co.uk".
     def subdomains(tld_length = 1)
       return [] unless named_host?(host)
@@ -234,7 +330,7 @@ EOM
       parts[0..-(tld_length+2)]
     end
 
-    # Return the query string, accounting for server idiosyncracies.
+    # Returns the query string, accounting for server idiosyncrasies.
     def query_string
       if uri = @env['REQUEST_URI']
         uri.split('?', 2)[1] || ''
@@ -242,8 +338,9 @@ EOM
         @env['QUERY_STRING'] || ''
       end
     end
+    memoize :query_string
 
-    # Return the request URI, accounting for server idiosyncracies.
+    # Returns the request URI, accounting for server idiosyncrasies.
     # WEBrick includes the full URL. IIS leaves REQUEST_URI blank.
     def request_uri
       if uri = @env['REQUEST_URI']
@@ -251,48 +348,36 @@ EOM
         (%r{^\w+\://[^/]+(/.*|$)$} =~ uri) ? $1 : uri
       else
         # Construct IIS missing REQUEST_URI from SCRIPT_NAME and PATH_INFO.
-        script_filename = @env['SCRIPT_NAME'].to_s.match(%r{[^/]+$})
-        uri = @env['PATH_INFO']
-        uri = uri.sub(/#{script_filename}\//, '') unless script_filename.nil?
-        unless (env_qs = @env['QUERY_STRING']).nil? || env_qs.empty?
-          uri << '?' << env_qs
+        uri = @env['PATH_INFO'].to_s
+
+        if script_filename = @env['SCRIPT_NAME'].to_s.match(%r{[^/]+$})
+          uri = uri.sub(/#{script_filename}\//, '')
         end
 
-        if uri.nil?
+        env_qs = @env['QUERY_STRING'].to_s
+        uri += "?#{env_qs}" unless env_qs.empty?
+
+        if uri.blank?
           @env.delete('REQUEST_URI')
-          uri
         else
           @env['REQUEST_URI'] = uri
         end
       end
     end
+    memoize :request_uri
 
-    # Returns the interpreted path to requested resource after all the installation directory of this application was taken into account
+    # Returns the interpreted \path to requested resource after all the installation
+    # directory of this application was taken into account.
     def path
       path = (uri = request_uri) ? uri.split('?').first.to_s : ''
 
       # Cut off the path to the installation directory if given
-      path.sub!(%r/^#{relative_url_root}/, '')
-      path || ''      
-    end
-    
-    # Returns the path minus the web server relative installation directory.
-    # This can be set with the environment variable RAILS_RELATIVE_URL_ROOT.
-    # It can be automatically extracted for Apache setups. If the server is not
-    # Apache, this method returns an empty string.
-    def relative_url_root
-      @@relative_url_root ||= case
-        when @env["RAILS_RELATIVE_URL_ROOT"]
-          @env["RAILS_RELATIVE_URL_ROOT"]
-        when server_software == 'apache'
-          @env["SCRIPT_NAME"].to_s.sub(/\/dispatch\.(fcgi|rb|cgi)$/, '')
-        else
-          ''
-      end
+      path.sub!(%r/^#{ActionController::Base.relative_url_root}/, '')
+      path || ''
     end
+    memoize :path
 
-
-    # Read the request body. This is useful for web services that need to
+    # Read the request \body. This is useful for web services that need to
     # work with raw requests directly.
     def raw_post
       unless env.include? 'RAW_POST_DATA'
@@ -302,7 +387,7 @@ EOM
       env['RAW_POST_DATA']
     end
 
-    # Returns both GET and POST parameters in a single hash.
+    # Returns both GET and POST \parameters in a single hash.
     def parameters
       @parameters ||= request_parameters.merge(query_parameters).update(path_parameters).with_indifferent_access
     end
@@ -312,34 +397,56 @@ EOM
       @symbolized_path_parameters = @parameters = nil
     end
 
-    # The same as <tt>path_parameters</tt> with explicitly symbolized keys 
-    def symbolized_path_parameters 
+    # The same as <tt>path_parameters</tt> with explicitly symbolized keys.
+    def symbolized_path_parameters
       @symbolized_path_parameters ||= path_parameters.symbolize_keys
     end
 
-    # Returns a hash with the parameters used to form the path of the request.
-    # Returned hash keys are strings.  See <tt>symbolized_path_parameters</tt> for symbolized keys.
-    #
-    # Example: 
+    # Returns a hash with the \parameters used to form the \path of the request.
+    # Returned hash keys are strings:
     #
     #   {'action' => 'my_action', 'controller' => 'my_controller'}
+    #
+    # See <tt>symbolized_path_parameters</tt> for symbolized keys.
     def path_parameters
       @path_parameters ||= {}
     end
 
+    # The request body is an IO input stream. If the RAW_POST_DATA environment
+    # 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)
+        StringIO.new(raw_post)
+      else
+        body_stream
+      end
+    end
+
+    def remote_addr
+      @env['REMOTE_ADDR']
+    end
 
-    #--
-    # Must be implemented in the concrete request
-    #++
+    def referrer
+      @env['HTTP_REFERER']
+    end
+    alias referer referrer
 
-    # The request body is an IO input stream.
-    def body
+
+    def query_parameters
+      @query_parameters ||= self.class.parse_query_parameters(query_string)
     end
 
-    def query_parameters #:nodoc:
+    def request_parameters
+      @request_parameters ||= parse_formatted_request_parameters
     end
 
-    def request_parameters #:nodoc:
+
+    #--
+    # Must be implemented in the concrete request
+    #++
+
+    def body_stream #:nodoc:
     end
 
     def cookies #:nodoc:
@@ -366,8 +473,9 @@ EOM
 
       # The raw content type string with its parameters stripped off.
       def content_type_without_parameters
-        @content_type_without_parameters ||= self.class.extract_content_type_without_parameters(content_type_with_parameters)
+        self.class.extract_content_type_without_parameters(content_type_with_parameters)
       end
+      memoize :content_type_without_parameters
 
     private
       def content_type_from_legacy_post_data_format_header