actionpack 2.0.5 → 2.1.0

data/lib/action_controller/caching/sweeping.rb

@@ -0,0 +1,97 @@
+module ActionController #:nodoc:
+  module Caching
+    # 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)
+    #       expire_action(:controller => "lists", :action => "all")
+    #       list.shares.each { |share| expire_page(:controller => "lists", :action => "show", :id => share.url_key) }
+    #     end
+    #   end
+    #
+    # The sweeper is assigned in the controllers that wish to have its job performed using the <tt>cache_sweeper</tt> class method:
+    #
+    #   class ListsController < ApplicationController
+    #     caches_action :index, :show, :public, :feed
+    #     cache_sweeper :list_sweeper, :only => [ :edit, :destroy, :share ]
+    #   end
+    #
+    # In the example above, four actions are cached and three actions are responsible for expiring those caches.
+    #
+    # You can also name an explicit class in the declaration of a sweeper, which is needed if the sweeper is in a module:
+    #
+    #   class ListsController < ApplicationController
+    #     caches_action :index, :show, :public, :feed
+    #     cache_sweeper OpenBar::Sweeper, :only => [ :edit, :destroy, :share ]
+    #   end
+    module Sweeping
+      def self.included(base) #:nodoc:
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods #:nodoc:
+        def cache_sweeper(*sweepers)
+          configuration = sweepers.extract_options!
+
+          sweepers.each do |sweeper|
+            ActiveRecord::Base.observers << sweeper if defined?(ActiveRecord) and defined?(ActiveRecord::Base)
+            sweeper_instance = (sweeper.is_a?(Symbol) ? Object.const_get(sweeper.to_s.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) and defined?(ActiveRecord::Observer)
+      class Sweeper < ActiveRecord::Observer #:nodoc:
+        attr_accessor :controller
+
+        def before(controller)
+          self.controller = controller
+          callback(:before) if controller.perform_caching
+        end
+
+        def after(controller)
+          callback(:after) if controller.perform_caching
+          # Clean up, so that the controller can be collected after this request
+          self.controller = nil
+        end
+
+        protected
+          # gets the action cache path for the given options.
+          def action_path_for(options)
+            ActionController::Caching::Actions::ActionCachePath.path_for(controller, options)
+          end
+
+          # Retrieve instance variables set in the controller.
+          def assigns(key)
+            controller.instance_variable_get("@#{key}")
+          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, true)
+            send!(action_callback_method_name)     if respond_to?(action_callback_method_name, true)
+          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/cookie.rb

@@ -6,25 +6,24 @@ class CGI #:nodoc:
     attr_accessor :name, :value, :path, :domain, :expires
     attr_reader :secure, :http_only
 
-    # Create a new CGI::Cookie object.
+    # Creates a new CGI::Cookie object.
     #
     # The contents of the cookie can be specified as a +name+ and one
     # or more +value+ arguments.  Alternatively, the contents can
     # be specified as a single hash argument.  The possible keywords of
     # this hash are as follows:
     #
-    # name:: the name of the cookie.  Required.
-    # value:: the cookie's value or list of values.
-    # path:: the path for which this cookie applies.  Defaults to the
-    #        base directory of the CGI script.
-    # domain:: the domain for which this cookie applies.
-    # expires:: the time at which this cookie expires, as a +Time+ object.
-    # secure:: whether this cookie is a secure cookie or not (default to
-    #          false).  Secure cookies are only transmitted to HTTPS
-    #          servers.
-    # http_only:: whether this cookie can be accessed by client side scripts (e.g. document.cookie) or only over HTTP 
-    #             More details: http://msdn2.microsoft.com/en-us/library/system.web.httpcookie.httponly.aspx
-    #             Defaults to false.
+    # * <tt>:name</tt> - The name of the cookie.  Required.
+    # * <tt>:value</tt> - The cookie's value or list of values.
+    # * <tt>:path</tt> - The path for which this cookie applies.  Defaults to the
+    #   base directory of the CGI script.
+    # * <tt>:domain</tt> - The domain for which this cookie applies.
+    # * <tt>:expires</tt> - The time at which this cookie expires, as a Time object.
+    # * <tt>:secure</tt> - Whether this cookie is a secure cookie or not (defaults to
+    #   +false+). Secure cookies are only transmitted to HTTPS servers.
+    # * <tt>:http_only</tt> - Whether this cookie can be accessed by client side scripts (e.g. document.cookie) or only over HTTP.
+    #   More details in http://msdn2.microsoft.com/en-us/library/system.web.httpcookie.httponly.aspx. Defaults to +false+. 
+    #
     # These keywords correspond to attributes of the cookie object.
     def initialize(name = '', *value)
       if name.kind_of?(String)
