actionpack 1.9.1 → 1.10.1

data/lib/action_controller/benchmarking.rb

@@ -6,17 +6,45 @@ module ActionController #:nodoc:
   module Benchmarking #:nodoc:
     def self.append_features(base)
       super
-      base.class_eval {
+      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
-      }
+      end
+    end
+
+    module ClassMethods
+      # Log and benchmark the workings of a single block and silence whatever logging that may have happened inside it 
+      # (unless <tt>use_silence</tt> is set to false).
+      #
+      # The benchmark is only recorded if the current level of the logger matches the <tt>log_level</tt>, which makes it
+      # easy to include benchmarking statements in production software that will remain inexpensive because the benchmark
+      # will only be conducted if the log level is low enough.
+      def benchmark(title, log_level = Logger::DEBUG, use_silence = true)
+        if logger && logger.level == log_level
+          result = nil
+          seconds = Benchmark.realtime { result = use_silence ? silence { yield } : yield }
+          logger.add(log_level, "#{title} (#{'%.5f' % seconds})")
+          result
+        else
+          yield
+        end
+      end
+
+      # Silences the logger for the duration of the block.
+      def silence
+        old_logger_level, logger.level = logger.level, Logger::ERROR if logger
+        yield
+      ensure
+        logger.level = old_logger_level if logger
+      end
     end
 
-    def render_with_benchmark(options = {}, deprecated_status = nil)
-      if logger.nil?
+    def render_with_benchmark(options = nil, deprecated_status = nil)
+      unless logger
         render_without_benchmark(options, deprecated_status)
       else
         db_runtime = ActiveRecord::Base.connection.reset_runtime if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
@@ -35,14 +63,15 @@ module ActionController #:nodoc:
     end    
 
     def perform_action_with_benchmark
-      if logger.nil?
+      unless logger
         perform_action_without_benchmark
       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 << active_record_runtime(runtime) if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
-        log_message << " [#{complete_request_uri}]"
+        log_message << " | #{headers["Status"]}"
+        log_message << " [#{complete_request_uri rescue "unknown"}]"
         logger.info(log_message)
       end
     end

data/lib/action_controller/caching.rb

@@ -57,8 +57,7 @@ module ActionController #:nodoc:
     # By default, the cache extension is .html, which makes it easy for the cached files to be picked up by the web server. If you want
     # something else, like .php or .shtml, just set Base.page_cache_extension.
     module Pages
-      def self.append_features(base) #:nodoc:
-        super
+      def self.included(base) #:nodoc:
         base.extend(ClassMethods)
         base.class_eval do
           @@page_cache_directory = defined?(RAILS_ROOT) ? "#{RAILS_ROOT}/public" : ""
@@ -74,17 +73,21 @@ module ActionController #:nodoc:
         #   expire_page "/lists/show"
         def expire_page(path)
           return unless perform_caching
-          File.delete(page_cache_path(path)) if File.exists?(page_cache_path(path))
-          logger.info "Expired page: #{page_cache_file(path)}" unless logger.nil?
+
+          benchmark "Expired page: #{page_cache_file(path)}" do
+            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)
           return unless perform_caching
-          FileUtils.makedirs(File.dirname(page_cache_path(path)))
-          File.open(page_cache_path(path), "w+") { |f| f.write(content) }
-          logger.info "Cached page: #{page_cache_file(path)}" unless logger.nil?
+
+          benchmark "Cached page: #{page_cache_file(path)}" do
+            FileUtils.makedirs(File.dirname(page_cache_path(path)))
+            File.open(page_cache_path(path), "wb+") { |f| f.write(content) }
+          end
         end
 
         # Caches the +actions+ using the page-caching approach that'll store the cache in a path within the page_cache_directory that
@@ -98,7 +101,7 @@ module ActionController #:nodoc:
         
         private
           def page_cache_file(path)
-            name = ((path.empty? || path == "/") ? "/index" : path)
+            name = ((path.empty? || path == "/") ? "/index" : URI.unescape(path))
             name << page_cache_extension unless (name.split('/').last || name).include? '.'
             return name
           end
@@ -232,27 +235,32 @@ module ActionController #:nodoc:
     #   up a lot of memory since each process keeps all the caches in memory.
     # * DRbStore: Keeps the fragments in the memory of a separate, shared DRb process. This works for all environments and only keeps one cache
     #   around for all processes, but requires that you run and manage a separate DRb process.
-    # * MemCachedStore: Works like DRbStore, but uses Danga's MemCached instead.
+    # * MemCacheStore: Works like DRbStore, but uses Danga's MemCache instead.
     #
     # Configuration examples (MemoryStore is the default):
     #
