actionpack 1.12.5 → 1.13.0

data/lib/action_controller/benchmarking.rb

@@ -8,11 +8,8 @@ module ActionController #:nodoc:
       base.extend(ClassMethods)
 
       base.class_eval do
-        alias_method :perform_action_without_benchmark, :perform_action
-        alias_method :perform_action, :perform_action_with_benchmark
-
-        alias_method :render_without_benchmark, :render
-        alias_method :render, :render_with_benchmark
+        alias_method_chain :perform_action, :benchmark
+        alias_method_chain :render, :benchmark
       end
     end
 
@@ -68,7 +65,7 @@ module ActionController #:nodoc:
       else
         runtime = [Benchmark::measure{ perform_action_without_benchmark }.real, 0.0001].max
         log_message  = "Completed in #{sprintf("%.5f", runtime)} (#{(1 / runtime).floor} reqs/sec)"
-        log_message << rendering_runtime(runtime) if @rendering_runtime
+        log_message << rendering_runtime(runtime) if defined?(@rendering_runtime)
         log_message << active_record_runtime(runtime) if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
         log_message << " | #{headers["Status"]}"
         log_message << " [#{complete_request_uri rescue "unknown"}]"

data/lib/action_controller/caching.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'uri'
 
 module ActionController #:nodoc:
   # Caching is a cheap way of speeding up slow applications by keeping the result of calculations, renderings, and database calls
@@ -117,24 +118,24 @@ module ActionController #:nodoc:
         return unless perform_caching
         if options[:action].is_a?(Array)
           options[:action].dup.each do |action|
-            self.class.expire_page(url_for(options.merge({ :only_path => true, :skip_relative_url_root => true, :action => action })))
+            self.class.expire_page(url_for(options.merge(:only_path => true, :skip_relative_url_root => true, :action => action)))
           end
         else
-          self.class.expire_page(url_for(options.merge({ :only_path => true, :skip_relative_url_root => true })))
+          self.class.expire_page(url_for(options.merge(:only_path => true, :skip_relative_url_root => true)))
         end
       end
 
-      # Manually cache the +content+ in the key determined by +options+. If no content is provided, the contents of @response.body is used
+      # Manually cache the +content+ in the key determined by +options+. If no content is provided, the contents of response.body is used
       # If no options are provided, the current +options+ for this action is used. Example:
       #   cache_page "I'm the cached content", :controller => "lists", :action => "show"
       def cache_page(content = nil, options = {})
         return unless perform_caching && caching_allowed
-        self.class.cache_page(content || @response.body, url_for(options.merge({ :only_path => true, :skip_relative_url_root => true })))
+        self.class.cache_page(content || response.body, url_for(options.merge(:only_path => true, :skip_relative_url_root => true, :format => params[:format])))
       end
 
       private
         def caching_allowed
-          !@request.post? && @response.headers['Status'] && @response.headers['Status'].to_i < 400
+          request.get? && response.headers['Status'].to_i == 200
         end
     end
 
@@ -155,9 +156,12 @@ module ActionController #:nodoc:
     # the current host and the path. So a page that is accessed at http://david.somewhere.com/lists/show/1 will result in a fragment named
     # "david.somewhere.com/lists/show/1". This allows the cacher to differentiate between "david.somewhere.com/lists/" and
     # "jamis.somewhere.com/lists/" -- which is a helpful way of assisting the subdomain-as-account-key pattern.
+    #
+    # Different representations of the same resource, e.g. <tt>http://david.somewhere.com/lists</tt> and <tt>http://david.somewhere.com/lists.xml</tt>
+    # are treated like separate requests and so are cached separately. Keep in mind when expiring an action cache that <tt>:action => 'lists'</tt> is not the same
+    # as <tt>:action => 'list', :format => :xml</tt>.
     module Actions
-      def self.append_features(base) #:nodoc:
-        super
+      def self.included(base) #:nodoc:
         base.extend(ClassMethods)
         base.send(:attr_accessor, :rendered_action_cache)
       end
