actionpack 2.1.2 → 2.2.2

data/lib/action_controller/response.rb

@@ -1,57 +1,169 @@
 require 'digest/md5'
 
-module ActionController
-  class AbstractResponse #:nodoc:
+module ActionController # :nodoc:
+  # Represents an HTTP response generated by a controller action. One can use an
+  # ActionController::AbstractResponse object to retrieve the current state of the
+  # response, or customize the response. An AbstractResponse object can either
+  # represent a "real" HTTP response (i.e. one that is meant to be sent back to the
+  # web browser) or a test response (i.e. one that is generated from integration
+  # tests). See CgiResponse and TestResponse, respectively.
+  #
+  # AbstractResponse is mostly a Ruby on Rails framework implement detail, and should
+  # never be used directly in controllers. Controllers should use the methods defined
+  # in ActionController::Base instead. For example, if you want to set the HTTP
+  # response's content MIME type, then use ActionControllerBase#headers instead of
+  # AbstractResponse#headers.
+  #
+  # Nevertheless, integration tests may want to inspect controller responses in more
+  # detail, and that's when AbstractResponse can be useful for application developers.
+  # Integration test methods such as ActionController::Integration::Session#get and
+  # ActionController::Integration::Session#post return objects of type TestResponse
+  # (which are of course also of type AbstractResponse).
+  #
+  # For example, the following demo integration "test" prints the body of the
+  # controller response to the console:
+  #
+  #  class DemoControllerTest < ActionController::IntegrationTest
+  #    def test_print_root_path_to_console
+  #      get('/')
+  #      puts @response.body
+  #    end
+  #  end
+  class AbstractResponse
     DEFAULT_HEADERS = { "Cache-Control" => "no-cache" }
     attr_accessor :request
-    attr_accessor :body, :headers, :session, :cookies, :assigns, :template, :redirected_to, :redirected_to_method_params, :layout
+
+    # The body content (e.g. HTML) of the response, as a String.
+    attr_accessor :body
+    # The headers of the response, as a Hash. It maps header names to header values.
+    attr_accessor :headers
+    attr_accessor :session, :cookies, :assigns, :template, :layout
+    attr_accessor :redirected_to, :redirected_to_method_params
+
+    delegate :default_charset, :to => 'ActionController::Base'
 
     def initialize
       @body, @headers, @session, @assigns = "", DEFAULT_HEADERS.merge("cookie" => []), [], []
     end
 
+    def status; headers['Status'] end
+    def status=(status) headers['Status'] = status end
+
+    def location; headers['Location'] end
+    def location=(url) headers['Location'] = url 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=(mime_type)
-      self.headers["Content-Type"] = charset ? "#{mime_type}; charset=#{charset}" : mime_type
+      self.headers["Content-Type"] =
+        if mime_type =~ /charset/ || (c = charset).nil?
+          mime_type.to_s
+        else
+          "#{mime_type}; charset=#{c}"
+        end
     end
-    
+
+    # Returns the response's content MIME type, or nil if content type has been set.
     def content_type
       content_type = String(headers["Content-Type"] || headers["type"]).split(";")[0]
       content_type.blank? ? nil : content_type
     end
-    
-    def charset=(encoding)
-      self.headers["Content-Type"] = "#{content_type || Mime::HTML}; charset=#{encoding}"
+
+    # Set the charset of the Content-Type header. Set to nil to remove it.
+    # If no content type is set, it defaults to HTML.
+    def charset=(charset)
+      headers["Content-Type"] =
+        if charset
+          "#{content_type || Mime::HTML}; charset=#{charset}"
+        else
+          content_type || Mime::HTML.to_s
+        end
     end
-    
+
     def charset
       charset = String(headers["Content-Type"] || headers["type"]).split(";")[1]
       charset.blank? ? nil : charset.strip.split("=")[1]
     end
 
-    def redirect(to_url, response_status)
-      self.headers["Status"] = response_status
-      self.headers["Location"] = to_url.gsub(/[\r\n]/, '')
+    def last_modified
+      if last = headers['Last-Modified']
+        Time.httpdate(last)
+      end
+    end
+
+    def last_modified?
+      headers.include?('Last-Modified')
+    end
 
