Changeset 5163

Timestamp:

09/22/06 03:41:03 (3 years ago)

Author:

bitsweat

Message:

Filters overhaul including meantime filter support for around filters. Closes #5949.

Files:

• trunk/actionpack/CHANGELOG (modified) (1 diff)
• trunk/actionpack/lib/action_controller/filters.rb (modified) (8 diffs)
• trunk/actionpack/test/active_record_unit.rb (modified) (1 diff)
• trunk/actionpack/test/controller/filters_test.rb (modified) (4 diffs)

trunk/actionpack/CHANGELOG

@@ -1 +1 @@
-*SVN*
+
+* Filters overhaul including meantime filter support using around filters + blocks.  #5949 [Martin Emde, Roman Le Negrate, Stefan Kaes, Jeremy Kemper]
-
-* Update RJS render tests. [sam]

trunk/actionpack/lib/action_controller/filters.rb

@@ -6 +6 @@
-    end
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-    #
-    # == Filter inheritance
-    #
-new
+or skip
-    # affecting the superclass. For example:
-    #
@@ -40 +35 @@
-    #
-    # Now any actions performed on the BankController will have the audit method called before. On the VaultController,
- 
+
-    # verify_credentials and the intended action are never called.
-    #
@@ -65 +60 @@
-    # manipulate them as it sees fit.
-    #
- 
+
-    # Or just as a quick test. It works like this:
-    #
@@ -77 +72 @@
-    # and returns 1 or -1 on arity will do (such as a Proc or an Method object).
-    #
+    # Please note that around_filters function a little differently than the normal before and after filters with regard to filter
+    # types. Please see the section dedicated to around_filters below.
+    #
-    # == Filter chain ordering
-    #
@@ -91 +89 @@
-    #
-    # The filter chain for the CheckoutController is now <tt>:ensure_items_in_cart, :ensure_items_in_stock,</tt>
- 
+
-    # is open or not.
-    #
@@ -99 +97 @@
-    # == Around filters
-    #
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    #     end
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    #
-    #   class BenchmarkingFilter
-initialize
-@runtime
+self.filter(controller, &block)
+Benchmark.measure(&block)
-    #     end
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    #     end
-
-
-
-
+
+
+
-    #     end
-    #   end
-    #
+    # If the filter has before and after methods, the before method will be
+    # called before the action. If before returns false, the filter chain is
+    # halted and after will not be run. See Filter Chain Halting below for
+    # an example.
+    #
-    # == Filter chain skipping
-    #
-
-
-
+
+
-    #
-    #   class ApplicationController < ActionController::Base
-    #     before_filter :authenticate
+    #     around_filter :catch_exceptions
-    #   end
-    #
-    #   class WeblogController < ApplicationController
-will run the :authenticate filter
+Will run the :authenticate and :catch_exceptions filters.
-    #   end
-    #
-    #   class SignupController < ApplicationController
-will not run the :authenticate filter
+Skip :authenticate, run :catch_exceptions.
-    #     skip_before_filter :authenticate
-    #   end
-    #
+    #   class ProjectsController < ApplicationController
+    #     # Skip :catch_exceptions, run :authenticate.
+    #     skip_filter :catch_exceptions
+    #   end
+    #
+    #   class ClientsController < ApplicationController
+    #     # Skip :catch_exceptions and :authenticate unless action is index.
+    #     skip_filter :catch_exceptions, :authenticate, :except => :index
+    #   end
+    #
-    # == Filter conditions
-    #
-can be limited to run for only specific actions. This can be expressed either by list
-exclude or the actions to include when executing the filter. Available conditions are +:only+ or +:except+, both 
-f which accept an arbitrary number of method references. For example:
+may be limited to specific actions by declar
+include or exclude. Both options accept single actions (:only => :index)
+r arrays of actions (:except => [:foo, :bar]).
-    #
-    #   class Journal < ActionController::Base
-
-
-
+
+
+
+
+
+
+
+
+
-    #     private
-    #       def authorize
-redirect to login unless authenticated
+Redirect to login unless authenticated.
-    #       end
-    #   end
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    module ClassMethods
-array of filters that's run _before_ actions
-on this controller are
+filter_chain and
+will execute before the action on this controller is
-      def append_before_filter(*filters, &block)
-
-
-
-
-
-
-
-
+
+
+
+
+
-      def prepend_before_filter(*filters, &block)
-
-
-
-
-
-
-
+
+
+
+
-      alias :before_filter :append_before_filter
-
- that's run _after_ actions
-
+
+
+that run _after_ actions 
-      def append_after_filter(*filters, &block)
-
-
-
-
-
-
-
-
+
+
+
+
+
-      def prepend_after_filter(*filters, &block)
-
-
-
-
-
-
-
+
+
+
+
-      alias :after_filter :append_after_filter
-
-
-
-
+
+
+
-      #
-      #   B#before
-      #     A#before
+      #       # run the action
-      #     A#after
-      #   B#after
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-      #
-      #   A#before
-      #     B#before
+      #       # run the action
-      #     B#after
-      #   A#after
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-      alias :around_filter :append_around_filter
-
- 
+
+
-      # 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.
-      #
- 
+
-      # just like when you apply the filters.
-      def skip_before_filter(*filters)
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-      # 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.
-      #
- 
+
-      # just like when you apply the filters.
-      def skip_after_filter(*filters)
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-      # Returns all the before filters for this class and all its ancestors.
+      # This method returns the actual filter that was assigned in the controller to maintain existing functionality.
-      def before_filters #:nodoc:
-@before_filters ||= read_inheritable_attribute("before_filters") || []
-
-
+filter_chain.select(&:before?).map(&:filter)
+
+
-      # Returns all the after filters for this class and all its ancestors.
+      # This method returns the actual filter that was assigned in the controller to maintain existing functionality.
-      def after_filters #:nodoc:
-@after_filters ||= read_inheritable_attribute("after_filters") || []
-
-
+filter_chain.select(&:after?).map(&:filter)
+
+
-      # Returns a mapping between filters and the actions that may run them.
-      def included_actions #:nodoc:
-@included_actions ||= read_inheritable_attribute("included_actions") || {
-
-
+filter_chain.inject({}) { |h,f| h[f.filter] = f.included_actions; h 
+
+
-      # Returns a mapping between filters and actions that may not run them.
-      def excluded_actions #:nodoc:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            end
-          end
+        end
+
+        # The determination of the filter type was once done at run time.
+        # This method is here to extract as much logic from the filter run time as possible
+        def class_for_filter(filter) #:nodoc:
+          case
+          when filter.is_a?(Symbol)
+            SymbolFilter
+          when filter.respond_to?(:call)
+            if filter.is_a?(Method)
+              MethodFilter
+            elsif filter.arity == 1
+              ProcFilter
+            else
+              ProcWithCallFilter
+            end
+          when filter.respond_to?(:filter)
+            ClassFilter
+          else
+            raise(ActionControllerError, 'A filters must be a Symbol, Proc, Method, or object responding to filter.')
+          end
+        end
+
+        def filter_responds_to_before_and_after(filter) #:nodoc:
+          filter.respond_to?(:before) && filter.respond_to?(:after)
+        end
+
+        def proxy_before_and_after_filter(filter) #:nodoc:
+          return filter unless filter_responds_to_before_and_after(filter)
+          Proc.new do |controller, action|
+            unless filter.before(controller) == false
+              begin
+                action.call
+              ensure
+                filter.after(controller)
+              end
+            end
+          end
+        end
+
+        def extract_conditions(*filters, &block) #:nodoc:
+          filters.flatten!
+          conditions = filters.last.is_a?(Hash) ? filters.pop : {}
+          filters << block if block_given?
+          return filters.flatten, conditions
+        end
+
+        def skip_filter_in_chain(*filters, &test) #:nodoc:
+          filters, conditions = extract_conditions(filters)
+          finder_proc = block_given? ?
+            proc { |f| find_filter(f, &test) } :
+            proc { |f| find_filter(f) }
+
+          filters.map(&finder_proc).reject(&:nil?).each do |filter|
+            if conditions.empty?
+              delete_filter_in_chain(filter)
+            else
+              filter.remove_actions_from_included_actions!(conditions[:only] || [])
+              conditions[:only], conditions[:except] = conditions[:except], conditions[:only]
+              filter.update_conditions(conditions)
+            end
+          end
+        end
+
+        def delete_filter_in_chain(filter) #:nodoc:
+          write_inheritable_attribute('filter_chain', filter_chain.reject { |f| f == filter })
-        end
-    end
@@ -358 +610 @@
-
-      def perform_action_with_filters
-
-
-
-
-
-
-
-
+
+
+
+
-      end
-
@@ -373 +621 @@
-      end
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-      private
-        def call_filters(filters)
-          filters.each do |filter| 
-            next if action_exempted?(filter)
-
-            filter_result = case
-              when filter.is_a?(Symbol)
-                self.send(filter)
-              when filter_block?(filter)
-                filter.call(self)
-              when filter_class?(filter)
-                filter.filter(self)
-              else
-                raise(
-                  ActionControllerError, 
-                  'Filters need to be either a symbol, proc/method, or class implementing a static filter method'
-                )
-            end
-
-            if filter_result == false
-              logger.info "Filter chain halted as [#{filter}] returned false" if logger
-              return false 
-            end
-          end
-        end
-        
-        def filter_block?(filter)
-          filter.respond_to?('call') && (filter.arity == 1 || filter.arity == -1)
-        end
-        
-        def filter_class?(filter)
-          filter.respond_to?('filter')
-        end
-
-        def action_exempted?(filter)
-          case
-            when ia = self.class.included_actions[filter]
-              !ia.include?(action_name)
-            when ea = self.class.excluded_actions[filter] 
-              ea.include?(action_name)
-          end
-        end
-
-        def process_cleanup_with_filters
-          if @before_filter_chain_aborted

trunk/actionpack/test/active_record_unit.rb

@@ -107 +107 @@
-    # If things go wrong, we don't want to run our test cases. We'll just define them to test nothing.
-    def abort_tests
+      $stderr.puts 'No Active Record connection, aborting tests.'
-      self.class.public_instance_methods.grep(/^test./).each do |method|
-        self.class.class_eval { define_method(method.to_sym){} }

trunk/actionpack/test/controller/filters_test.rb

@@ -197 +197 @@
-      render_text "hello"
-    end
-  end
-
-  class BadFilterController < ActionController::Base
-    before_filter 2
-    
-    def show() "show" end
-    
-    protected
-      def rescue_action(e) raise(e) end
-  end
-
@@ -337 +328 @@
-    assert_equal nil, test_process(BeforeAndAfterConditionController, "show_without_filter").template.assigns["ran_filter"]
-  end
-
+
-  def test_bad_filter
-
-
-
-
-
+
+
+
+
+
+
-  def test_around_filter
-    controller = test_process(AroundFilterController)
@@ -349 +341 @@
-    assert controller.template.assigns["after_ran"]
-  end
-
+
-  def test_having_properties_in_around_filter
-    controller = test_process(AroundFilterController)
@@ -409 +401 @@
-    end
-end
+
+
+
+class PostsController < ActionController::Base
+  def rescue_action(e); raise e; end
+
+  module AroundExceptions
+    class Error < StandardError ; end
+    class Before < Error ; end
+    class After < Error ; end
+  end
+  include AroundExceptions
+
+  class DefaultFilter
+    include AroundExceptions
+  end
+
+  module_eval %w(raises_before raises_after raises_both no_raise no_filter).map { |action| "def #{action}; default_action end" }.join("\n")
+
+  private
+    def default_action
+      render :inline => "#{action_name} called"
+    end
+end
+
+class ControllerWithSymbolAsFilter < PostsController
+  around_filter :raise_before, :only => :raises_before
+  around_filter :raise_after, :only => :raises_after
+  around_filter :without_exception, :only => :no_raise
+
+  private
+    def raise_before
+      raise Before
+      yield
+    end
+
+    def raise_after
+      yield
+      raise After
+    end
+
+    def without_exception
+      # Do stuff...
+      1 + 1
+
+      yield
+
+      # Do stuff...
+      1 + 1
+    end
+end
+
+class ControllerWithFilterClass < PostsController
+  class YieldingFilter < DefaultFilter
+    def self.filter(controller)
+      yield
+      raise After
+    end
+  end
+
+  around_filter YieldingFilter, :only => :raises_after
+end
+
+class ControllerWithFilterInstance < PostsController
+  class YieldingFilter < DefaultFilter
+    def filter(controller)
+      yield
+      raise After
+    end
+  end
+
+  around_filter YieldingFilter.new, :only => :raises_after
+end
+
+class ControllerWithFilterMethod < PostsController
+  class YieldingFilter < DefaultFilter
+    def filter(controller)
+      yield
+      raise After
+    end
+  end
+
+  around_filter YieldingFilter.new.method(:filter), :only => :raises_after
+end
+
+class ControllerWithProcFilter < PostsController
+  around_filter(:only => :no_raise) do |c,b|
+    c.assigns['before'] = true
+    b.call
+    c.assigns['after'] = true
+  end
+end
+
+class ControllerWithWrongFilterType < PostsController
+  around_filter lambda { yield }, :only => :no_raise
+end
+
+class ControllerWithNestedFilters < ControllerWithSymbolAsFilter
+  around_filter :raise_before, :raise_after, :without_exception, :only => :raises_both
+end
+
+class ControllerWithAllTypesOfFilters < PostsController
+  before_filter :before
+  around_filter :around
+  after_filter :after
+  around_filter :around_again
+
+  private
+  def before
+    @ran_filter ||= []
+    @ran_filter << 'before'
+  end
+
+  def around
+    @ran_filter << 'around (before yield)'
+    yield
+    @ran_filter << 'around (after yield)'
+  end
+
+  def after
+    @ran_filter << 'after'
+  end
+
+  def around_again
+    @ran_filter << 'around_again (before yield)'
+    yield
+    @ran_filter << 'around_again (after yield)'
+  end
+end
+
+class ControllerWithTwoLessFilters < ControllerWithAllTypesOfFilters
+  skip_filter :around_again
+  skip_filter :after
+end
+
+class YieldingAroundFiltersTest < Test::Unit::TestCase
+  include PostsController::AroundExceptions
+
+  def test_filters_registering
+    assert_equal 1, ControllerWithFilterMethod.filter_chain.size
+    assert_equal 1, ControllerWithFilterClass.filter_chain.size
+    assert_equal 1, ControllerWithFilterInstance.filter_chain.size
+    assert_equal 3, ControllerWithSymbolAsFilter.filter_chain.size
+    assert_equal 1, ControllerWithWrongFilterType.filter_chain.size
+    assert_equal 6, ControllerWithNestedFilters.filter_chain.size
+    assert_equal 4, ControllerWithAllTypesOfFilters.filter_chain.size
+  end
+
+  def test_wrong_filter_type
+    assert_raise(ActionController::ActionControllerError) do
+      test_process(ControllerWithWrongFilterType,'no_raise')
+    end
+  end
+
+  def test_base
+    controller = PostsController
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_nothing_raised { test_process(controller,'raises_before') }
+    assert_nothing_raised { test_process(controller,'raises_after') }
+    assert_nothing_raised { test_process(controller,'no_filter') }
+  end
+
+  def test_with_symbol
+    controller = ControllerWithSymbolAsFilter
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_raise(Before) { test_process(controller,'raises_before') }
+    assert_raise(After) { test_process(controller,'raises_after') }
+    assert_nothing_raised { test_process(controller,'no_raise') }
+  end
+
+  def test_with_class
+    controller = ControllerWithFilterClass
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_raise(After) { test_process(controller,'raises_after') }
+  end
+
+  def test_with_instance
+    controller = ControllerWithFilterInstance
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_raise(After) { test_process(controller,'raises_after') }
+  end
+
+  def test_with_method
+    controller = ControllerWithFilterMethod
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_raise(After) { test_process(controller,'raises_after') }
+  end
+
+  def test_with_proc
+    controller = test_process(ControllerWithProcFilter,'no_raise')
+    assert controller.template.assigns['before']
+    assert controller.template.assigns['after']
+  end
+
+  def test_nested_filters
+    controller = ControllerWithNestedFilters
+    assert_nothing_raised do
+      begin
+        test_process(controller,'raises_both')
+      rescue Before, After
+      end
+    end
+    assert_raise Before do
+      begin
+        test_process(controller,'raises_both')
+      rescue After
+      end
+    end
+  end
+
+  def test_filter_order_with_all_filter_types
+    controller = test_process(ControllerWithAllTypesOfFilters,'no_raise')
+    assert_equal 'before around (before yield) around_again (before yield) around_again (after yield) around (after yield) after',controller.template.assigns['ran_filter'].join(' ')
+  end
+
+  def test_filter_order_with_skip_filter_method
+    controller = test_process(ControllerWithTwoLessFilters,'no_raise')
+    assert_equal 'before around (before yield) around (after yield)',controller.template.assigns['ran_filter'].join(' ')
+  end
+
+  protected
+    def test_process(controller, action = "show")
+      request = ActionController::TestRequest.new
+      request.action = action
+      controller.process(request, ActionController::TestResponse.new)
+    end
+end