@@ -37,7 +36,7 @@ class CGI #:nodoc:
         @path = nil
       else
         @name = name['name']
-        @value = Array(name['value'])
+        @value = (name['value'].kind_of?(String) ? [name['value']] : Array(name['value'])).delete_if(&:blank?)
         @domain = name['domain']
         @expires = name['expires']
         @secure = name['secure'] || false
@@ -56,17 +55,17 @@ class CGI #:nodoc:
       super(@value)
     end
 
-    # Set whether the Cookie is a secure cookie or not.
+    # Sets whether the Cookie is a secure cookie or not.
     def secure=(val)
       @secure = val == true
     end
 
-    # Set whether the Cookie is an HTTP only cookie or not.
+    # Sets whether the Cookie is an HTTP only cookie or not.
     def http_only=(val)
       @http_only = val == true
     end
 
-    # Convert the Cookie to its string representation.
+    # Converts the Cookie to its string representation.
     def to_s
       buf = ''
       buf << @name << '='
@@ -79,23 +78,28 @@ class CGI #:nodoc:
       buf
     end
 
-    # Parse a raw cookie string into a hash of cookie-name=>Cookie
+    # FIXME: work around broken 1.8.7 DelegateClass#respond_to?
+    def respond_to?(method, include_private = false)
+      return true if super(method)
+      return __getobj__.respond_to?(method, include_private)
+    end
+
+    # Parses a raw cookie string into a hash of <tt>cookie-name => cookie-object</tt>
     # pairs.
     #
     #   cookies = CGI::Cookie::parse("raw_cookie_string")
-    #     # { "name1" => cookie1, "name2" => cookie2, ... }
+    #     # => { "name1" => cookie1, "name2" => cookie2, ... }
     #
     def self.parse(raw_cookie)
       cookies = Hash.new([])
 
       if raw_cookie
         raw_cookie.split(/;\s?/).each do |pairs|
-          name, values = pairs.split('=',2)
-          next unless name and values
+          name, value = pairs.split('=',2)
+          next unless name and value
           name = CGI::unescape(name)
-          values = values.split('&').collect!{|v| CGI::unescape(v) }
           unless cookies.has_key?(name)
-            cookies[name] = new(name, *values)
+            cookies[name] = new(name, CGI::unescape(value))
           end
         end
       end

data/lib/action_controller/cgi_ext/stdinput.rb

@@ -16,6 +16,7 @@ module ActionController
 
       def initialize_with_stdinput(type = nil, stdinput = $stdin)
         @stdinput = stdinput
+        @stdinput.set_encoding(Encoding::BINARY) if @stdinput.respond_to?(:set_encoding)
         initialize_without_stdinput(type || 'query')
       end
     end

data/lib/action_controller/cgi_process.rb

@@ -3,7 +3,7 @@ require 'action_controller/session/cookie_store'
 
 module ActionController #:nodoc:
   class Base
-    # Process a request extracted from an CGI object and return a response. Pass false as <tt>session_options</tt> to disable
+    # Process a request extracted from a CGI object and return a response. Pass false as <tt>session_options</tt> to disable
     # sessions (large performance increase if sessions are not needed). The <tt>session_options</tt> are the same as for CGI::Session:
     #
     # * <tt>:database_manager</tt> - standard options are CGI::Session::FileStore, CGI::Session::MemoryStore, and CGI::Session::PStore
@@ -15,9 +15,9 @@ module ActionController #:nodoc:
     # * <tt>:new_session</tt> - if true, force creation of a new session.  If not set, a new session is only created if none currently
     #   exists.  If false, a new session is never created, and if none currently exists and the +session_id+ option is not set,
     #   an ArgumentError is raised.
-    # * <tt>:session_expires</tt> - the time the current session expires, as a +Time+ object.  If not set, the session will continue
+    # * <tt>:session_expires</tt> - the time the current session expires, as a Time object.  If not set, the session will continue
     #   indefinitely.
