actionpack 1.8.1 → 1.9.0

data/lib/action_controller/benchmarking.rb

@@ -15,18 +15,22 @@ module ActionController #:nodoc:
       }
     end
 
-    def render_with_benchmark(template_name = default_template_name, status = "200 OK")
+    def render_with_benchmark(options = {}, deprecated_status = nil)
       if logger.nil?
-        render_without_benchmark(template_name, status)
+        render_without_benchmark(options, deprecated_status)
       else
         db_runtime = ActiveRecord::Base.connection.reset_runtime if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
-        @rendering_runtime = Benchmark::measure{ render_without_benchmark(template_name, status) }.real
+
+        render_output = nil
+        @rendering_runtime = Benchmark::measure{ render_output = render_without_benchmark(options, deprecated_status) }.real
 
         if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
           @db_rt_before_render = db_runtime
           @db_rt_after_render = ActiveRecord::Base.connection.reset_runtime
           @rendering_runtime -= @db_rt_after_render
         end
+
+        render_output
       end
     end    
 
@@ -38,6 +42,7 @@ module ActionController #:nodoc:
         log_message  = "Completed in #{sprintf("%.5f", runtime)} (#{(1 / runtime).floor} reqs/sec)"
         log_message << rendering_runtime(runtime) if @rendering_runtime
         log_message << active_record_runtime(runtime) if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
+        log_message << " [#{complete_request_uri}]"
         logger.info(log_message)
       end
     end

data/lib/action_controller/caching.rb

@@ -256,13 +256,8 @@ module ActionController #:nodoc:
         end
       end
 
-      def cache_base_url
-        @@cache_base_url ||= url_for(:controller => '')
-      end
-
       def fragment_cache_key(name)
-        key = name.is_a?(Hash) ? url_for(name) : cache_base_url + name
-        key.split("://").last
+        name.is_a?(Hash) ? url_for(name).split("://").last : name
       end
 
       # Called by CacheHelper#cache
@@ -281,6 +276,8 @@ module ActionController #:nodoc:
       end
       
       def write_fragment(name, content, options = {})
+        return unless perform_caching
+
         key = fragment_cache_key(name)
         fragment_cache_store.write(key, content, options)
         logger.info "Cached fragment: #{key}" unless logger.nil?
@@ -288,6 +285,8 @@ module ActionController #:nodoc:
       end
       
       def read_fragment(name, options = {})
+        return unless perform_caching
+
         key = fragment_cache_key(name)
         if cache = fragment_cache_store.read(key, options)
           logger.info "Fragment hit: #{key}" unless logger.nil?
@@ -297,16 +296,27 @@ module ActionController #:nodoc:
         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}
       def expire_fragment(name, options = {})
+        return unless perform_caching
+
         key = fragment_cache_key(name)
-        fragment_cache_store.delete(key, options)
-        logger.info "Expired fragment: #{key}" unless logger.nil?
+
+        if key.is_a?(Regexp)
+          fragment_cache_store.delete_matched(key, options)
+          logger.info "Expired fragments matching: #{key.source}" unless logger.nil?
+        else
+          fragment_cache_store.delete(key, options)
+          logger.info "Expired fragment: #{key}" unless logger.nil?
+        end
       end
 
-      def expire_matched_fragments(re=Regexp.new('/.*/'), options = {})
-        rp = cache_base_url.split("://").last
-        fragment_cache_store.delete_matched(re, { :root_path => rp })
-        logger.info "Expired all fragments matching: #{rp}#{re.source}" unless logger.nil?
+      # Deprecated -- just call expire_fragment with a regular expression
+      def expire_matched_fragments(matcher = /.*/, options = {}) #:nodoc:
+        expire_fragment(matcher, options)
       end
 
       class MemoryStore #:nodoc:
@@ -326,9 +336,8 @@ module ActionController #:nodoc:
           @mutex.synchronize { @data.delete(name) }
         end
 
-        def delete_matched(re, options) #:nodoc:
-          re = Regexp.new("#{Regexp.escape(options[:root_path])}#{re.source}")
-          @mutex.synchronize { @data.delete_if { |k,v| k =~ re } }
+        def delete_matched(matcher, options) #:nodoc:
+          @mutex.synchronize { @data.delete_if { |k,v| k =~ matcher } }
         end
       end
 
