Rename all action callbacks from *_filter to *_action

3 files changed, 118 insertions, 69 deletions

diff --git a/actionpack/CHANGELOG.md b/actionpack/CHANGELOG.md
index b57408ede3..88cac3552d 100644
--- a/actionpack/CHANGELOG.md
+++ b/actionpack/CHANGELOG.md
@@ -1,4 +1,31 @@
 ## Rails 4.0.0 (unreleased) ##
+
+*   Rename all action callbacks from *_filter to *_action to avoid the misconception that these
+    callbacks are only suited for transforming or halting the response. With the new style,
+    it's more inviting to use them as they were intended, like setting shared ivars for views.
+    
+    Example:
+    
+        class PeopleController < ActionController::Base
+          before_action :set_person,      except: [ :index, :new, :create ]
+          before_action :ensure_permission, only: [ :edit, :update ]
+          
+          ...
+          
+          private
+            def set_person
+              @person = current_account.people.find(params[:id])
+            end
+            
+            def ensure_permission
+              current_person.change_change?(@person)
+            end
+        end
+    
+    The old *_filter methods still work with no deprecation notice.
+    
+    *DHH*
+
 *   Add :if / :unless conditions to fragment cache:
 
         <%= cache @model, if: some_condition(@model) do %>
diff --git a/actionpack/lib/abstract_controller/callbacks.rb b/actionpack/lib/abstract_controller/callbacks.rb
index 02ac111392..33799fe6dc 100644
--- a/actionpack/lib/abstract_controller/callbacks.rb
+++ b/actionpack/lib/abstract_controller/callbacks.rb
@@ -40,18 +40,21 @@ module AbstractController
         end
       end
 
-      # Skip before, after, and around filters matching any of the names
+      # Skip before, after, and around action callbacks matching any of the names
+      # Aliased as skip_filter.
       #
       # ==== Parameters
       # * <tt>names</tt> - A list of valid names that could be used for
       #   callbacks. Note that skipping uses Ruby equality, so it's
       #   impossible to skip a callback defined using an anonymous proc
       #   using #skip_filter
-      def skip_filter(*names)
-        skip_before_filter(*names)
-        skip_after_filter(*names)
-        skip_around_filter(*names)
+      def skip_action_callback(*names)
+        skip_before_action(*names)
+        skip_after_action(*names)
+        skip_around_action(*names)
       end
+      
+      alias_method :skip_filter, :skip_action_callback
 
       # Take callback names and an optional callback proc, normalize them,
       # then call the block with each callback. This allows us to abstract
@@ -75,119 +78,138 @@ module AbstractController
       end
 
       ##
-      # :method: before_filter
+      # :method: before_action
       #
-      # :call-seq: before_filter(names, block)
+      # :call-seq: before_action(names, block)
       #
-      # Append a before filter. See _insert_callbacks for parameter details.
+      # Append a callback before actions. See _insert_callbacks for parameter details.
+      # Aliased as before_filter.
 
       ##
-      # :method: prepend_before_filter
+      # :method: prepend_before_action
       #
-      # :call-seq: prepend_before_filter(names, block)
+      # :call-seq: prepend_before_action(names, block)
       #
-      # Prepend a before filter. See _insert_callbacks for parameter details.
+      # Prepend a callback before actions. See _insert_callbacks for parameter details.
+      # Aliased as prepend_before_action.
 
       ##
-      # :method: skip_before_filter
+      # :method: skip_before_action
       #
-      # :call-seq: skip_before_filter(names)
+      # :call-seq: skip_before_action(names)
       #
-      # Skip a before filter. See _insert_callbacks for parameter details.
+      # Skip a callback before actions. See _insert_callbacks for parameter details.
+      # Aliased as skip_before_filter.
 
       ##
-      # :method: append_before_filter
+      # :method: append_before_action
       #
-      # :call-seq: append_before_filter(names, block)
+      # :call-seq: append_before_action(names, block)
       #
-      # Append a before filter. See _insert_callbacks for parameter details.
+      # Append a callback before actions. See _insert_callbacks for parameter details.
+      # Aliased as append_before_filter.
 
       ##