-      self.body = "<html><body>You are being <a href=\"#{CGI.escapeHTML(to_url)}\">redirected</a>.</body></html>"
+    def last_modified=(utc_time)
+      headers['Last-Modified'] = utc_time.httpdate
+    end
+
+    def etag
+      headers['ETag']
+    end
+    
+    def etag?
+      headers.include?('ETag')
+    end
+    
+    def etag=(etag)
+      headers['ETag'] = %("#{Digest::MD5.hexdigest(ActiveSupport::Cache.expand_cache_key(etag))}")
+    end
+
+    def redirect(url, status)
+      self.status = status
+      self.location = url.gsub(/[\r\n]/, '')
+      self.body = "<html><body>You are being <a href=\"#{CGI.escapeHTML(url)}\">redirected</a>.</body></html>"
+    end
+
+    def sending_file?
+      headers["Content-Transfer-Encoding"] == "binary"
+    end
+
+    def assign_default_content_type_and_charset!
+      self.content_type ||= Mime::HTML
+      self.charset ||= default_charset unless sending_file?
     end
 
     def prepare!
+      assign_default_content_type_and_charset!
       handle_conditional_get!
-      convert_content_type!
       set_content_length!
+      convert_content_type!
     end
 
-
     private
-      def handle_conditional_get!
-        if body.is_a?(String) && (headers['Status'] ? headers['Status'][0..2] == '200' : true)  && !body.empty?
-          self.headers['ETag'] ||= %("#{Digest::MD5.hexdigest(body)}")
-          self.headers['Cache-Control'] = 'private, max-age=0, must-revalidate' if headers['Cache-Control'] == DEFAULT_HEADERS['Cache-Control']
-
-          if request.headers['HTTP_IF_NONE_MATCH'] == headers['ETag']
-            self.headers['Status'] = '304 Not Modified'
-            self.body = ''
-          end
+      def handle_conditional_get! 
+        if etag? || last_modified? 
+          set_conditional_cache_control! 
+        elsif nonempty_ok_response? 
+          self.etag = body 
+
+          if request && request.etag_matches?(etag) 
+            self.status = '304 Not Modified' 
+            self.body = '' 
+          end 
+
+          set_conditional_cache_control! 
+        end 
+      end
+
+      def nonempty_ok_response?
+        ok = !status || status[0..2] == '200'
+        ok && body.is_a?(String) && !body.empty?
+      end
+
+      def set_conditional_cache_control!
+        if headers['Cache-Control'] == DEFAULT_HEADERS['Cache-Control']
+          headers['Cache-Control'] = 'private, max-age=0, must-revalidate'
         end
       end
 
@@ -70,7 +182,9 @@ module ActionController
       # Don't set the Content-Length for block-based bodies as that would mean reading it all into memory. Not nice
       # for, say, a 2GB streaming file.
       def set_content_length!
-        self.headers["Content-Length"] = body.size unless body.respond_to?(:call)
+        unless body.respond_to?(:call) || (status && status[0..2] == '304')
+          self.headers["Content-Length"] ||= body.size
+        end
       end
   end
-end
+end

data/lib/action_controller/routing.rb

@@ -201,7 +201,7 @@ module ActionController
   # With conditions you can define restrictions on routes. Currently the only valid condition is <tt>:method</tt>.
   #
   # * <tt>:method</tt> - Allows you to specify which method can access the route. Possible values are <tt>:post</tt>,
-  #   <tt>:get</tt>, <tt>:put</tt>, <tt>:delete</tt> and <tt>:any</tt>. The default value is <tt>:any</tt>, 
+  #   <tt>:get</tt>, <tt>:put</tt>, <tt>:delete</tt> and <tt>:any</tt>. The default value is <tt>:any</tt>,
   #   <tt>:any</tt> means that any method can access the route.
   #
   # Example:
@@ -213,7 +213,7 @@ module ActionController
   #
   # Now, if you POST to <tt>/posts/:id</tt>, it will route to the <tt>create_comment</tt> action. A GET on the same
   # URL will route to the <tt>show</tt> action.
-  # 
+  #
   # == Reloading routes
   #
   # You can reload routes if you feel you must:
@@ -281,9 +281,9 @@ module ActionController
     end
 
     class << self
-	  # Expects an array of controller names as the first argument.  
-	  # Executes the passed block with only the named controllers named available.
-	  # This method is used in internal Rails testing.
+      # Expects an array of controller names as the first argument.
+      # Executes the passed block with only the named controllers named available.
+      # This method is used in internal Rails testing.
       def with_controllers(names)
         prior_controllers = @possible_controllers
         use_controllers! names
@@ -292,10 +292,10 @@ module ActionController
         use_controllers! prior_controllers
       end
 
-	  # Returns an array of paths, cleaned of double-slashes and relative path references.
-	  # * "\\\" and "//"  become "\\" or "/". 
-	  # * "/foo/bar/../config" becomes "/foo/config".
-	  # The returned array is sorted by length, descending.
+      # Returns an array of paths, cleaned of double-slashes and relative path references.
+      # * "\\\" and "//"  become "\\" or "/".
+      # * "/foo/bar/../config" becomes "/foo/config".
+      # The returned array is sorted by length, descending.
       def normalize_paths(paths)
         # do the hokey-pokey of path normalization...
         paths = paths.collect do |path|