@@ -361,38 +370,42 @@ module ActionController #:nodoc:
         end
 
         def delete(name, options) #:nodoc:
-          File.delete(real_file_path(name)) if File.exist?(real_file_path(name))
+          File.delete(real_file_path(name))
+        rescue SystemCallError => e
+          Base.logger.info "Couldn't expire cache #{name} (#{e.message})" unless Base.logger.nil?
         end
 
-        def delete_matched(re, options) #:nodoc:
-          rootPath = real_file_path(options[:root_path])
-          search_dir(@cache_path).each do |f|
-            File.delete(f) if f.index(rootPath) == 0 and f =~ re and File.exist?(f)
+        def delete_matched(matcher, options) #:nodoc:
+          search_dir(@cache_path) do |f|
+            if f =~ matcher
+              begin 
+                File.delete(f)
+              rescue Object => e
+                Base.logger.info "Couldn't expire cache: #{f} (#{e.message})" unless Base.logger.nil?
+              end
+            end
           end
         end
     
         private
           def real_file_path(name)
-            '%s/%s' % [@cache_path, name.gsub('?', '.').gsub(':', '.')]
+            '%s/%s.cache' % [@cache_path, name.gsub('?', '.').gsub(':', '.')]
           end
         
           def ensure_cache_path(path)
             FileUtils.makedirs(path) unless File.exists?(path)
           end
 
-          def search_dir(dir)
-            require 'pathname'
-            files = []
-            dir = Dir.new(dir)
-            dir.each do |d|
-              unless d == '.' or d == '..'
-                d = File.join(dir.path, d)
-                p = Pathname.new(d)
-                files << p.to_s if p.file?
-                files += search_dir(d) if p.directory?
+          def search_dir(dir, &callback)
+            Dir.foreach(dir) do |d|
+              next if d == "." || d == ".."
+              name = File.join(dir, d)
+              if File.directory?(name)
+                search_dir(name, &callback)
+              else
+                callback.call name
               end
             end
-            files
           end
       end
     end
@@ -400,17 +413,14 @@ 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 < ActiveRecord::Observer
+    #   class ListSweeper < ActionController::Caching::Sweeper
     #     observe List, Item
     #   
     #     def after_save(record)
-    #       @list = record.is_a?(List) ? record : record.list
-    #     end
-    #     
-    #     def filter(controller)
-    #       controller.expire_page(:controller => "lists", :action => %w( show public feed ), :id => @list.id)
-    #       controller.expire_action(:controller => "lists", :action => "all")
-    #       @list.shares.each { |share| controller.expire_page(:controller => "lists", :action => "show", :id => share.url_key) }
+    #       list = record.is_a?(List) ? record : record.list
+    #       expire_page(:controller => "lists", :action => %w( show public feed ), :id => list.id)
+    #       expire_action(:controller => "lists", :action => "all")
+    #       list.shares.each { |share| expire_page(:controller => "lists", :action => "show", :id => share.url_key) }
     #     end
     #   end
     #
@@ -432,12 +442,48 @@ module ActionController #:nodoc:
         def cache_sweeper(*sweepers)
           return unless perform_caching
           configuration = sweepers.last.is_a?(Hash) ? sweepers.pop : {}
-          sweepers.each do |sweeper| 
+          sweepers.each do |sweeper|
             observer(sweeper)
-            after_filter(Object.const_get(Inflector.classify(sweeper)).instance, :only => configuration[:only])
+
+            sweeper_instance = Object.const_get(Inflector.classify(sweeper)).instance
+
+            if sweeper_instance.is_a?(Sweeper)
+              around_filter(sweeper_instance, :only => configuration[:only])
+            else
+              after_filter(sweeper_instance, :only => configuration[:only])
+            end
           end
         end
       end
     end
+    
+    if defined?(ActiveRecord::Observer)
+      class Sweeper < ActiveRecord::Observer #:nodoc:
+        attr_accessor :controller
+        
+        def before(controller)
+          self.controller = controller
+          callback(:before)
+        end
+
+        def after(controller)
+          callback(:after)
+        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)
+          end
+      end
+    end
   end
 end

