actionpack 1.11.2 → 1.12.0

data/lib/action_controller/components.rb

@@ -1,18 +1,18 @@
 module ActionController #:nodoc:
-  # Components allows you to call other actions for their rendered response while executing another action. You can either delegate
+  # Components allow you to call other actions for their rendered response while executing another action. You can either delegate
   # the entire response rendering or you can mix a partial response in with your other content.
   #
   #   class WeblogController < ActionController::Base
   #     # Performs a method and then lets hello_world output its render
   #     def delegate_action
   #       do_other_stuff_before_hello_world
-  #       render_component :controller => "greeter",  :action => "hello_world", :params => { "person" => "david" }
+  #       render_component :controller => "greeter",  :action => "hello_world", :params => { :person => "david" }
   #     end
   #   end
   #
   #   class GreeterController < ActionController::Base
   #     def hello_world
-  #       render_text "#{@params['person']} says, Hello World!"
+  #       render :text => "#{params[:person]} says, Hello World!"
   #     end
   #   end
   #
@@ -20,67 +20,167 @@ module ActionController #:nodoc:
   # 
   #   Let's see a greeting: 
   #   <%= render_component :controller => "greeter", :action => "hello_world" %>
+  #
+  # It is also possible to specify the controller as a class constant, bypassing the inflector
+  # code to compute the controller class at runtime:
+  # 
+  # <%= render_component :controller => GreeterController, :action => "hello_world" %>
+  #
+  # == When to use components
+  #
+  # Components should be used with care. They're significantly slower than simply splitting reusable parts into partials and
+  # conceptually more complicated. Don't use components as a way of separating concerns inside a single application. Instead,
+  # reserve components to those rare cases where you truly have reusable view and controller elements that can be employed 
+  # across many applications at once.
+  #
+  # So to repeat: Components are a special-purpose approach that can often be replaced with better use of partials and filters.
   module Components
-    def self.append_features(base) #:nodoc:
-      super
+    def self.included(base) #:nodoc:
+      base.send :include, InstanceMethods
+      base.extend(ClassMethods)
+
       base.helper do
         def render_component(options) 
           @controller.send(:render_component_as_string, options)
         end
       end
-    end
+            
+      # If this controller was instantiated to process a component request,
+      # +parent_controller+ points to the instantiator of this controller.
+      base.send :attr_accessor, :parent_controller
+      
+      base.class_eval do
+        alias_method :process_cleanup_without_components, :process_cleanup
+        alias_method :process_cleanup, :process_cleanup_with_components
+        
+        alias_method :set_session_options_without_components, :set_session_options
+        alias_method :set_session_options, :set_session_options_with_components
+        
+        alias_method :flash_without_components, :flash
+        alias_method :flash, :flash_with_components
 
-    protected
-      # Renders the component specified as the response for the current method
-      def render_component(options = {}) #:doc:
-        component_logging(options) { render_text(component_response(options).body, response.headers["Status"]) }
+        alias_method :component_request?, :parent_controller       
       end
+    end
 
-      # Returns the component response as a string
-      def render_component_as_string(options) #:doc:
-        component_logging(options) do
-          response = component_response(options, false)
-          unless response.redirected_to.nil?
-            render_component_as_string response.redirected_to
-          else
-            response.body
-          end
-       end
+    module ClassMethods
+      # Track parent controller to identify component requests
+      def process_with_components(request, response, parent_controller = nil) #:nodoc:
+        controller = new
+        controller.parent_controller = parent_controller
+        controller.process(request, response)
       end