@@ -314,7 +314,7 @@ module ActionController
         paths = paths.uniq.sort_by { |path| - path.length }
       end
 
-	  # Returns the array of controller names currently available to ActionController::Routing.
+      # Returns the array of controller names currently available to ActionController::Routing.
       def possible_controllers
         unless @possible_controllers
           @possible_controllers = []
@@ -339,28 +339,27 @@ module ActionController
         @possible_controllers
       end
 
-	  # Replaces the internal list of controllers available to ActionController::Routing with the passed argument.
-	  #   ActionController::Routing.use_controllers!([ "posts", "comments", "admin/comments" ])
+      # Replaces the internal list of controllers available to ActionController::Routing with the passed argument.
+      #   ActionController::Routing.use_controllers!([ "posts", "comments", "admin/comments" ])
       def use_controllers!(controller_names)
         @possible_controllers = controller_names
       end
 
-	  # Returns a controller path for a new +controller+ based on a +previous+ controller path.
-	  # Handles 4 scenarios:
-	  #
-	  # * stay in the previous controller:
-	  #     controller_relative_to( nil, "groups/discussion" ) # => "groups/discussion"
-	  #
-	  # * stay in the previous namespace:
-	  #     controller_relative_to( "posts", "groups/discussion" ) # => "groups/posts"
-	  #
-	  # * forced move to the root namespace:
-	  #     controller_relative_to( "/posts", "groups/discussion" ) # => "posts"
-	  #
-	  # * previous namespace is root:
-	  #     controller_relative_to( "posts", "anything_with_no_slashes" ) # =>"posts"
-	  #
-	  
+      # Returns a controller path for a new +controller+ based on a +previous+ controller path.
+      # Handles 4 scenarios:
+      #
+      # * stay in the previous controller:
+      #     controller_relative_to( nil, "groups/discussion" ) # => "groups/discussion"
+      #
+      # * stay in the previous namespace:
+      #     controller_relative_to( "posts", "groups/discussion" ) # => "groups/posts"
+      #
+      # * forced move to the root namespace:
+      #     controller_relative_to( "/posts", "groups/discussion" ) # => "posts"
+      #
+      # * previous namespace is root:
+      #     controller_relative_to( "posts", "anything_with_no_slashes" ) # =>"posts"
+      #
       def controller_relative_to(controller, previous)
         if controller.nil?           then previous
         elsif controller[0] == ?/    then controller[1..-1]
@@ -369,12 +368,11 @@ module ActionController
         end
       end
     end
-    
 
     Routes = RouteSet.new
 
     ActiveSupport::Inflector.module_eval do