data/lib/action_controller/cgi_ext/cgi_ext.rb

@@ -25,7 +25,7 @@ class CGI #:nodoc:
   end
 
   def request_parameters
-    CGIMethods.parse_request_parameters(params)
+    CGIMethods.parse_request_parameters(params, env_table)
   end
 
   def redirect(where)

data/lib/action_controller/cgi_ext/cgi_methods.rb

@@ -1,4 +1,5 @@
 require 'cgi'
+require 'action_controller/vendor/xml_simple'
 
 # Static methods for parsing the query and request parameters that can be used in
 # a CGI extension class or testing in isolation.
@@ -10,25 +11,25 @@ class CGIMethods #:nodoc:
       parsed_params = {}
   
       query_string.split(/[&;]/).each { |p| 
-        k, v = p.split('=')
+        k, v = p.split('=',2)
+        v = nil if (!v.nil? && v.empty?)
 
         k = CGI.unescape(k) unless k.nil?
         v = CGI.unescape(v) unless v.nil?
 
-        if k =~ /(.*)\[\]$/
-            if parsed_params.has_key? $1
-                parsed_params[$1] << v
-            else
-                parsed_params[$1] = [v]
-            end
-        else
-            parsed_params[k] = v.nil? ? nil : v
+        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
       }
   
       return parsed_params
     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!" } } }
@@ -47,7 +48,36 @@ class CGIMethods #:nodoc:
       return 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)
+        when :yaml
+          return YAML.load(raw_post_data)
+      end
+    rescue Object => e
+      { "exception" => "#{e.message} (#{e.class})", "backtrace" => e.backtrace, 
+        "raw_post_data" => raw_post_data, "format" => format }
+    end
+
   private
+
+    # 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
+        
+        return keys
+      else
+        return [key]
+      end
+    end
+    
     def CGIMethods.get_typed_value(value)
       if value.respond_to?(:content_type) && !value.content_type.empty?
         # Uploaded file
@@ -56,7 +86,7 @@ class CGIMethods #:nodoc:
         # Value as part of a multipart request
         value.read
       elsif value.class == Array
-          value
+        value.collect { |v| CGIMethods.get_typed_value(v) }
       else
         # Standard value (not a multipart request)
         value.to_s

data/lib/action_controller/cgi_ext/multipart_progress.rb