-      # :method: after_filter
+      # :method: after_action
       #
-      # :call-seq: after_filter(names, block)
+      # :call-seq: after_action(names, block)
       #
-      # Append an after filter. See _insert_callbacks for parameter details.
+      # Append a callback after actions. See _insert_callbacks for parameter details.
+      # Aliased as after_filter.
 
       ##
-      # :method: prepend_after_filter
+      # :method: prepend_after_action
       #
-      # :call-seq: prepend_after_filter(names, block)
+      # :call-seq: prepend_after_action(names, block)
       #
-      # Prepend an after filter. See _insert_callbacks for parameter details.
+      # Prepend a callback after actions. See _insert_callbacks for parameter details.
+      # Aliased as prepend_after_filter.
 
       ##
-      # :method: skip_after_filter
+      # :method: skip_after_action
       #
-      # :call-seq: skip_after_filter(names)
+      # :call-seq: skip_after_action(names)
       #
-      # Skip an after filter. See _insert_callbacks for parameter details.
+      # Skip a callback after actions. See _insert_callbacks for parameter details.
+      # Aliased as skip_after_filter.
 
       ##
-      # :method: append_after_filter
+      # :method: append_after_action
       #
-      # :call-seq: append_after_filter(names, block)
+      # :call-seq: append_after_action(names, block)
       #
-      # Append an after filter. See _insert_callbacks for parameter details.
+      # Append a callback after actions. See _insert_callbacks for parameter details.
+      # Aliased as append_after_filter.
 
       ##
-      # :method: around_filter
+      # :method: around_action
       #
-      # :call-seq: around_filter(names, block)
+      # :call-seq: around_action(names, block)
       #
-      # Append an around filter. See _insert_callbacks for parameter details.
+      # Append a callback around actions. See _insert_callbacks for parameter details.
+      # Aliased as around_filter.
 
       ##
-      # :method: prepend_around_filter
+      # :method: prepend_around_action
       #
-      # :call-seq: prepend_around_filter(names, block)
+      # :call-seq: prepend_around_action(names, block)
       #
-      # Prepend an around filter. See _insert_callbacks for parameter details.
+      # Prepend a callback around actions. See _insert_callbacks for parameter details.
+      # Aliased as prepend_around_filter.
 
       ##
-      # :method: skip_around_filter
+      # :method: skip_around_action
       #
-      # :call-seq: skip_around_filter(names)
+      # :call-seq: skip_around_action(names)
       #
-      # Skip an around filter. See _insert_callbacks for parameter details.
+      # Skip a callback around actions. See _insert_callbacks for parameter details.
+      # Aliased as skip_around_filter.
 
       ##
-      # :method: append_around_filter
+      # :method: append_around_action
       #
-      # :call-seq: append_around_filter(names, block)
+      # :call-seq: append_around_action(names, block)
       #
-      # Append an around filter. See _insert_callbacks for parameter details.
+      # Append a callback around actions. See _insert_callbacks for parameter details.
+      # Aliased as append_around_filter.
 
-      # set up before_filter, prepend_before_filter, skip_before_filter, etc.
+      # set up before_action, prepend_before_action, skip_before_action, etc.
       # for each of before, after, and around.
-      [:before, :after, :around].each do |filter|
+      [:before, :after, :around].each do |callback|
         class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-          # Append a before, after or around filter. See _insert_callbacks
+          # Append a before, after or around callback. See _insert_callbacks
           # for details on the allowed parameters.
