actionpack 1.11.2 → 1.12.0

data/lib/action_controller/benchmarking.rb

@@ -4,9 +4,9 @@ module ActionController #:nodoc:
   # The benchmarking module times the performance of actions and reports to the logger. If the Active Record
   # package has been included, a separate timing section for database calls will be added as well.
   module Benchmarking #:nodoc:
-    def self.append_features(base)
-      super
+    def self.included(base)
       base.extend(ClassMethods)
+
       base.class_eval do
         alias_method :perform_action_without_benchmark, :perform_action
         alias_method :perform_action, :perform_action_with_benchmark
@@ -43,14 +43,14 @@ module ActionController #:nodoc:
       end
     end
 
-    def render_with_benchmark(options = nil, deprecated_status = nil)
+    def render_with_benchmark(options = nil, deprecated_status = nil, &block)
       unless logger
-        render_without_benchmark(options, deprecated_status)
+        render_without_benchmark(options, deprecated_status, &block)
       else
         db_runtime = ActiveRecord::Base.connection.reset_runtime if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
 
         render_output = nil
-        @rendering_runtime = Benchmark::measure{ render_output = render_without_benchmark(options, deprecated_status) }.real
+        @rendering_runtime = Benchmark::measure{ render_output = render_without_benchmark(options, deprecated_status, &block) }.real
 
         if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
           @db_rt_before_render = db_runtime

data/lib/action_controller/caching.rb

@@ -8,16 +8,16 @@ module ActionController #:nodoc:
   #
   # Note: To turn off all caching and sweeping, set Base.perform_caching = false.
   module Caching
-    def self.append_features(base) #:nodoc:
-      super
+    def self.included(base) #:nodoc:
       base.send(:include, Pages, Actions, Fragments, Sweeping)
+
       base.class_eval do
         @@perform_caching = true
         cattr_accessor :perform_caching
       end
     end
 
-    # Page caching is an approach to caching where the entire action output of is stored as a HTML file that the web server 
+    # Page caching is an approach to caching where the entire action output of is stored as a HTML file that the web server
     # can serve without going through the Action Pack. This can be as much as 100 times faster than going through the process of dynamically
     # generating the content. Unfortunately, this incredible speed-up is only available to stateless pages where all visitors
     # are treated the same. Content management systems -- including weblogs and wikis -- have many pages that are a great fit
@@ -78,7 +78,7 @@ module ActionController #:nodoc:
             File.delete(page_cache_path(path)) if File.exists?(page_cache_path(path))
           end
         end
-        
+
         # Manually cache the +content+ in the key determined by +path+. Example:
         #   cache_page "I'm the cached content", "/lists/show"
         def cache_page(content, path)
@@ -94,18 +94,18 @@ module ActionController #:nodoc:
         # matches the triggering url.
         def caches_page(*actions)
           return unless perform_caching
-          actions.each do |action| 
+          actions.each do |action|
             class_eval "after_filter { |c| c.cache_page if c.action_name == '#{action}' }"
           end
         end
-        
+
         private
           def page_cache_file(path)
             name = ((path.empty? || path == "/") ? "/index" : URI.unescape(path))
             name << page_cache_extension unless (name.split('/').last || name).include? '.'
             return name
           end
-        
+
           def page_cache_path(path)
             page_cache_directory + page_cache_file(path)
           end
@@ -134,11 +134,11 @@ module ActionController #:nodoc:
 
       private
         def caching_allowed
-          !@request.post?
+          !@request.post? && @response.headers['Status'] && @response.headers['Status'].to_i < 400
         end
     end
 
-    # Action caching is similar to page caching by the fact that the entire output of the response is cached, but unlike page caching, 
+    # Action caching is similar to page caching by the fact that the entire output of the response is cached, but unlike page caching,
     # every request still goes through the Action Pack. The key benefit of this is that filters are run before the cache is served, which
     # allows for authentication and other restrictions on whether someone is allowed to see the cache. Example:
     #
@@ -184,7 +184,7 @@ module ActionController #:nodoc:
         def initialize(*actions)
           @actions = actions
         end
-        
+
         def before(controller)
           return unless @actions.include?(controller.action_name.intern)
           if cache = controller.read_fragment(controller.url_for.split("://").last)
@@ -193,7 +193,7 @@ module ActionController #:nodoc:
             false
           end
         end
-        
+
         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)
@@ -211,7 +211,7 @@ module ActionController #:nodoc:
     #     <%= render_collection_of_partials "topic", 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 
+    # This cache will bind to the name of action that called it. So you would be able to invalidate it using
     # <tt>expire_fragment(:controller => "topics", :action => "list")</tt> -- if that was the controller/action used. This is not too helpful
     # if you need to cache multiple fragments per action or if the action itself is cached using <tt>caches_action</tt>. So instead we should
     # qualify the name of the action used with something like:
@@ -272,7 +272,7 @@ module ActionController #:nodoc:
       # Called by CacheHelper#cache
       def cache_erb_fragment(block, name = {}, options = nil)
         unless perform_caching then block.call; return end
