Changeset 354

Timestamp:

01/09/05 17:14:47 (4 years ago)

Author:

david

Message:

Added conditional filters #431 [Marcel]

Files:

• trunk/actionpack/CHANGELOG (modified) (1 diff)
• trunk/actionpack/lib/action_controller/filters.rb (modified) (10 diffs)
• trunk/actionpack/test/controller/filters_test.rb (modified) (2 diffs)

trunk/actionpack/CHANGELOG

@@ -1 +1 @@
-*SVN*
+
+* Added conditional filters #431 [Marcel]. Example:
+
+    class JournalController < ActionController::Base
+      # only require authentication if the current action is edit or delete
+      before_filter :authorize, :only_on => [ :edit, :delete ]
+    
+      private
+        def authorize
+          # redirect to login unless authenticated
+        end
+    end
-
-* Added authentication framework to protect actions behind a condition and redirect on failure. See ActionController::Authentication for more.

trunk/actionpack/lib/action_controller/filters.rb

@@ -127 +127 @@
-    #     end
-    #   end
+    #
+    # == Filter conditions
+    #
+    # Filters can be limited to run for only specific actions. This can be expressed either by listing the actions to
+    # exclude or the actions to include when executing the filter. Available conditions are +:only+ or +:except+, both 
+    # of which accept an arbitrary number of method references. For example:
+    #
+    #   class Journal < ActionController::Base
+    #     # only require authentication if the current action is edit or delete
+    #     before_filter :authorize, :only => [ :edit, :delete ]
+    #    
+    #     private
+    #       def authorize
+    #         # redirect to login unless authenticated
+    #       end
+    #   end
+    # 
+    # When setting conditions on inline method (proc) filters the condition must come first and be placed in parenthesis.
+    #
+    #   class UserPreferences < ActionController::Base
+    #     before_filter(:except => :new) { # some proc ... }
+    #     # ...
+    #   end
+    #
-    module ClassMethods
-      # The passed <tt>filters</tt> will be appended to the array of filters that's run _before_ actions
-      # on this controller are performed.
-      def append_before_filter(*filters, &block)
+        conditions = extract_conditions!(filters)
-        filters << block if block_given?
+        add_action_conditions(filters, conditions)
-        append_filter_to_chain("before", filters)
-      end
@@ -138 +164 @@
-      # on this controller are performed.
-      def prepend_before_filter(*filters, &block)
+        conditions = extract_conditions!(filters) 
-        filters << block if block_given?
+        add_action_conditions(filters, conditions)
-        prepend_filter_to_chain("before", filters)
-      end
@@ -148 +176 @@
-      # on this controller are performed.
-      def append_after_filter(*filters, &block)
+        conditions = extract_conditions!(filters) 
-        filters << block if block_given?
+        add_action_conditions(filters, conditions)
-        append_filter_to_chain("after", filters)
-      end
@@ -155 +185 @@
-      # on this controller are performed.
-      def prepend_after_filter(*filters, &block)
+        conditions = extract_conditions!(filters) 
-        filters << block if block_given?
+        add_action_conditions(filters, conditions)
-        prepend_filter_to_chain("after", filters)
-      end
@@ -170 +202 @@
-      #     A#after
-      #   B#after
-
-[filters]
+*
+filters
-          ensure_filter_responds_to_before_and_after(filter)
-          append_before_filter { |c| filter.before(c) }
@@ -186 +218 @@
-      #     B#after
-      #   A#after
-
-[filters]
+*
+filters
-          ensure_filter_responds_to_before_and_after(filter)
-          prepend_before_filter { |c| filter.before(c) }
@@ -205 +237 @@
-      def after_filters #:nodoc:
-        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") || {}
+      end
+      
+      # Returns a mapping between filters and actions that may not run them.
+      def excluded_actions #:nodoc:
+        read_inheritable_attribute("excluded_actions") || {}
-      end
-      
@@ -220 +262 @@
-            raise ActionControllerError, "Filter object must respond to both before and after"
-          end
+        end
+
+        def extract_conditions!(filters)
+          return nil unless filters.last.is_a? Hash
+          filters.pop
+        end
+
+        def add_action_conditions(filters, conditions)
+          return unless conditions
+          included, excluded = conditions[:only], conditions[:except]
+          write_inheritable_hash("included_actions", condition_hash(filters, included)) && return if included
+          write_inheritable_hash("excluded_actions", condition_hash(filters, excluded)) if excluded
+        end
+
+        def condition_hash(filters, *actions)
+          filters.inject({}) {|hash, filter| hash.merge(filter => actions.flatten.map {|action| action.to_s})}
-        end
-    end
@@ -253 +311 @@
-        def call_filters(filters)
-          filters.each do |filter| 
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-            end
+            return false if filter_result == false
-          end
-        end
@@ -275 +336 @@
-          filter.respond_to?("filter")
-        end
+
+        def action_exempted?(filter)
+          case
+            when self.class.included_actions[filter]
+              !self.class.included_actions[filter].include?(action_name)
+            when self.class.excluded_actions[filter] 
+              self.class.excluded_actions[filter].include?(action_name)
+          end
+        end
-    end
-  end