-    # * <tt>:session_domain</tt> -  the hostname domain for which this session is valid. If not set, defaults to the hostname of the
+    # * <tt>:session_domain</tt> - the hostname domain for which this session is valid. If not set, defaults to the hostname of the
     #   server.
     # * <tt>:session_secure</tt> - if +true+, this session will only work over HTTPS.
     # * <tt>:session_path</tt> - the path for which this session applies.  Defaults to the directory of the CGI script.
@@ -34,7 +34,8 @@ module ActionController #:nodoc:
 
   class CgiRequest < AbstractRequest #:nodoc:
     attr_accessor :cgi, :session_options
-    class SessionFixationAttempt < StandardError; end #:nodoc:
+    class SessionFixationAttempt < StandardError #:nodoc:
+    end
 
     DEFAULT_SESSION_OPTIONS = {
       :database_manager => CGI::Session::CookieStore, # store data in cookie
@@ -64,6 +65,7 @@ module ActionController #:nodoc:
     # variable is already set, wrap it in a StringIO.
     def body
       if raw_post = env['RAW_POST_DATA']
+        raw_post.force_encoding(Encoding::BINARY) if raw_post.respond_to?(:force_encoding)
         StringIO.new(raw_post)
       else
         @cgi.stdinput

data/lib/action_controller/components.rb

@@ -39,12 +39,7 @@ module ActionController #:nodoc:
       base.class_eval do
         include InstanceMethods
         extend ClassMethods
-
-        helper do
-          def render_component(options)
-            @controller.send!(:render_component_as_string, options)
-          end
-        end
+        helper HelperMethods
 
         # If this controller was instantiated to process a component request,
         # +parent_controller+ points to the instantiator of this controller.
@@ -67,6 +62,12 @@ module ActionController #:nodoc:
       end
     end
 
+    module HelperMethods
+      def render_component(options)
+        @controller.send!(:render_component_as_string, options)
+      end
+    end
+
     module InstanceMethods
       # Extracts the action_name from the request parameters and performs that action.
       def process_with_components(request, response, method = :perform_action, *arguments) #:nodoc:

data/lib/action_controller/cookies.rb

@@ -1,31 +1,38 @@
 module ActionController #:nodoc:
-  # Cookies are read and written through ActionController#cookies. The cookies being read are what were received along with the request,
-  # the cookies being written are what will be sent out with the response. Cookies are read by value (so you won't get the cookie object
-  # itself back -- just the value it holds). Examples for writing:
+  # Cookies are read and written through ActionController#cookies.
   #
-  #   cookies[:user_name] = "david" # => Will set a simple session cookie
+  # The cookies being read are the ones received along with the request, the cookies
+  # being written will be sent out with the response. Reading a cookie does not get
+  # the cookie object itself back, just the value it holds.
+  #
+  # Examples for writing:
+  #
+  #   # Sets a simple session cookie.
+  #   cookies[:user_name] = "david"
+  #
+  #   # Sets a cookie that expires in 1 hour.
   #   cookies[:login] = { :value => "XJ-122", :expires => 1.hour.from_now }
-  #   # => Will set a cookie that expires in 1 hour
   #
   # Examples for reading:
   #
   #   cookies[:user_name] # => "david"
-  #   cookies.size         # => 2
+  #   cookies.size        # => 2
   #
   # Example for deleting:
   #
   #   cookies.delete :user_name
   #
-  # All the option symbols for setting cookies are:
+  # The option symbols for setting cookies are:
   #
-  # * <tt>value</tt> - the cookie's value or list of values (as an array).
-  # * <tt>path</tt> - the path for which this cookie applies.  Defaults to the root of the application.
-  # * <tt>domain</tt> - the domain for which this cookie applies.
-  # * <tt>expires</tt> - the time at which this cookie expires, as a +Time+ object.
-  # * <tt>secure</tt> - whether this cookie is a secure cookie or not (default to false).
-  #                     Secure cookies are only transmitted to HTTPS servers.
-  # * <tt>http_only</tt> - whether this cookie is accessible via scripting or only HTTP (defaults to false).
-  
+  # * <tt>:value</tt> - The cookie's value or list of values (as an array).
+  # * <tt>:path</tt> - The path for which this cookie applies.  Defaults to the root
+  #   of the application.
+  # * <tt>:domain</tt> - The domain for which this cookie applies.
+  # * <tt>:expires</tt> - The time at which this cookie expires, as a Time object.
+  # * <tt>:secure</tt> - Whether this cookie is a only transmitted to HTTPS servers.
+  #   Default is +false+.
+  # * <tt>:http_only</tt> - Whether this cookie is accessible via scripting or
+  #   only HTTP. Defaults to +false+.
   module Cookies
     def self.included(base)
       base.helper_method :cookies
@@ -45,8 +52,7 @@ module ActionController #:nodoc:
       update(@cookies)
     end
 
-    # Returns the value of the cookie by +name+ -- or nil if no such cookie exists. You set new cookies using cookies[]=
-    # (for simple name/value cookies without options).
+    # Returns the value of the cookie by +name+, or +nil+ if no such cookie exists.
     def [](name)
       cookie = @cookies[name.to_s]
       if cookie && cookie.respond_to?(:value)
@@ -54,6 +60,8 @@ module ActionController #:nodoc:
       end
     end
 
+    # Sets the cookie named +name+. The second argument may be the very cookie
+    # value, or a hash of options as documented above.
     def []=(name, options)
       if options.is_a?(Hash)
         options = options.inject({}) { |options, pair| options[pair.first.to_s] = pair.last; options }
@@ -66,14 +74,18 @@ module ActionController #:nodoc:
     end
 
     # Removes the cookie on the client machine by setting the value to an empty string
-    # and setting its expiration date into the past.  Like []=, you can pass in an options
-    # hash to delete cookies with extra data such as a +path+.
+    # and setting its expiration date into the past. Like <tt>[]=</tt>, you can pass in
+    # an options hash to delete cookies with extra data such as a <tt>:path</tt>.
     def delete(name, options = {})
       options.stringify_keys!
       set_cookie(options.merge("name" => name.to_s, "value" => "", "expires" => Time.at(0)))
     end
 
     private
+      # Builds a CGI::Cookie object and adds the cookie to the response headers.
+      #
+      # The path of the cookie defaults to "/" if there's none in +options+, and
+      # everything is passed to the CGI::Cookie constructor.
       def set_cookie(options) #:doc:
         options["path"] = "/" unless options["path"]
         cookie = CGI::Cookie.new(options)

data/lib/action_controller/dispatcher.rb

@@ -2,27 +2,39 @@ module ActionController
   # Dispatches requests to the appropriate controller and takes care of
   # reloading the app after each request when Dependencies.load? is true.
   class Dispatcher
+    @@guard = Mutex.new
+
     class << self
+      def define_dispatcher_callbacks(cache_classes)
+        unless cache_classes
+          # Development mode callbacks
+          before_dispatch :reload_application
+          after_dispatch :cleanup_application
+        end
+
+        # Common callbacks
+        to_prepare :load_application_controller do
+          begin
+            require_dependency 'application' unless defined?(::ApplicationController)
+          rescue LoadError => error
+            raise unless error.message =~ /application\.rb/
+          end
+        end
+
+        if defined?(ActiveRecord)
+          before_dispatch { ActiveRecord::Base.verify_active_connections! }
+          to_prepare(:activerecord_instantiate_observers) { ActiveRecord::Base.instantiate_observers }
+        end
+
+        after_dispatch :flush_logger if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:flush)
+      end
+
       # Backward-compatible class method takes CGI-specific args. Deprecated
       # in favor of Dispatcher.new(output, request, response).dispatch.
       def dispatch(cgi = nil, session_options = CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
         new(output).dispatch_cgi(cgi, session_options)
       end
 
-      # Declare a block to be called before each dispatch.
-      # Run in the order declared.
-      def before_dispatch(*method_names, &block)
-        callbacks[:before].concat method_names
-        callbacks[:before] << block if block_given?
-      end
-
-      # Declare a block to be called after each dispatch.
-      # Run in reverse of the order declared.
-      def after_dispatch(*method_names, &block)
-        callbacks[:after].concat method_names
-        callbacks[:after] << block if block_given?
-      end
-
       # Add a preparation callback. Preparation callbacks are run before every
       # request in development mode, and before the first request in production
       # mode.
@@ -32,16 +44,9 @@ module ActionController
       # existing callback. Passing an identifier is a suggested practice if the
       # code adding a preparation block may be reloaded.
       def to_prepare(identifier = nil, &block)
-        # Already registered: update the existing callback
-        if identifier
-          if callback = callbacks[:prepare].assoc(identifier)
-            callback[1] = block
-          else
-            callbacks[:prepare] << [identifier, block]
-          end
-        else
-          callbacks[:prepare] << block
-        end
+        @prepare_dispatch_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new
+        callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier)
+        @prepare_dispatch_callbacks | callback
       end
 
       # If the block raises, send status code as a last-ditch response.