@@ -173,22 +177,24 @@ module ActionController #:nodoc:
         return unless perform_caching
         if options[:action].is_a?(Array)
           options[:action].dup.each do |action|
-            expire_fragment(url_for(options.merge({ :action => action })).split("://").last)
+            expire_fragment(ActionCachePath.path_for(self, options.merge({ :action => action })))
           end
         else
-          expire_fragment(url_for(options).split("://").last)
+          expire_fragment(ActionCachePath.path_for(self, options))
         end
       end
 
       class ActionCacheFilter #:nodoc:
-        def initialize(*actions)
+        def initialize(*actions, &block)
           @actions = actions
         end
 
         def before(controller)
           return unless @actions.include?(controller.action_name.intern)
-          if cache = controller.read_fragment(controller.url_for.split("://").last)
+          action_cache_path = ActionCachePath.new(controller)
+          if cache = controller.read_fragment(action_cache_path.path)
             controller.rendered_action_cache = true
+            set_content_type!(action_cache_path)
             controller.send(:render_text, cache)
             false
           end
@@ -196,8 +202,60 @@ module ActionController #:nodoc:
 
         def after(controller)
           return if !@actions.include?(controller.action_name.intern) || controller.rendered_action_cache
-          controller.write_fragment(controller.url_for.split("://").last, controller.response.body)
+          controller.write_fragment(ActionCachePath.path_for(controller), controller.response.body)
         end
+        
+        private
+          
+          def set_content_type!(action_cache_path)
+            if extention = action_cache_path.extension
+              content_type = Mime::EXTENSION_LOOKUP[extention]
+              action_cache_path.controller.response.content_type = content_type.to_s
+            end
+          end
+          
+      end
+      
+      class ActionCachePath
+        attr_reader :controller, :options
+        
+        class << self
+          def path_for(*args, &block)
+            new(*args).path
+          end
+        end
+        
+        def initialize(controller, options = {})
+          @controller = controller
+          @options    = options
+        end
+        
+        def path
+          return @path if @path
+          @path = controller.url_for(options).split('://').last
+          normalize!
+          add_extension!
+          URI.unescape(@path)
+        end
+        
+        def extension
+          @extension ||= extract_extension(controller.request.path)
+        end
+        
+        private
+          def normalize!
+            @path << 'index' if @path.last == '/'
+          end
+        
+          def add_extension!
+            @path << ".#{extension}" if extension
+          end
+          
+          def extract_extension(file_path)
+            # Don't want just what comes after the last '.' to accomodate multi part extensions
+            # such as tar.gz.
+            file_path[/^[^.]+\.(.+)$/, 1]
+          end
       end
     end
 
@@ -208,7 +266,7 @@ module ActionController #:nodoc:
     #   <b>Hello <%= @name %></b>
     #   <% cache do %>
     #     All the topics in the system:
-    #     <%= render_collection_of_partials "topic", Topic.find_all %>
+    #     <%= render :partial => "topic", :collection => Topic.find(:all) %>
     #   <% end %>
     #
     # This cache will bind to the name of action that called it. So you would be able to invalidate it using
@@ -246,8 +304,7 @@ module ActionController #:nodoc:
     #   ActionController::Base.fragment_cache_store = :mem_cache_store, "localhost"
     #   ActionController::Base.fragment_cache_store = MyOwnStore.new("parameter")
     module Fragments
-      def self.append_features(base) #:nodoc:
-        super
+      def self.included(base) #:nodoc:
         base.class_eval do
           @@fragment_cache_store = MemoryStore.new
           cattr_reader :fragment_cache_store
@@ -306,7 +363,12 @@ module ActionController #:nodoc:
       # Name can take one of three forms:
       # * String: This would normally take the form of a path like "pages/45/notes"
       # * Hash: Is treated as an implicit call to url_for, like { :controller => "pages", :action => "notes", :id => 45 }