-	  # Ensures that routes are reloaded when Rails inflections are updated.
+      # Ensures that routes are reloaded when Rails inflections are updated.
       def inflections_with_route_reloading(&block)
         returning(inflections_without_route_reloading(&block)) {
           ActionController::Routing::Routes.reload! if block_given?

data/lib/action_controller/routing/builder.rb

@@ -1,23 +1,16 @@
 module ActionController
   module Routing
     class RouteBuilder #:nodoc:
-      attr_accessor :separators, :optional_separators
+      attr_reader :separators, :optional_separators
+      attr_reader :separator_regexp, :nonseparator_regexp, :interval_regexp
 
       def initialize
-        self.separators = Routing::SEPARATORS
-        self.optional_separators = %w( / )
-      end
-
-      def separator_pattern(inverted = false)
-        "[#{'^' if inverted}#{Regexp.escape(separators.join)}]"
-      end
+        @separators = Routing::SEPARATORS
+        @optional_separators = %w( / )
 
-      def interval_regexp
-        Regexp.new "(.*?)(#{separators.source}|$)"
-      end
-
-      def multiline_regexp?(expression)
-        expression.options & Regexp::MULTILINE == Regexp::MULTILINE
+        @separator_regexp = /[#{Regexp.escape(separators.join)}]/
+        @nonseparator_regexp = /\A([^#{Regexp.escape(separators.join)}]+)/
+        @interval_regexp = /(.*?)(#{separator_regexp}|$)/
       end
 
       # Accepts a "route path" (a string defining a route), and returns the array
@@ -30,7 +23,7 @@ module ActionController
         rest, segments = path, []
 
         until rest.empty?
-          segment, rest = segment_for rest
+          segment, rest = segment_for(rest)
           segments << segment
         end
         segments
@@ -39,24 +32,20 @@ module ActionController
       # A factory method that returns a new segment instance appropriate for the
       # format of the given string.
       def segment_for(string)
-        segment = case string
-          when /\A:(\w+)/
-            key = $1.to_sym
-            case key
-              when :controller then ControllerSegment.new(key)
-              else DynamicSegment.new key
-            end
-          when /\A\*(\w+)/ then PathSegment.new($1.to_sym, :optional => true)
-          when /\A\?(.*?)\?/
-            returning segment = StaticSegment.new($1) do
-              segment.is_optional = true
-            end
-          when /\A(#{separator_pattern(:inverted)}+)/ then StaticSegment.new($1)
-          when Regexp.new(separator_pattern) then
-            returning segment = DividerSegment.new($&) do
-              segment.is_optional = (optional_separators.include? $&)
-            end
-        end
+        segment =
+          case string
+            when /\A:(\w+)/
+              key = $1.to_sym
+              key == :controller ? ControllerSegment.new(key) : DynamicSegment.new(key)
+            when /\A\*(\w+)/
+              PathSegment.new($1.to_sym, :optional => true)
+            when /\A\?(.*?)\?/
+              StaticSegment.new($1, :optional => true)
+            when nonseparator_regexp
+              StaticSegment.new($1)
+            when separator_regexp
+              DividerSegment.new($&, :optional => optional_separators.include?($&))
+          end
         [segment, $~.post_match]
       end
 
@@ -64,18 +53,18 @@ module ActionController
       # segments are passed alongside in order to distinguish between default values
       # and requirements.
       def divide_route_options(segments, options)
-        options = options.dup
+        options = options.except(:path_prefix, :name_prefix)
 
         if options[:namespace]
           options[:controller] = "#{options.delete(:namespace).sub(/\/$/, '')}/#{options[:controller]}"
-          options.delete(:path_prefix)
-          options.delete(:name_prefix)
         end
 
         requirements = (options.delete(:requirements) || {}).dup
         defaults     = (options.delete(:defaults)     || {}).dup
         conditions   = (options.delete(:conditions)   || {}).dup
 
+        validate_route_conditions(conditions)
+
         path_keys = segments.collect { |segment| segment.key if segment.respond_to?(:key) }.compact
         options.each do |key, value|
           hash = (path_keys.include?(key) && ! value.is_a?(Regexp)) ? defaults : requirements
@@ -102,7 +91,7 @@ module ActionController
             if requirement.source =~ %r{\A(\\A|\^)|(\\Z|\\z|\$)\Z}
               raise ArgumentError, "Regexp anchor characters are not allowed in routing requirements: #{requirement.inspect}"
             end
-            if multiline_regexp?(requirement)
+            if requirement.multiline?
               raise ArgumentError, "Regexp multiline option not allowed in routing requirements: #{requirement.inspect}"
             end
             segment.regexp = requirement
@@ -174,30 +163,32 @@ module ActionController
         defaults, requirements, conditions = divide_route_options(segments, options)
         requirements = assign_route_options(segments, defaults, requirements)
 
-        route = Route.new
+        # TODO: Segments should be frozen on initialize
+        segments.each { |segment| segment.freeze }
 
-        route.segments = segments
-        route.requirements = requirements
-        route.conditions = conditions
-
-        if !route.significant_keys.include?(:action) && !route.requirements[:action]
-          route.requirements[:action] = "index"
-          route.significant_keys << :action
-        end
-
-        # Routes cannot use the current string interpolation method
-        # if there are user-supplied <tt>:requirements</tt> as the interpolation
-        # code won't raise RoutingErrors when generating
-        if options.key?(:requirements) || route.requirements.keys.to_set != Routing::ALLOWED_REQUIREMENTS_FOR_OPTIMISATION
-          route.optimise = false
-        end
+        route = Route.new(segments, requirements, conditions)
 
         if !route.significant_keys.include?(:controller)
           raise ArgumentError, "Illegal route: the :controller must be specified!"
         end
 
-        route
+        route.freeze
       end
+
+      private
+        def validate_route_conditions(conditions)
+          if method = conditions[:method]
+            [method].flatten.each do |m|
+              if m == :head
+                raise ArgumentError, "HTTP method HEAD is invalid in route conditions. Rails processes HEAD requests the same as GETs, returning just the response headers"
+              end
+
+              unless HTTP_METHODS.include?(m.to_sym)
+                raise ArgumentError, "Invalid HTTP method specified in route conditions: #{conditions.inspect}"
+              end
+            end
+          end
+        end
     end
   end
 end