@@ -86,37 +91,26 @@ module ActionController
     end
 
     cattr_accessor :error_file_path
-    self.error_file_path = "#{::RAILS_ROOT}/public" if defined? ::RAILS_ROOT
-
-    cattr_accessor :callbacks
-    self.callbacks = Hash.new { |h, k| h[k] = [] }
-
-    cattr_accessor :unprepared
-    self.unprepared = true
-
+    self.error_file_path = Rails.public_path if defined?(Rails.public_path)
 
-    before_dispatch :reload_application
-    before_dispatch :prepare_application
-    after_dispatch :flush_logger
-    after_dispatch :cleanup_application
-
-    if defined? ActiveRecord
-      to_prepare :activerecord_instantiate_observers do
-        ActiveRecord::Base.instantiate_observers
-      end
-    end
+    include ActiveSupport::Callbacks
+    define_callbacks :prepare_dispatch, :before_dispatch, :after_dispatch
 
     def initialize(output, request = nil, response = nil)
       @output, @request, @response = output, request, response
     end
 
     def dispatch
-      run_callbacks :before
-      handle_request
-    rescue Exception => exception
-      failsafe_rescue exception
-    ensure
-      run_callbacks :after, :reverse_each
+      @@guard.synchronize do
+        begin
+          run_callbacks :before_dispatch
+          handle_request
+        rescue Exception => exception
+          failsafe_rescue exception
+        ensure
+          run_callbacks :after_dispatch, :enumerator => :reverse_each
+        end
+      end
     end
 
     def dispatch_cgi(cgi, session_options)