trunk/actionpack/test/controller/filters_test.rb

@@ -16 +16 @@
-  end
-  
+  class ConditionalFilterController < ActionController::Base
+    def show
+      render_text "ran action"
+    end
+
+    def another_action
+      render_text "ran action"
+    end
+
+    def show_without_filter
+      render_text "ran action without filter"
+    end
+
+    private
+      def ensure_login
+        @ran_filter ||= []
+        @ran_filter << "ensure_login"
+      end
+
+      def clean_up_tmp
+        @ran_filter ||= []
+        @ran_filter << "clean_up_tmp"
+      end
+      
+      def rescue_action(e) raise(e) end
+  end
+
+  class ConditionalCollectionFilterController < ConditionalFilterController
+    before_filter :ensure_login, :except => [ :show_without_filter, :another_action ]
+  end
+
+  class OnlyConditionSymController < ConditionalFilterController 
+    before_filter :ensure_login, :only => :show
+  end
+
+  class ExceptConditionSymController < ConditionalFilterController
+    before_filter :ensure_login, :except => :show_without_filter
+  end
+
+  class BeforeAndAfterConditionController < ConditionalFilterController
+    before_filter :ensure_login, :only => :show
+    after_filter  :clean_up_tmp, :only => :show 
+  end
+  
+  class OnlyConditionProcController < ConditionalFilterController 
+    before_filter(:only => :show) {|c| c.assigns["ran_proc_filter"] = true }
+  end
+
+  class ExceptConditionProcController < ConditionalFilterController
+    before_filter(:except => :show_without_filter) {|c| c.assigns["ran_proc_filter"] = true }
+  end
+
+  class ConditionalClassFilter
+    def self.filter(controller) controller.assigns["ran_class_filter"] = true end
+  end
+
+  class OnlyConditionClassController < ConditionalFilterController
+    before_filter ConditionalClassFilter, :only => :show
+  end
+
+  class ExceptConditionClassController < ConditionalFilterController
+    before_filter ConditionalClassFilter, :except => :show_without_filter
+  end
+
+  class AnomolousYetValidConditionController < ConditionalFilterController
+    before_filter(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.assigns["ran_proc_filter1"] = true }, :except => :show_without_filter) { |c| c.assigns["ran_proc_filter2"] = true}
+  end
+
-  class PrependingController < TestController
-    prepend_before_filter :wonderful_life
@@ -127 +195 @@
-  end
-
+  def test_running_anomolous_yet_valid_condition_filters
+    response = test_process(AnomolousYetValidConditionController)
+    assert_equal %w( ensure_login ), response.template.assigns["ran_filter"]
+    assert response.template.assigns["ran_class_filter"]
+    assert response.template.assigns["ran_proc_filter1"]
+    assert response.template.assigns["ran_proc_filter2"]
+    
+    response = test_process(AnomolousYetValidConditionController, "show_without_filter")
+    assert_equal nil, response.template.assigns["ran_filter"]
+    assert !response.template.assigns["ran_class_filter"]
+    assert !response.template.assigns["ran_proc_filter1"]
+    assert !response.template.assigns["ran_proc_filter2"]
+  end
+
+  def test_running_collection_condition_filters
+    assert_equal %w( ensure_login ), test_process(ConditionalCollectionFilterController).template.assigns["ran_filter"]
+    assert_equal nil, test_process(ConditionalCollectionFilterController, "show_without_filter").template.assigns["ran_filter"]
+    assert_equal nil, test_process(ConditionalCollectionFilterController, "another_action").template.assigns["ran_filter"]
+  end
+
+  def test_running_only_condition_filters
+    assert_equal %w( ensure_login ), test_process(OnlyConditionSymController).template.assigns["ran_filter"]
+    assert_equal nil, test_process(OnlyConditionSymController, "show_without_filter").template.assigns["ran_filter"]
+
+    assert test_process(OnlyConditionProcController).template.assigns["ran_proc_filter"]
+    assert !test_process(OnlyConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
+
+    assert test_process(OnlyConditionClassController).template.assigns["ran_class_filter"]
+    assert !test_process(OnlyConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
+  end
+
+  def test_running_except_condition_filters
+    assert_equal %w( ensure_login ), test_process(ExceptConditionSymController).template.assigns["ran_filter"]
+    assert_equal nil, test_process(ExceptConditionSymController, "show_without_filter").template.assigns["ran_filter"]
+
+    assert test_process(ExceptConditionProcController).template.assigns["ran_proc_filter"]
+    assert !test_process(ExceptConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
+
+    assert test_process(ExceptConditionClassController).template.assigns["ran_class_filter"]
+    assert !test_process(ExceptConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
+  end
+
+  def test_running_before_and_after_condition_filters
+    assert_equal %w( ensure_login clean_up_tmp), test_process(BeforeAndAfterConditionController).template.assigns["ran_filter"]
+    assert_equal nil, test_process(BeforeAndAfterConditionController, "show_without_filter").template.assigns["ran_filter"]
+  end
+  
-  def test_bad_filter
-    assert_raises(ActionController::ActionControllerError) {