-          def #{filter}_filter(*names, &blk)                                                    # def before_filter(*names, &blk)
-            _insert_callbacks(names, blk) do |name, options|                                    #   _insert_callbacks(names, blk) do |name, options|
-              set_callback(:process_action, :#{filter}, name, options)                          #     set_callback(:process_action, :before, name, options)
-            end                                                                                 #   end
-          end                                                                                   # end
+          def #{callback}_action(*names, &blk)                                                    # def before_action(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|                                      #   _insert_callbacks(names, blk) do |name, options|
+              set_callback(:process_action, :#{callback}, name, options)                          #     set_callback(:process_action, :before, name, options)
+            end                                                                                   #   end
+          end                                                                                     # end
 
-          # Prepend a before, after or around filter. See _insert_callbacks
+          alias_method :#{callback}_filter, :#{callback}_action
+
+          # Prepend a before, after or around callback. See _insert_callbacks
           # for details on the allowed parameters.
-          def prepend_#{filter}_filter(*names, &blk)                                            # def prepend_before_filter(*names, &blk)
-            _insert_callbacks(names, blk) do |name, options|                                    #   _insert_callbacks(names, blk) do |name, options|
-              set_callback(:process_action, :#{filter}, name, options.merge(:prepend => true))  #     set_callback(:process_action, :before, name, options.merge(:prepend => true))
-            end                                                                                 #   end
-          end                                                                                   # end
+          def prepend_#{callback}_action(*names, &blk)                                            # def prepend_before_action(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|                                      #   _insert_callbacks(names, blk) do |name, options|
+              set_callback(:process_action, :#{callback}, name, options.merge(:prepend => true))  #     set_callback(:process_action, :before, name, options.merge(:prepend => true))
+            end                                                                                   #   end
+          end                                                                                     # end
+
+          alias_method :prepend_#{callback}_filter, :prepend_#{callback}_action
 
-          # Skip a before, after or around filter. See _insert_callbacks
+          # Skip a before, after or around callback. See _insert_callbacks
           # for details on the allowed parameters.
-          def skip_#{filter}_filter(*names)                                                     # def skip_before_filter(*names)
-            _insert_callbacks(names) do |name, options|                                         #   _insert_callbacks(names) do |name, options|
-              skip_callback(:process_action, :#{filter}, name, options)                         #     skip_callback(:process_action, :before, name, options)
-            end                                                                                 #   end
-          end                                                                                   # end
-
-          # *_filter is the same as append_*_filter
-          alias_method :append_#{filter}_filter, :#{filter}_filter  # alias_method :append_before_filter, :before_filter
+          def skip_#{callback}_action(*names)                                                     # def skip_before_action(*names)
+            _insert_callbacks(names) do |name, options|                                           #   _insert_callbacks(names) do |name, options|
+              skip_callback(:process_action, :#{callback}, name, options)                         #     skip_callback(:process_action, :before, name, options)
+            end                                                                                   #   end
+          end                                                                                     # end
+
+          alias_method :skip_#{callback}_filter, :skip_#{callback}_action
+          
+          # *_action is the same as append_*_action
+          alias_method :append_#{callback}_action, :#{callback}_action  # alias_method :append_before_action, :before_action
+          alias_method :append_#{callback}_filter, :#{callback}_action  # alias_method :append_before_filter, :before_action
         RUBY_EVAL
       end
     end
diff --git a/actionpack/test/abstract/callbacks_test.rb b/actionpack/test/abstract/callbacks_test.rb
index 5d1a703c55..10b93d5d31 100644
--- a/actionpack/test/abstract/callbacks_test.rb
+++ b/actionpack/test/abstract/callbacks_test.rb
@@ -84,11 +84,11 @@ module AbstractController
     end
 
     class Callback3 < ControllerWithCallbacks
-      before_filter do |c|
+      before_action do |c|
         c.instance_variable_set("@text", "Hello world")
       end
 
-      after_filter do |c|
+      after_action do |c|
         c.instance_variable_set("@second", "Goodbye")
       end
 
@@ -114,8 +114,8 @@ module AbstractController
     end
 
     class CallbacksWithConditions < ControllerWithCallbacks
-      before_filter :list, :only => :index
-      before_filter :authenticate, :except => :index
+      before_action :list, :only => :index
+      before_action :authenticate, :except => :index
 
       def index
         self.response_body = @list.join(", ")
@@ -202,7 +202,7 @@ module AbstractController
     end
 
     class ChangedConditions < Callback2
-      before_filter :first, :only => :index
+      before_action :first, :only => :index
 
       def not_index
         @text ||= nil