@@ -130,39 +124,23 @@ module ActionController
     end
 
     def reload_application
-      if Dependencies.load?
-        Routing::Routes.reload
-        self.unprepared = true
-      end
-    end
+      # Run prepare callbacks before every request in development mode
+      run_callbacks :prepare_dispatch
 
-    def prepare_application(force = false)
-      begin
-        require_dependency 'application' unless defined?(::ApplicationController)
-      rescue LoadError => error
-        raise unless error.message =~ /application\.rb/
-      end
-
-      ActiveRecord::Base.verify_active_connections! if defined?(ActiveRecord)
-
-      if unprepared || force
-        run_callbacks :prepare
-        self.unprepared = false
-      end
+      Routing::Routes.reload
+      ActionView::TemplateFinder.reload! unless ActionView::Base.cache_template_loading
     end
 
     # Cleanup the application by clearing out loaded classes so they can
     # be reloaded on the next request without restarting the server.
-    def cleanup_application(force = false)
-      if Dependencies.load? || force
-        ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
-        Dependencies.clear
-        ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
-      end
+    def cleanup_application
+      ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
+      Dependencies.clear
+      ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
     end
 
     def flush_logger
-      RAILS_DEFAULT_LOGGER.flush if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:flush)
+      RAILS_DEFAULT_LOGGER.flush
     end
 
     protected
@@ -171,17 +149,6 @@ module ActionController
         @controller.process(@request, @response).out(@output)
       end
 
-      def run_callbacks(kind, enumerator = :each)
-        callbacks[kind].send!(enumerator) do |callback|
-          case callback
-          when Proc; callback.call(self)
-          when String, Symbol; send!(callback)
-          when Array; callback[1].call(self)
-          else raise ArgumentError, "Unrecognized callback #{callback.inspect}"
-          end
-        end
-      end
-
       def failsafe_rescue(exception)
         self.class.failsafe_response(@output, '500 Internal Server Error', exception) do
           if @controller ||= defined?(::ApplicationController) ? ::ApplicationController : Base