@@ -0,0 +1,169 @@
+# == Overview
+#
+# This module will extend the CGI module with methods to track the upload
+# progress for multipart forms for use with progress meters.  The progress is
+# saved in the session to be used from any request from any server with the
+# same session.  In other words, this module will work across application
+# instances.
+#
+# === Usage
+#
+# Just do your file-uploads as you normally would, but include an upload_id in
+# the query string of your form action.  Your form post action should look
+# like:
+#
+#   <form method="post" enctype="multipart/form-data" action="postaction?upload_id=SOMEIDYOUSET">
+#     <input type="file" name="client_file"/>
+#   </form>
+#
+# Query the upload state in a progress by reading the progress from the session
+#
+#   class UploadController < ApplicationController
+#     def upload_status
+#       render :text => "Percent complete: " + @session[:uploads]['SOMEIDYOUSET'].completed_percent"
+#     end
+#   end
+#
+# === Session options
+#
+# Upload progress uses the session options defined in 
+# ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.  If you are passing
+# custom session options to your dispatcher then please follow the
+# "recommended way to change session options":http://wiki.rubyonrails.com/rails/show/HowtoChangeSessionOptions
+#
+# === Update frequency
+#
+# During an upload, the progress will be written to the session every 2
+# seconds.  This prevents excessive writes yet maintains a decent picture of
+# the upload progress for larger files.  
+#
+# User interfaces that update more often that every 2 seconds will display the same results.
+# Consider this update frequency when designing your progress polling.
+#
+
+require 'cgi'
+
+# For integration with ActionPack
+require 'action_controller/base'
+require 'action_controller/cgi_process'
+require 'action_controller/upload_progress'
+
+class CGI #:nodoc:
+  class ProgressIO < SimpleDelegator #:nodoc:
+    MIN_SAVE_INTERVAL = 1.0         # Number of seconds between session saves
+
+    attr_reader :progress, :session
+
+    def initialize(orig_io, progress, session)
+      @session = session
+      @progress = progress
+      
+      @start_time = Time.now
+      @last_save_time = @start_time
+      save_progress
+      
+      super(orig_io)
+    end
+
+    def read(*args)
+      data = __getobj__.read(*args)
+
+      if data and data.size > 0
+        now = Time.now
+        elapsed =  now - @start_time
+        progress.update!(data.size, elapsed)
+
+        if now - @last_save_time > MIN_SAVE_INTERVAL
+          save_progress 
+          @last_save_time = now 
+        end
+      else
+        ActionController::Base.logger.debug("CGI::ProgressIO#read returns nothing when it should return nil if IO is finished: [#{args.inspect}], a cancelled upload or old FCGI bindings.  Resetting the upload progress")
+
+        progress.reset!
+        save_progress
+      end
+
+      data
+    end
+
+    def save_progress
+      @session.update 
+    end
+
+    def finish
+      @session.update
+      ActionController::Base.logger.debug("Finished processing multipart upload in #{@progress.elapsed_seconds.to_s}s")
+    end
+  end
+
+  module QueryExtension #:nodoc:
+    # Need to do lazy aliasing on the instance that we are extending because of the way QueryExtension
+    # gets included for each instance of the CGI object rather than on a module level.  This method is a 
+    # bit obtrusive because we are overriding CGI::QueryExtension::extended which could be used in the 
+    # future.  Need to research a better method
+    def self.extended(obj)
+      obj.instance_eval do
+        # unless defined? will prevent clobbering the progress IO on multiple extensions
+        alias :stdinput_without_progress :stdinput unless defined? stdinput_without_progress
+        alias :stdinput :stdinput_with_progress 
+      end
+    end
+
+    def stdinput_with_progress
+      @stdin_with_progress or stdinput_without_progress
+    end
+
+    private
+    # Bootstrapped on ActionController::UploadProgress::upload_status_for
+    def read_multipart_with_progress(boundary, content_length)
+      begin
+        begin
+          # Session disabled if the default session options have been set to 'false'
+          options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS
+          raise RuntimeError.new("Multipart upload progress disabled, no session options") unless options
+
+          options = options.stringify_keys
+       
+          # Pull in the application controller to satisfy any dependencies on class definitions
+          # of instances stored in the session.
+          Controllers.const_load!(:ApplicationController, "application") unless Controllers.const_defined?(:ApplicationController)
+
+          # Assumes that @cookies has already been setup
+          # Raises nomethod if upload_id is not defined
+          @params = CGI::parse(read_params_from_query)
+          upload_id = @params[(options['upload_key'] || 'upload_id')].first
+          raise RuntimeError.new("Multipart upload progress disabled, no upload id in query string") unless upload_id
+
+          upload_progress = ActionController::UploadProgress::Progress.new(content_length)
+
+          session = Session.new(self, options)
+          session[:uploads] = {} unless session[:uploads]
+          session[:uploads].delete(upload_id) # in case the same upload id is used twice
+          session[:uploads][upload_id] = upload_progress
+
+          @stdin_with_progress = CGI::ProgressIO.new(stdinput_without_progress, upload_progress, session)
+          ActionController::Base.logger.debug("Multipart upload with progress (id: #{upload_id}, size: #{content_length})")
+        rescue
+          ActionController::Base.logger.debug("Exception during setup of read_multipart_with_progress: #{$!}")
+        end
+      ensure
+        begin
+          params = read_multipart_without_progress(boundary, content_length)
+          @stdin_with_progress.finish if @stdin_with_progress.respond_to? :finish
+        ensure
+          @stdin_with_progress = nil
+          session.close if session
+        end
+      end
+      params 
+    end
+
+    # Prevent redefinition of aliases on multiple includes
+    unless private_instance_methods.include?("read_multipart_without_progress")
+      alias_method :read_multipart_without_progress, :read_multipart 
+      alias_method :read_multipart, :read_multipart_with_progress
+    end
+
+  end
+end