-      # * Regexp: Will destroy all the matched fragments, example: %r{pages/\d*/notes} Ensure you do not specify start and finish in the regex (^$) because the actual filename matched looks like ./cache/filename/path.cache
+      # * Regexp: Will destroy all the matched fragments, example:
+      #     %r{pages/\d*/notes}
+      #   Ensure you do not specify start and finish in the regex (^$) because
+      #   the actual filename matched looks like ./cache/filename/path.cache
+      #   Regexp expiration is not supported on caches which can't iterate over
+      #   all keys, such as memcached.
       def expire_fragment(name, options = nil)
         return unless perform_caching
 
@@ -327,6 +389,7 @@ module ActionController #:nodoc:
       def expire_matched_fragments(matcher = /.*/, options = nil) #:nodoc:
         expire_fragment(matcher, options)
       end
+      deprecate :expire_matched_fragments => :expire_fragment
 
 
       class UnthreadedMemoryStore #:nodoc:
@@ -430,7 +493,7 @@ module ActionController #:nodoc:
             if f =~ matcher
               begin
                 File.delete(f)
-              rescue Object => e
+              rescue SystemCallError => e
                 # If there's no cache, then there's nothing to complain about
               end
             end
@@ -493,8 +556,7 @@ module ActionController #:nodoc:
     #
     # In the example above, four actions are cached and three actions are responsible for expiring those caches.
     module Sweeping
-      def self.append_features(base) #:nodoc:
-        super
+      def self.included(base) #:nodoc:
         base.extend(ClassMethods)
       end
 
@@ -503,8 +565,7 @@ module ActionController #:nodoc:
           return unless perform_caching
           configuration = sweepers.last.is_a?(Hash) ? sweepers.pop : {}
           sweepers.each do |sweeper|
-            observer(sweeper)
-
+            ActiveRecord::Base.observers << sweeper if defined?(ActiveRecord) and defined?(ActiveRecord::Base)
             sweeper_instance = Object.const_get(Inflector.classify(sweeper)).instance
 
             if sweeper_instance.is_a?(Sweeper)
@@ -523,7 +584,7 @@ module ActionController #:nodoc:
 
         # ActiveRecord::Observer will mark this class as reloadable even though it should not be.
         # However, subclasses of ActionController::Caching::Sweeper should be Reloadable
-        include Reloadable::Subclasses
+        include Reloadable::Deprecated
         
         def before(controller)
           self.controller = controller

data/lib/action_controller/cgi_ext/cgi_ext.rb

@@ -27,13 +27,6 @@ class CGI #:nodoc:
   def request_parameters
     CGIMethods.parse_request_parameters(params, env_table)
   end
-
-  def redirect(where)
-     header({ 
-       "Status" => "302 Moved", 
-       "location" => "#{where}"
-    })
-  end
   
   def session(parameters = nil)
     parameters = {} if parameters.nil?

data/lib/action_controller/cgi_ext/cgi_methods.rb

@@ -1,217 +1,211 @@
 require 'cgi'
-require 'action_controller/vendor/xml_simple'
 require 'action_controller/vendor/xml_node'
+require 'strscan'
 
 # Static methods for parsing the query and request parameters that can be used in
 # a CGI extension class or testing in isolation.
 class CGIMethods #:nodoc:
-  public
-    # Returns a hash with the pairs from the query string. The implicit hash construction that is done in
-    # parse_request_params is not done here.
-    def CGIMethods.parse_query_parameters(query_string)
-      parsed_params = {}
-  
-      query_string.split(/[&;]/).each { |p| 
-        # Ignore repeated delimiters.
-        next if p.empty?
-
-        k, v = p.split('=',2)
-        v = nil if (v && v.empty?)
-
-        k = CGI.unescape(k) if k
-        v = CGI.unescape(v) if v
-
-        unless k.include?(?[)
-          parsed_params[k] = v
-        else
-          keys = split_key(k)
-          last_key = keys.pop
-          last_key = keys.pop if (use_array = last_key.empty?)
-          parent = keys.inject(parsed_params) {|h, k| h[k] ||= {}}
-          
-          if use_array then (parent[last_key] ||= []) << v
-          else parent[last_key] = v
-          end
-        end
-      }
-  
-      parsed_params
+  class << self
+    # DEPRECATED: Use parse_form_encoded_parameters
+    def parse_query_parameters(query_string)
+      pairs = query_string.split('&').collect do |chunk|
+        next if chunk.empty?
+        key, value = chunk.split('=', 2)
+        next if key.empty?
+        value = (value.nil? || value.empty?) ? nil : CGI.unescape(value)
+        [ CGI.unescape(key), value ]
+      end.compact
+
+      FormEncodedPairParser.new(pairs).result
     end
 
-    # Returns the request (POST/GET) parameters in a parsed form where pairs such as "customer[address][street]" / 
-    # "Somewhere cool!" are translated into a full hash hierarchy, like
-    # { "customer" => { "address" => { "street" => "Somewhere cool!" } } }
-    def CGIMethods.parse_request_parameters(params)
-      parsed_params = {}
-
-      for key, value in params
-        value = [value] if key =~ /.*\[\]$/
-        unless key.include?('[')
-          # much faster to test for the most common case first (GET)
-          # and avoid the call to build_deep_hash
-          parsed_params[key] = get_typed_value(value[0])
-        else
-          build_deep_hash(get_typed_value(value[0]), parsed_params, get_levels(key))
+    # DEPRECATED: Use parse_form_encoded_parameters
+    def parse_request_parameters(params)
+      parser = FormEncodedPairParser.new
+
+      params = params.dup
+      until params.empty?
+        for key, value in params
+          if key.blank?
+            params.delete key
+          elsif !key.include?('[')
+            # much faster to test for the most common case first (GET)
+            # and avoid the call to build_deep_hash
+            parser.result[key] = get_typed_value(value[0])
+            params.delete key
+          elsif value.is_a?(Array)
+            parser.parse(key, get_typed_value(value.shift))
+            params.delete key if value.empty?
+          else
+            raise TypeError, "Expected array, found #{value.inspect}"
+          end
         end
       end
     
-      parsed_params
+      parser.result
     end
 
-    def self.parse_formatted_request_parameters(mime_type, raw_post_data)
-      params = case strategy = ActionController::Base.param_parsers[mime_type]
+    def parse_formatted_request_parameters(mime_type, raw_post_data)
+      case strategy = ActionController::Base.param_parsers[mime_type]
         when Proc
           strategy.call(raw_post_data)
         when :xml_simple
-          raw_post_data.blank? ? nil :
-            typecast_xml_value(XmlSimple.xml_in(raw_post_data,
-              'forcearray'   => false,
-              'forcecontent' => true,
-              'keeproot'     => true,
-              'contentkey'   => '__content__'))
+          raw_post_data.blank? ? {} : Hash.from_xml(raw_post_data)
         when :yaml
           YAML.load(raw_post_data)
         when :xml_node
           node = XmlNode.from_xml(raw_post_data)
           { node.node_name => node }
       end
-      
-      dasherize_keys(params || {})
-    rescue Object => e
+    rescue Exception => e # YAML, XML or Ruby code block errors
       { "exception" => "#{e.message} (#{e.class})", "backtrace" => e.backtrace, 
         "raw_post_data" => raw_post_data, "format" => mime_type }
     end
 
-    def self.typecast_xml_value(value)
-      case value
-      when Hash
-        if value.has_key?("__content__")
-          content = translate_xml_entities(value["__content__"])
-          case value["type"]
-          when "integer"  then content.to_i
-          when "boolean"  then content == "true"
-          when "datetime" then Time.parse(content)
-          when "date"     then Date.parse(content)
-          else                 content
-          end
-        else
-          value.empty? ? nil : value.inject({}) do |h,(k,v)|
-            h[k] = typecast_xml_value(v)
-            h
-          end
-        end
-      when Array
-        value.map! { |i| typecast_xml_value(i) }
-        case value.length
-        when 0 then nil
-        when 1 then value.first
-        else value
+    private
+      def get_typed_value(value)
+        case value
+          when String
+            value
+          when NilClass
+            ''
+          when Array
+            value.map { |v| get_typed_value(v) }
+          else
+            # Uploaded file provides content type and filename.
+            if value.respond_to?(:content_type) &&
+                  !value.content_type.blank? &&
+                  !value.original_filename.blank?
+              unless value.respond_to?(:full_original_filename)
+                class << value
+                  alias_method :full_original_filename, :original_filename
+
+                  # Take the basename of the upload's original filename.
+                  # This handles the full Windows paths given by Internet Explorer
+                  # (and perhaps other broken user agents) without affecting
+                  # those which give the lone filename.
+                  # The Windows regexp is adapted from Perl's File::Basename.
+                  def original_filename
+                    if md = /^(?:.*[:\\\/])?(.*)/m.match(full_original_filename)
+                      md.captures.first
+                    else
+                      File.basename full_original_filename
+                    end
+                  end
+                end
+              end
+
+              # Return the same value after overriding original_filename.
+              value
+
+            # Multipart values may have content type, but no filename.
+            elsif value.respond_to?(:read)
+              result = value.read
+              value.rewind
+              result
+
+            # Unknown value, neither string nor multipart.
+            else
+              raise "Unknown form value: #{value.inspect}"
+            end
         end
-      else
-        raise "can't typecast #{value.inspect}"
       end
-    end
+  end
 
-  private
+  class FormEncodedPairParser < StringScanner
+    attr_reader :top, :parent, :result
 
-    def self.translate_xml_entities(value)
-      value.gsub(/&lt;/,   "<").
-            gsub(/&gt;/,   ">").
-            gsub(/&quot;/, '"').
-            gsub(/&apos;/, "'").
-            gsub(/&amp;/,  "&")
+    def initialize(pairs = [])
+      super('')
+      @result = {}
+      pairs.each { |key, value| parse(key, value) }
     end
-
-    def self.dasherize_keys(params)
-      case params.class.to_s
-      when "Hash"
-        params.inject({}) do |h,(k,v)|
-          h[k.to_s.tr("-", "_")] = dasherize_keys(v)
-          h
-        end
-      when "Array"
-        params.map { |v| dasherize_keys(v) }
-      else
-        params
+     
+    KEY_REGEXP = %r{([^\[\]=&]+)}
+    BRACKETED_KEY_REGEXP = %r{\[([^\[\]=&]+)\]}
+    
+    # Parse the query string
+    def parse(key, value)
+      self.string = key
+      @top, @parent = result, nil
+      
+      # First scan the bare key
+      key = scan(KEY_REGEXP) or return
+      key = post_key_check(key)
+            
+      # Then scan as many nestings as present
+      until eos? 
+        r = scan(BRACKETED_KEY_REGEXP) or return
+        key = self[1]
+        key = post_key_check(key)
       end
+ 
+      bind(key, value)
     end
 
-    # Splits the given key into several pieces. Example keys are 'name', 'person[name]',
-    # 'person[name][first]', and 'people[]'. In each instance, an Array instance is returned.
-    # 'person[name][first]' produces ['person', 'name', 'first']; 'people[]' produces ['people', '']
-    def CGIMethods.split_key(key)
-      if /^([^\[]+)((?:\[[^\]]*\])+)$/ =~ key
-        keys = [$1]
-        
-        keys.concat($2[1..-2].split(']['))
-        keys << '' if key[-2..-1] == '[]' # Have to add it since split will drop empty strings
-        
-        keys
-      else
-        [key]
+    private
+      # After we see a key, we must look ahead to determine our next action. Cases:
+      # 
+      #   [] follows the key. Then the value must be an array.
+      #   = follows the key. (A value comes next)
+      #   & or the end of string follows the key. Then the key is a flag.
+      #   otherwise, a hash follows the key. 
+      def post_key_check(key)
+        if scan(/\[\]/) # a[b][] indicates that b is an array
+          container(key, Array)
+          nil
+        elsif check(/\[[^\]]/) # a[b] indicates that a is a hash
+          container(key, Hash)
+          nil
+        else # End of key? We do nothing.
+          key
+        end
       end
-    end
     
-    def CGIMethods.get_typed_value(value)
-      # test most frequent case first
-      if value.is_a?(String)
-        value
-      elsif value.respond_to?(:content_type) && ! value.content_type.blank?
-        # Uploaded file
-        unless value.respond_to?(:full_original_filename)
-          class << value
-            alias_method :full_original_filename, :original_filename
-
-            # Take the basename of the upload's original filename.
-            # This handles the full Windows paths given by Internet Explorer
-            # (and perhaps other broken user agents) without affecting
-            # those which give the lone filename.
-            # The Windows regexp is adapted from Perl's File::Basename.
-            def original_filename
-              if md = /^(?:.*[:\\\/])?(.*)/m.match(full_original_filename)
-                md.captures.first
-              else
-                File.basename full_original_filename
-              end
+      # Add a container to the stack.
+      # 
+      def container(key, klass)
+        type_conflict! klass, top[key] if top.is_a?(Hash) && top.key?(key) && ! top[key].is_a?(klass)
+        value = bind(key, klass.new)
+        type_conflict! klass, value unless value.is_a?(klass)
+        push(value)
+      end
+    
+      # Push a value onto the 'stack', which is actually only the top 2 items.
+      def push(value)
+        @parent, @top = @top, value
+      end
+    
+      # Bind a key (which may be nil for items in an array) to the provided value.
+      def bind(key, value)
+        if top.is_a? Array
+          if key
+            if top[-1].is_a?(Hash) && ! top[-1].key?(key)
+              top[-1][key] = value
+            else
+              top << {key => value}.with_indifferent_access
+              push top.last
             end
+          else
+            top << value
           end
+        elsif top.is_a? Hash
+          key = CGI.unescape(key)
+          parent << (@top = {}) if top.key?(key) && parent.is_a?(Array)
+          return top[key] ||= value
+        else
+          raise ArgumentError, "Don't know what to do: top is #{top.inspect}"
         end
 
-        # Return the same value after overriding original_filename.
-        value
-
-      elsif value.respond_to?(:read)
-        # Value as part of a multipart request
-        value.read
-      elsif value.class == Array
-        value.collect { |v| CGIMethods.get_typed_value(v) }
-      else
-        # other value (neither string nor a multipart request)
-        value.to_s
-      end
-    end
-  
-    PARAMS_HASH_RE = /^([^\[]+)(\[.*\])?(.)?.*$/
-    def CGIMethods.get_levels(key)
-      all, main, bracketed, trailing = PARAMS_HASH_RE.match(key).to_a
-      if main.nil?
-        []
-      elsif trailing
-        [key]
-      elsif bracketed
-        [main] + bracketed.slice(1...-1).split('][')
-      else
-        [main]
+        return value
       end
-    end
-
-    def CGIMethods.build_deep_hash(value, hash, levels)
-      if levels.length == 0
-        value
-      elsif hash.nil?
-        { levels.first => CGIMethods.build_deep_hash(value, nil, levels[1..-1]) }
-      else
-        hash.update({ levels.first => CGIMethods.build_deep_hash(value, hash[levels.first], levels[1..-1]) })
+      
+      def type_conflict!(klass, value)
+        raise TypeError, 
+          "Conflicting types for parameter containers. " +
+          "Expected an instance of #{klass}, but found an instance of #{value.class}. " +
+          "This can be caused by passing Array and Hash based paramters qs[]=value&qs[key]=value. "
       end
+      
     end
 end