-        
+
         buffer = eval("_erbout", block.binding)
 
         if cache = read_fragment(name, options)
@@ -283,7 +283,7 @@ module ActionController #:nodoc:
           write_fragment(name, buffer[pos..-1], options)
         end
       end
-      
+
       def write_fragment(name, content, options = nil)
         return unless perform_caching
 
@@ -293,7 +293,7 @@ module ActionController #:nodoc:
         end
         content
       end
-      
+
       def read_fragment(name, options = nil)
         return unless perform_caching
 
@@ -302,11 +302,11 @@ module ActionController #:nodoc:
           fragment_cache_store.read(key, options)
         end
       end
-      
+
       # 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}
+      # * 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
       def expire_fragment(name, options = nil)
         return unless perform_caching
 
@@ -355,15 +355,15 @@ module ActionController #:nodoc:
         def read(name, options=nil) #:nodoc:
           @mutex.synchronize { super }
         end
-        
+
         def write(name, value, options=nil) #:nodoc:
           @mutex.synchronize { super }
         end
-        
+
         def delete(name, options=nil) #:nodoc:
           @mutex.synchronize { super }
         end
-        
+
         def delete_matched(matcher, options=nil) #:nodoc:
           @mutex.synchronize { super }
         end
@@ -386,26 +386,28 @@ module ActionController #:nodoc:
           super()
           @address = address
           @data = DRbObject.new(nil, address)
-        end    
+        end
       end
 
       class MemCacheStore < MemoryStore #:nodoc:
-        attr_reader :address
+        attr_reader :addresses
 
-        def initialize(address = 'localhost')
+        def initialize(*addresses)
           super()
-          @address = address
-          @data = MemCache.new(address)
-        end    
+          addresses = addresses.flatten
+          addresses = ["localhost"] if addresses.empty?
+          @addresses = addresses
+          @data = MemCache.new(*addresses)
+        end
       end
 
       class UnthreadedFileStore #:nodoc:
         attr_reader :cache_path
-        
+
         def initialize(cache_path)
           @cache_path = cache_path
         end
-    
+
         def write(name, value, options = nil) #:nodoc:
           ensure_cache_path(File.dirname(real_file_path(name)))
           File.open(real_file_path(name), "wb+") { |f| f.write(value) }
@@ -426,7 +428,7 @@ module ActionController #:nodoc:
         def delete_matched(matcher, options) #:nodoc:
           search_dir(@cache_path) do |f|
             if f =~ matcher
-              begin 
+              begin
                 File.delete(f)
               rescue Object => e
                 # If there's no cache, then there's nothing to complain about
@@ -434,12 +436,12 @@ module ActionController #:nodoc:
             end
           end
         end
-    
+
         private
           def real_file_path(name)
             '%s/%s.cache' % [@cache_path, name.gsub('?', '.').gsub(':', '.')]
           end
-        
+
           def ensure_cache_path(path)
             FileUtils.makedirs(path) unless File.exists?(path)
           end
@@ -470,10 +472,10 @@ module ActionController #:nodoc:
 
     # Sweepers are the terminators of the caching world and responsible for expiring caches when model objects change.
     # They do this by being half-observers, half-filters and implementing callbacks for both roles. A Sweeper example:
-    # 
+    #
     #   class ListSweeper < ActionController::Caching::Sweeper
     #     observe List, Item
-    #   
+    #
     #     def after_save(record)
     #       list = record.is_a?(List) ? record : record.list
     #       expire_page(:controller => "lists", :action => %w( show public feed ), :id => list.id)
@@ -518,6 +520,10 @@ module ActionController #:nodoc:
     if defined?(ActiveRecord) and defined?(ActiveRecord::Observer)
       class Sweeper < ActiveRecord::Observer #:nodoc:
         attr_accessor :controller
+
+        # 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
         
         def before(controller)
           self.controller = controller
@@ -526,17 +532,19 @@ module ActionController #:nodoc:
 
         def after(controller)
           callback(:after)
+          # Clean up, so that the controller can be collected after this request
+          self.controller = nil
         end
-        
+
         private
           def callback(timing)
             controller_callback_method_name = "#{timing}_#{controller.controller_name.underscore}"
             action_callback_method_name     = "#{controller_callback_method_name}_#{controller.action_name}"
-            
+
             send(controller_callback_method_name) if respond_to?(controller_callback_method_name)
             send(action_callback_method_name)     if respond_to?(action_callback_method_name)
           end
-        
+
           def method_missing(method, *arguments)
             return if @controller.nil?
             @controller.send(method, *arguments)

data/lib/action_controller/cgi_ext/cgi_methods.rb

@@ -1,5 +1,6 @@
 require 'cgi'
 require 'action_controller/vendor/xml_simple'
+require 'action_controller/vendor/xml_node'
 
 # Static methods for parsing the query and request parameters that can be used in
 # a CGI extension class or testing in isolation.
@@ -57,20 +58,84 @@ class CGIMethods #:nodoc:
       parsed_params
     end
 