-  
-    private
-      def component_response(options, reuse_response = true)
-        begin
-          ActionController::Flash::FlashHash.avoid_sweep = true
-          p = component_class(options).process(request_for_component(options), reuse_response ? @response : response_for_component)
-        ensure
-          ActionController::Flash::FlashHash.avoid_sweep = false
-        end
-        p
-      end
-    
-      def component_class(options)
-        options[:controller] ? (options[:controller].camelize + "Controller").constantize : self.class
-      end
-      
-      def request_for_component(options)
-        request_for_component = @request.dup
-        request_for_component.send(
-          :instance_variable_set, :@parameters, 
-          (options[:params] || {}).merge({ "controller" => options[:controller], "action" => options[:action], "id" => options[:id] }).with_indifferent_access
-        )
-        return request_for_component
+
+      # Set the template root to be one directory behind the root dir of the controller. Examples:
+      #   /code/weblog/components/admin/users_controller.rb with Admin::UsersController 
+      #     will use /code/weblog/components as template root 
+      #     and find templates in /code/weblog/components/admin/users/
+      #
+      #   /code/weblog/components/admin/parties/users_controller.rb with Admin::Parties::UsersController 
+      #     will also use /code/weblog/components as template root 
+      #     and find templates in /code/weblog/components/admin/parties/users/
+      def uses_component_template_root
+        path_of_calling_controller = File.dirname(caller[0].split(/:\d+:/).first)
+        path_of_controller_root    = path_of_calling_controller.sub(/#{controller_path.split("/")[0..-2]}$/, "") # " (for ruby-mode)
+
+        self.template_root = path_of_controller_root
       end
-      
-      def response_for_component
-        @response.dup
+    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:
+        flash.discard if component_request?
+        process_without_components(request, response, method, *arguments)
       end
       
-      def component_logging(options)
-        logger.info("Start rendering component (#{options.inspect}): ") unless logger.nil?
-        result = yield
-        logger.info("\n\nEnd of component rendering") unless logger.nil?
-        return result
-      end
+      protected
+        # Renders the component specified as the response for the current method
+        def render_component(options) #:doc:
+          component_logging(options) do
+            render_text(component_response(options, true).body, response.headers["Status"])
+          end
+        end
+
+        # Returns the component response as a string
+        def render_component_as_string(options) #:doc:
+          component_logging(options) do
+            response = component_response(options, false)
+
+            if redirected = response.redirected_to
+              render_component_as_string(redirected)
+            else
+              response.body
+            end
+          end
+        end
+
+        def flash_with_components(refresh = false) #:nodoc:
+          if @flash.nil? || refresh
+            @flash = 
+              if @parent_controller
+                @parent_controller.flash
+              else
+                flash_without_components
+              end
+          end
+          
+          @flash
+        end
+
+      private
+        def component_response(options, reuse_response)
+          klass    = component_class(options)
+          request  = request_for_component(klass.controller_name, options)
+          response = reuse_response ? @response : @response.dup
+
+          klass.process_with_components(request, response, self)
+        end
+        
+        # determine the controller class for the component request
+        def component_class(options)
+          if controller = options[:controller]
+            controller.is_a?(Class) ? controller : "#{controller.camelize}Controller".constantize
+          else
+            self.class
+          end
+        end
+        
+        # Create a new request object based on the current request.
+        # The new request inherits the session from the current request,
+        # bypassing any session options set for the component controller's class
+        def request_for_component(controller_name, options)
+          request         = @request.dup
+          request.session = @request.session
+        
+          request.instance_variable_set(
+            :@parameters,
+            (options[:params] || {}).with_indifferent_access.update(
+              "controller" => controller_name, "action" => options[:action], "id" => options[:id]
+            )
+          )
+          
+          request
+        end
+
+        def component_logging(options)
+          if logger
+            logger.info "Start rendering component (#{options.inspect}): "
+            result = yield
+            logger.info "\n\nEnd of component rendering"
+            result
+          else
+            yield
+          end
+        end
+
+        def set_session_options_with_components(request)
+          set_session_options_without_components(request) unless component_request?
+        end
+
+        def process_cleanup_with_components
+          process_cleanup_without_components unless component_request?
+        end
+    end
   end
 end

data/lib/action_controller/dependencies.rb

@@ -28,7 +28,7 @@ module ActionController #:nodoc:
     #
     # Also note, that if the models follow the pattern of just 1 class per file in the form of MyClass => my_class.rb, then these
     # classes don't have to be required as Active Support will auto-require them.
-    module ClassMethods
+    module ClassMethods #:nodoc:
       # Specifies a variable number of models that this controller depends on. Models are normally Active Record classes or a similar
       # backend for modelling entity classes.
       def model(*models)

data/lib/action_controller/deprecated_redirects.rb

@@ -2,14 +2,14 @@ module ActionController
   class Base
     protected
       # Deprecated in favor of calling redirect_to directly with the path.
-      def redirect_to_path(path)
+      def redirect_to_path(path) #:nodoc:
         redirect_to(path)
       end
 
       # Deprecated in favor of calling redirect_to directly with the url. If the resource has moved permanently, it's possible to pass
       # true as the second parameter and the browser will get "301 Moved Permanently" instead of "302 Found". This can also be done through
       # just setting the headers["Status"] to "301 Moved Permanently" before using the redirect_to.
-      def redirect_to_url(url, permanently = false)
+      def redirect_to_url(url, permanently = false) #:nodoc:
         headers["Status"] = "301 Moved Permanently" if permanently
         redirect_to(url)
       end

data/lib/action_controller/deprecated_request_methods.rb

@@ -0,0 +1,34 @@
+module ActionController
+  class AbstractRequest
+    # Determine whether the body of a HTTP call is URL-encoded (default)
+    # or matches one of the registered param_parsers. 
+    #
+    # For backward compatibility, the post format is extracted from the
+    # X-Post-Data-Format HTTP header if present.
+    def post_format
+      case content_type.to_s
+      when 'application/xml'
+        :xml
+      when 'application/x-yaml'
+        :yaml
+      else
+        :url_encoded
+      end
+    end
+
+    # Is this a POST request formatted as XML or YAML?
+    def formatted_post?
+      post? && (post_format == :yaml || post_format == :xml)
+    end
+
+    # Is this a POST request formatted as XML?
+    def xml_post?
+      post? && post_format == :xml
+    end
+
+    # Is this a POST request formatted as YAML?
+    def yaml_post?
+      post? && post_format == :yaml
+    end
+  end
+end

data/lib/action_controller/filters.rb

@@ -1,7 +1,6 @@
 module ActionController #:nodoc:
   module Filters #:nodoc:
-    def self.append_features(base)
-      super
+    def self.included(base)
       base.extend(ClassMethods)
       base.send(:include, ActionController::Filters::InstanceMethods)
     end
@@ -141,7 +140,7 @@ module ActionController #:nodoc:
     #     # will run the :authenticate filter
     #   end
     #
-    #   class SignupController < ActionController::Base
+    #   class SignupController < ApplicationController
     #     # will not run the :authenticate filter
     #     skip_before_filter :authenticate
     #   end
@@ -251,39 +250,55 @@ module ActionController #:nodoc:
       # Removes the specified filters from the +before+ filter chain. Note that this only works for skipping method-reference 
       # filters, not procs. This is especially useful for managing the chain in inheritance hierarchies where only one out
       # of many sub-controllers need a different hierarchy.
+      #
+      # You can control the actions to skip the filter for with the <tt>:only</tt> and <tt>:except</tt> options, 
+      # just like when you apply the filters.
       def skip_before_filter(*filters)
-        for filter in filters.flatten
-          write_inheritable_attribute("before_filters", read_inheritable_attribute("before_filters") - [ filter ])
+        if conditions = extract_conditions!(filters)
+          conditions[:only], conditions[:except] = conditions[:except], conditions[:only]
+          add_action_conditions(filters, conditions)
+        else
+          for filter in filters.flatten
+            write_inheritable_attribute("before_filters", read_inheritable_attribute("before_filters") - [ filter ])
+          end
         end
       end
 
       # Removes the specified filters from the +after+ filter chain. Note that this only works for skipping method-reference 
       # filters, not procs. This is especially useful for managing the chain in inheritance hierarchies where only one out
       # of many sub-controllers need a different hierarchy.
+      #
+      # You can control the actions to skip the filter for with the <tt>:only</tt> and <tt>:except</tt> options, 
+      # just like when you apply the filters.
       def skip_after_filter(*filters)
-        for filter in filters.flatten
-          write_inheritable_attribute("after_filters", read_inheritable_attribute("after_filters") - [ filter ])
+        if conditions = extract_conditions!(filters)
+          conditions[:only], conditions[:except] = conditions[:except], conditions[:only]
+          add_action_conditions(filters, conditions)
+        else
+          for filter in filters.flatten
+            write_inheritable_attribute("after_filters", read_inheritable_attribute("after_filters") - [ filter ])
+          end
         end
       end
       
       # Returns all the before filters for this class and all its ancestors.
       def before_filters #:nodoc:
-        read_inheritable_attribute("before_filters")
+        @before_filters ||= read_inheritable_attribute("before_filters") || []
       end
       
       # Returns all the after filters for this class and all its ancestors.
       def after_filters #:nodoc:
-        read_inheritable_attribute("after_filters")
+        @after_filters ||= read_inheritable_attribute("after_filters") || []
       end
       
       # Returns a mapping between filters and the actions that may run them.
       def included_actions #:nodoc:
-        read_inheritable_attribute("included_actions") || {}
+        @included_actions ||= read_inheritable_attribute("included_actions") || {}
       end
       
       # Returns a mapping between filters and actions that may not run them.
       def excluded_actions #:nodoc:
-        read_inheritable_attribute("excluded_actions") || {}
+        @excluded_actions ||= read_inheritable_attribute("excluded_actions") || {}
       end
       
       private
@@ -292,7 +307,8 @@ module ActionController #:nodoc:
         end
 
         def prepend_filter_to_chain(condition, filters)
-          write_inheritable_attribute("#{condition}_filters", filters + read_inheritable_attribute("#{condition}_filters"))
+          old_filters = read_inheritable_attribute("#{condition}_filters") || []
+          write_inheritable_attribute("#{condition}_filters", filters + old_filters)
         end
 
         def ensure_filter_responds_to_before_and_after(filter)
@@ -319,18 +335,33 @@ module ActionController #:nodoc:
     end
 
     module InstanceMethods # :nodoc:
-      def self.append_features(base)
-        super
-        base.class_eval {
+      def self.included(base)
+        base.class_eval do
           alias_method :perform_action_without_filters, :perform_action
           alias_method :perform_action, :perform_action_with_filters
-        }
+
+          alias_method :process_without_filters, :process
+          alias_method :process, :process_with_filters
+
+          alias_method :process_cleanup_without_filters, :process_cleanup
+          alias_method :process_cleanup, :process_cleanup_with_filters
+        end
       end
 
       def perform_action_with_filters
-        return if before_action == false || performed?
-        perform_action_without_filters
-        after_action
+        before_action_result = before_action
+
+        unless before_action_result == false || performed?
+          perform_action_without_filters
+          after_action
+        end
+
+        @before_filter_chain_aborted = (before_action_result == false)
+      end
+
+      def process_with_filters(request, response, method = :perform_action, *arguments) #:nodoc:
+        @before_filter_chain_aborted = false
+        process_without_filters(request, response, method, *arguments)
       end
 
       # Calls all the defined before-filter filters, which are added by using "before_filter :method".
@@ -349,6 +380,7 @@ module ActionController #:nodoc:
         def call_filters(filters)
           filters.each do |filter| 
             next if action_exempted?(filter)
+
             filter_result = case
               when filter.is_a?(Symbol)
                 self.send(filter)
@@ -386,6 +418,14 @@ module ActionController #:nodoc:
               ea.include?(action_name)
           end
         end
+
+        def process_cleanup_with_filters
+          if @before_filter_chain_aborted
+            close_session
+          else
+            process_cleanup_without_filters
+          end
+        end
     end
   end
 end