-    #   ActionController::Base.fragment_cache_store = 
-    #     ActionController::Caching::Fragments::MemoryStore.new
-    #
-    #   ActionController::Base.fragment_cache_store = 
-    #     ActionController::Caching::Fragments::FileStore.new("/path/to/cache/directory")
-    #
-    #   ActionController::Base.fragment_cache_store = 
-    #     ActionController::Caching::Fragments::DRbStore.new("druby://localhost:9192")
-    #
-    #   ActionController::Base.fragment_cache_store = 
-    #     ActionController::Caching::Fragments::FileStore.new("localhost")
+    #   ActionController::Base.fragment_cache_store = :memory_store
+    #   ActionController::Base.fragment_cache_store = :file_store, "/path/to/cache/directory"
+    #   ActionController::Base.fragment_cache_store = :drb_store, "druby://localhost:9192"
+    #   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
         base.class_eval do
           @@fragment_cache_store = MemoryStore.new
-          cattr_accessor :fragment_cache_store
+          cattr_reader :fragment_cache_store
+
+          def self.fragment_cache_store=(store_option)
+            store, *parameters = *([ store_option ].flatten)
+            @@fragment_cache_store = if store.is_a?(Symbol)
+              store_class_name = (store == :drb_store ? "DRbStore" : store.to_s.camelize)
+              store_class = ActionController::Caching::Fragments.const_get(store_class_name)
+              parameters.empty? ? store.new : store_class.new(*parameters)
+            else
+              store
+            end
+          end
         end
       end
 
@@ -261,7 +269,7 @@ module ActionController #:nodoc:
       end
 
       # Called by CacheHelper#cache
-      def cache_erb_fragment(block, name = {}, options = {})
+      def cache_erb_fragment(block, name = {}, options = nil)
         unless perform_caching then block.call; return end
         
         buffer = eval("_erbout", block.binding)
@@ -275,24 +283,22 @@ module ActionController #:nodoc:
         end
       end
       
-      def write_fragment(name, content, options = {})
+      def write_fragment(name, content, options = nil)
         return unless perform_caching
 
         key = fragment_cache_key(name)
-        fragment_cache_store.write(key, content, options)
-        logger.info "Cached fragment: #{key}" unless logger.nil?
+        self.class.benchmark "Cached fragment: #{key}" do
+          fragment_cache_store.write(key, content, options)
+        end
         content
       end
       
-      def read_fragment(name, options = {})
+      def read_fragment(name, options = nil)
         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?
-          cache
-        else
-          false
+        self.class.benchmark "Fragment read: #{key}" do
+          fragment_cache_store.read(key, options)
         end
       end
       
@@ -300,79 +306,120 @@ module ActionController #:nodoc:
       # * 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 = {})
+      def expire_fragment(name, options = nil)
         return unless perform_caching
 
         key = fragment_cache_key(name)
 
         if key.is_a?(Regexp)
-          fragment_cache_store.delete_matched(key, options)
-          logger.info "Expired fragments matching: #{key.source}" unless logger.nil?
+          self.class.benchmark "Expired fragments matching: #{key.source}" do
+            fragment_cache_store.delete_matched(key, options)
+          end
         else
-          fragment_cache_store.delete(key, options)
-          logger.info "Expired fragment: #{key}" unless logger.nil?
+          self.class.benchmark "Expired fragment: #{key}" do
+            fragment_cache_store.delete(key, options)
+          end
         end
       end
 
       # Deprecated -- just call expire_fragment with a regular expression
-      def expire_matched_fragments(matcher = /.*/, options = {}) #:nodoc:
+      def expire_matched_fragments(matcher = /.*/, options = nil) #:nodoc:
         expire_fragment(matcher, options)
       end
 
-      class MemoryStore #:nodoc:
-        def initialize
-          @data, @mutex = { }, Mutex.new
+
+      class UnthreadedMemoryStore #:nodoc:
+        def initialize #:nodoc:
+          @data = {}
         end
 
-        def read(name, options = {}) #:nodoc:
-          @mutex.synchronize { @data[name] } rescue nil
+        def read(name, options=nil) #:nodoc:
+          @data[name]
         end
 
-        def write(name, value, options = {}) #:nodoc:
-          @mutex.synchronize { @data[name] = value }
+        def write(name, value, options=nil) #:nodoc:
+          @data[name] = value
         end
 
-        def delete(name, options = {}) #:nodoc:
-          @mutex.synchronize { @data.delete(name) }
+        def delete(name, options=nil) #:nodoc:
+          @data.delete(name)
         end
 
-        def delete_matched(matcher, options) #:nodoc:
-          @mutex.synchronize { @data.delete_if { |k,v| k =~ matcher } }
+        def delete_matched(matcher, options=nil) #:nodoc:
+          @data.delete_if { |k,v| k =~ matcher }
+        end
+      end
+
+      module ThreadSafety #: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
+      end
+
+      class MemoryStore < UnthreadedMemoryStore #:nodoc:
+        def initialize #:nodoc:
+          super
+          if ActionController::Base.allow_concurrency
+            @mutex = Mutex.new
+            MemoryStore.send(:include, ThreadSafety)
+          end
         end
       end
 
       class DRbStore < MemoryStore #:nodoc:
+        attr_reader :address
+
         def initialize(address = 'druby://localhost:9192')
-          @data, @mutex = DRbObject.new(nil, address), Mutex.new
+          super()
+          @address = address
+          @data = DRbObject.new(nil, address)
         end    
       end
 
       class MemCacheStore < MemoryStore #:nodoc:
+        attr_reader :address
+
         def initialize(address = 'localhost')
-          @data, @mutex = MemCache.new(address), Mutex.new
+          super()
+          @address = address
+          @data = MemCache.new(address)
         end    
       end
 
-      class FileStore #:nodoc:
+      class UnthreadedFileStore #:nodoc:
+        attr_reader :cache_path
+        
         def initialize(cache_path)
           @cache_path = cache_path
         end
     
-        def write(name, value, options = {}) #:nodoc:
+        def write(name, value, options = nil) #:nodoc:
           ensure_cache_path(File.dirname(real_file_path(name)))
-          File.open(real_file_path(name), "w+") { |f| f.write(value) }
+          File.open(real_file_path(name), "wb+") { |f| f.write(value) }
         rescue => e
-          Base.logger.info "Couldn't create cache directory: #{name} (#{e.message})" unless Base.logger.nil?
+          Base.logger.error "Couldn't create cache directory: #{name} (#{e.message})" if Base.logger
         end
 
-        def read(name, options = {}) #:nodoc:
+        def read(name, options = nil) #:nodoc:
           IO.read(real_file_path(name)) rescue nil
         end
 
         def delete(name, options) #:nodoc:
           File.delete(real_file_path(name))
         rescue SystemCallError => e
-          Base.logger.info "Couldn't expire cache #{name} (#{e.message})" unless Base.logger.nil?
+          # If there's no cache, then there's nothing to complain about
         end
 
         def delete_matched(matcher, options) #:nodoc:
@@ -381,7 +428,7 @@ module ActionController #:nodoc:
               begin 
                 File.delete(f)
               rescue Object => e
-                Base.logger.info "Couldn't expire cache: #{f} (#{e.message})" unless Base.logger.nil?
+                # If there's no cache, then there's nothing to complain about
               end
             end
           end
@@ -407,7 +454,17 @@ module ActionController #:nodoc:
               end
             end
           end
-      end
+        end
+
+        class FileStore < UnthreadedFileStore #:nodoc:
+          def initialize(cache_path)
+            super(cache_path)
+            if ActionController::Base.allow_concurrency
+              @mutex = Mutex.new
+              FileStore.send(:include, ThreadSafety)
+            end
+          end
+        end
     end
 
     # Sweepers are the terminators of the caching world and responsible for expiring caches when model objects change.

data/lib/action_controller/cgi_ext/cgi_methods.rb

@@ -11,23 +11,30 @@ class CGIMethods #:nodoc:
       parsed_params = {}
   
       query_string.split(/[&;]/).each { |p| 
+        # Ignore repeated delimiters.
+        next if p.empty?
+
         k, v = p.split('=',2)
-        v = nil if (!v.nil? && v.empty?)
+        v = nil if (v && v.empty?)
 
-        k = CGI.unescape(k) unless k.nil?
-        v = CGI.unescape(v) unless v.nil?
+        k = CGI.unescape(k) if k
+        v = CGI.unescape(v) if 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
+        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
       }
   
-      return parsed_params
+      parsed_params
     end
 
     # Returns the request (POST/GET) parameters in a parsed form where pairs such as "customer[address][street]" / 
@@ -38,14 +45,16 @@ class CGIMethods #:nodoc:
 
       for key, value in params
         value = [value] if key =~ /.*\[\]$/
-        CGIMethods.build_deep_hash(
-          CGIMethods.get_typed_value(value[0]),
-          parsed_params, 
-          CGIMethods.get_levels(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))
+        end
       end
     
-      return parsed_params
+      parsed_params
     end
 
     def self.parse_formatted_request_parameters(format, raw_post_data)
@@ -72,23 +81,47 @@ class CGIMethods #:nodoc:
         keys.concat($2[1..-2].split(']['))
         keys << '' if key[-2..-1] == '[]' # Have to add it since split will drop empty strings
         
-        return keys
+        keys
       else
-        return [key]
+        [key]
       end
     end
     
     def CGIMethods.get_typed_value(value)
-      if value.respond_to?(:content_type) && !value.content_type.empty?
+      # 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
+            end
+          end
+        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
-        # Standard value (not a multipart request)
+        # other value (neither string nor a multipart request)
         value.to_s
       end
     end