-    def self.parse_formatted_request_parameters(format, raw_post_data)
-      case format
-        when :xml
-          return XmlSimple.xml_in(raw_post_data, 'ForceArray' => false)
+    def self.parse_formatted_request_parameters(mime_type, raw_post_data)
+      params = 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__'))
         when :yaml
-          return YAML.load(raw_post_data)
+          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
       { "exception" => "#{e.message} (#{e.class})", "backtrace" => e.backtrace, 
-        "raw_post_data" => raw_post_data, "format" => format }
+        "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
+        end
+      else
+        raise "can't typecast #{value.inspect}"
+      end
     end
 
   private
 
+    def self.translate_xml_entities(value)
+      value.gsub(/&lt;/,   "<").
+            gsub(/&gt;/,   ">").
+            gsub(/&quot;/, '"').
+            gsub(/&apos;/, "'").
+            gsub(/&amp;/,  "&")
+    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
+      end
+    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', '']

data/lib/action_controller/cgi_ext/cookie_performance_fix.rb

@@ -108,7 +108,7 @@ class CGI #:nodoc:
       cookies = Hash.new([])
 
       if raw_cookie
-        raw_cookie.split(/; /).each do |pairs|
+        raw_cookie.split(/; ?/).each do |pairs|
           name, values = pairs.split('=',2)
           next unless name and values
           name = CGI::unescape(name)

data/lib/action_controller/cgi_process.rb

@@ -36,25 +36,26 @@ module ActionController #:nodoc:
 
     DEFAULT_SESSION_OPTIONS = {
       :database_manager => CGI::Session::PStore,
-      :prefix => "ruby_sess.",
-      :session_path => "/"
+      :prefix           => "ruby_sess.",
+      :session_path     => "/"
     } unless const_defined?(:DEFAULT_SESSION_OPTIONS)
 
     def initialize(cgi, session_options = {})
       @cgi = cgi
       @session_options = session_options
+      @env = @cgi.send(:env_table)
       super()
     end
 
     def query_string
       if (qs = @cgi.query_string) && !qs.empty?
         qs
-      elsif uri = env['REQUEST_URI']
+      elsif uri = @env['REQUEST_URI']
         parts = uri.split('?')  
         parts.shift
         parts.join('?')
       else
-        env['QUERY_STRING'] || ''
+        @env['QUERY_STRING'] || ''
       end
     end
 
@@ -63,31 +64,39 @@ module ActionController #:nodoc:
     end
 
     def request_parameters
-      if formatted_post?
-        CGIMethods.parse_formatted_request_parameters(post_format, env['RAW_POST_DATA'])
+      if ActionController::Base.param_parsers.has_key?(content_type)
+        CGIMethods.parse_formatted_request_parameters(content_type, @env['RAW_POST_DATA'])
       else
         CGIMethods.parse_request_parameters(@cgi.params)
       end
     end
-    
-    def env
-      @cgi.send(:env_table)
-    end
-
+   
     def cookies
       @cgi.cookies.freeze
     end
 
+    def host_with_port
+      if forwarded = env["HTTP_X_FORWARDED_HOST"]
+        forwarded.split(/,\s?/).last
+      elsif http_host = env['HTTP_HOST']
+        http_host
+      elsif server_name = env['SERVER_NAME']
+        server_name
+      else
+        "#{env['SERVER_ADDR']}:#{env['SERVER_PORT']}"
+      end
+    end
+
     def host
-      env["HTTP_X_FORWARDED_HOST"] || ($1 if env['HTTP_HOST'] && /^(.*):\d+$/ =~ env['HTTP_HOST']) || @cgi.host.to_s.split(":").first || ''
+      host_with_port[/^[^:]+/]
     end
-    
+
     def port
-      env["HTTP_X_FORWARDED_HOST"] ? standard_port : (port_from_http_host || super)
-    end
-    
-    def port_from_http_host
-      $1.to_i if env['HTTP_HOST'] && /:(\d+)$/ =~ env['HTTP_HOST']
+      if host_with_port =~ /:(\d+)$/
+        $1.to_i
+      else
+        standard_port
+      end
     end
 
     def session
@@ -136,7 +145,7 @@ module ActionController #:nodoc:
             Module.const_missing($1)
           rescue LoadError, NameError => const_error
             raise ActionController::SessionRestoreError, <<end_msg
-Session contains objects whose class definition isn't available.
+Session contains objects whose class definition isn\'t available.
 Remember to require the classes for all objects kept in the session.
 (Original exception: #{const_error.message} [#{const_error.class}])
 end_msg
@@ -183,11 +192,14 @@ end_msg
 
     private
       def convert_content_type!(headers)
-        %w( Content-Type Content-type content-type ).each do |ct|
-          if headers[ct]
-            headers["type"] = headers[ct]
-            headers.delete(ct)
-          end
+        if header = headers.delete("Content-Type")
+          headers["type"] = header
+        end
+        if header = headers.delete("Content-type")
+          headers["type"] = header
+        end
+        if header = headers.delete("content-type")
+          headers["type"] = header
         end
       end
   end