Deprecate all *_filter callbacks in favor of *_action callbacks

This is the continuation of the work started at
9d62e04838f01f5589fa50b0baa480d60c815e2c

7 files changed, 228 insertions, 218 deletions

diff --git a/actionpack/CHANGELOG.md b/actionpack/CHANGELOG.md
index 86e98c011c..7da58ca4e7 100644
--- a/actionpack/CHANGELOG.md
+++ b/actionpack/CHANGELOG.md
@@ -1,3 +1,7 @@
+*   Deprecate all *_filter callbacks in favor of *_action callbacks.
+
+    *Rafael Mendonça França*
+
 *   Fix URL generation with `:trailing_slash` such that it does not add
     a trailing slash after `.:format`
 
diff --git a/actionpack/lib/abstract_controller/callbacks.rb b/actionpack/lib/abstract_controller/callbacks.rb
index 69aca308d6..252e297c69 100644
--- a/actionpack/lib/abstract_controller/callbacks.rb
+++ b/actionpack/lib/abstract_controller/callbacks.rb
@@ -1,3 +1,5 @@
+require 'active_support/deprecation'
+
 module AbstractController
   module Callbacks
     extend ActiveSupport::Concern
@@ -42,21 +44,23 @@ module AbstractController
         end
       end
 
-      # Skip before, after, and around action callbacks matching any of the names
-      # Aliased as skip_filter.
+      # Skip before, after, and around action callbacks matching any of the names.
       #
       # ==== 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
+      #   using #skip_action_callback
       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
+      def skip_filter(*names)
+        ActiveSupport::Deprecation.warn("#{callback}_filter is deprecated and will removed in Rails 5. Use #{callback}_action instead.")
+        skip_action_callback(*names)
+      end
 
       # Take callback names and an optional callback proc, normalize them,
       # then call the block with each callback. This allows us to abstract
@@ -85,7 +89,6 @@ module AbstractController
       # :call-seq: before_action(names, block)
       #
       # Append a callback before actions. See _insert_callbacks for parameter details.
-      # Aliased as before_filter.
 
       ##
       # :method: prepend_before_action
@@ -93,7 +96,6 @@ module AbstractController
       # :call-seq: prepend_before_action(names, block)
       #
       # Prepend a callback before actions. See _insert_callbacks for parameter details.
-      # Aliased as prepend_before_filter.
 
       ##
       # :method: skip_before_action
@@ -101,7 +103,6 @@ module AbstractController
       # :call-seq: skip_before_action(names)
       #
       # Skip a callback before actions. See _insert_callbacks for parameter details.
-      # Aliased as skip_before_filter.
 
       ##
       # :method: append_before_action
@@ -109,7 +110,6 @@ module AbstractController
       # :call-seq: append_before_action(names, block)
       #
       # Append a callback before actions. See _insert_callbacks for parameter details.
-      # Aliased as append_before_filter.
 
       ##
       # :method: after_action
@@ -117,7 +117,6 @@ module AbstractController
       # :call-seq: after_action(names, block)
       #
       # Append a callback after actions. See _insert_callbacks for parameter details.
-      # Aliased as after_filter.
 
       ##
       # :method: prepend_after_action
@@ -125,7 +124,6 @@ module AbstractController
       # :call-seq: prepend_after_action(names, block)
       #
       # Prepend a callback after actions. See _insert_callbacks for parameter details.
-      # Aliased as prepend_after_filter.
 
       ##
       # :method: skip_after_action
@@ -133,7 +131,6 @@ module AbstractController
       # :call-seq: skip_after_action(names)
       #
       # Skip a callback after actions. See _insert_callbacks for parameter details.
-      # Aliased as skip_after_filter.
 
       ##
       # :method: append_after_action
@@ -141,7 +138,6 @@ module AbstractController
       # :call-seq: append_after_action(names, block)
       #
       # Append a callback after actions. See _insert_callbacks for parameter details.
-      # Aliased as append_after_filter.
 
       ##
       # :method: around_action
@@ -149,7 +145,6 @@ module AbstractController
       # :call-seq: around_action(names, block)
       #
       # Append a callback around actions. See _insert_callbacks for parameter details.
-      # Aliased as around_filter.
 
       ##
       # :method: prepend_around_action
@@ -157,7 +152,6 @@ module AbstractController
       # :call-seq: prepend_around_action(names, block)
       #
       # Prepend a callback around actions. See _insert_callbacks for parameter details.
-      # Aliased as prepend_around_filter.
 
       ##
       # :method: skip_around_action
@@ -165,7 +159,6 @@ module AbstractController
       # :call-seq: skip_around_action(names)
       #
       # Skip a callback around actions. See _insert_callbacks for parameter details.
-      # Aliased as skip_around_filter.
 
       ##
       # :method: append_around_action
@@ -173,7 +166,6 @@ module AbstractController
       # :call-seq: append_around_action(names, block)
       #
       # Append a callback around actions. See _insert_callbacks for parameter details.
-      # Aliased as append_around_filter.
 
       # set up before_action, prepend_before_action, skip_before_action, etc.
       # for each of before, after, and around.
@@ -184,7 +176,10 @@ module AbstractController
           end
         end
 
-        alias_method :"#{callback}_filter", :"#{callback}_action"
+        define_method "#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("#{callback}_filter is deprecated and will removed in Rails 5. Use #{callback}_action instead.")
+          send("#{callback}_action", *names, &blk)
+        end
 
         define_method "prepend_#{callback}_action" do |*names, &blk|
           _insert_callbacks(names, blk) do |name, options|
@@ -192,7 +187,10 @@ module AbstractController
           end
         end
 
-        alias_method :"prepend_#{callback}_filter", :"prepend_#{callback}_action"
+        define_method "prepend_#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("prepend_#{callback}_filter is deprecated and will removed in Rails 5. Use prepend_#{callback}_action instead.")
+          send("prepend_#{callback}_action", *names, &blk)
+        end
 
         # Skip a before, after or around callback. See _insert_callbacks
         # for details on the allowed parameters.
@@ -202,11 +200,17 @@ module AbstractController
           end
         end
 
-        alias_method :"skip_#{callback}_filter", :"skip_#{callback}_action"
+        define_method "skip_#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("skip_#{callback}_filter is deprecated and will removed in Rails 5. Use skip_#{callback}_action instead.")
+          send("skip_#{callback}_action", *names, &blk)
+        end
 
         # *_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
+        define_method "append_#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("append_#{callback}_filter is deprecated and will removed in Rails 5. Use append_#{callback}_action instead.")
+          send("append_#{callback}_action", *names, &blk)
+        end
       end
     end
   end
diff --git a/actionpack/test/abstract/callbacks_test.rb b/actionpack/test/abstract/callbacks_test.rb
index 8cba049485..07571602e4 100644
--- a/actionpack/test/abstract/callbacks_test.rb
+++ b/actionpack/test/abstract/callbacks_test.rb
@@ -267,9 +267,11 @@ module AbstractController
     end
 
     class AliasedCallbacks < ControllerWithCallbacks
-      before_filter :first
-      after_filter :second
-      around_filter :aroundz
+      ActiveSupport::Deprecation.silence do
+        before_filter :first
+        after_filter :second
+        around_filter :aroundz
+      end
 
       def first
         @text = "Hello world"
diff --git a/actionpack/test/controller/filters_test.rb b/actionpack/test/controller/filters_test.rb
index c87494aa64..b2b01b3fa9 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -2,13 +2,13 @@ require 'abstract_unit'
 
 class ActionController::Base
   class << self
-    %w(append_around_filter prepend_after_filter prepend_around_filter prepend_before_filter skip_after_filter skip_before_filter skip_filter).each do |pending|
+    %w(append_around_action prepend_after_action prepend_around_action prepend_before_action skip_after_action skip_before_action skip_action_callback).each do |pending|
       define_method(pending) do |*args|
         $stderr.puts "#{pending} unimplemented: #{args.inspect}"
       end unless method_defined?(pending)
     end
 
-    def before_filters
+    def before_actions
       filters = _process_action_callbacks.select { |c| c.kind == :before }
       filters.map! { |c| c.raw_filter }
     end
@@ -28,8 +28,8 @@ end
 class FilterTest < ActionController::TestCase
 
   class TestController < ActionController::Base
-    before_filter :ensure_login
-    after_filter  :clean_up
+    before_action :ensure_login
+    after_action  :clean_up
 
     def show
       render :inline => "ran action"
@@ -42,13 +42,13 @@ class FilterTest < ActionController::TestCase
       end
 
       def clean_up
-        @ran_after_filter ||= []
-        @ran_after_filter << "clean_up"
+        @ran_after_action ||= []
+        @ran_after_action << "clean_up"
       end
   end
 
   class ChangingTheRequirementsController < TestController
-    before_filter :ensure_login, :except => [:go_wild]
+    before_action :ensure_login, :except => [:go_wild]
 
     def go_wild
       render :text => "gobble"
@@ -56,9 +56,9 @@ class FilterTest < ActionController::TestCase
   end
 
   class TestMultipleFiltersController < ActionController::Base
-    before_filter :try_1
-    before_filter :try_2
-    before_filter :try_3
+    before_action :try_1
+    before_action :try_2
+    before_action :try_3
 
     (1..3).each do |i|
       define_method "fail_#{i}" do
@@ -78,8 +78,8 @@ class FilterTest < ActionController::TestCase
   end
 
   class RenderingController < ActionController::Base
-    before_filter :before_filter_rendering
-    after_filter :unreached_after_filter
+    before_action :before_action_rendering
+    after_action :unreached_after_action
 
     def show
       @ran_action = true
@@ -87,29 +87,29 @@ class FilterTest < ActionController::TestCase
     end
 
     private
-      def before_filter_rendering
+      def before_action_rendering
         @ran_filter ||= []
-        @ran_filter << "before_filter_rendering"
+        @ran_filter << "before_action_rendering"
         render :inline => "something else"
       end
 
-      def unreached_after_filter
-        @ran_filter << "unreached_after_filter_after_render"
+      def unreached_after_action
+        @ran_filter << "unreached_after_action_after_render"
       end
   end
 
-  class RenderingForPrependAfterFilterController < RenderingController
-    prepend_after_filter :unreached_prepend_after_filter
+  class RenderingForPrependAfterActionController < RenderingController
+    prepend_after_action :unreached_prepend_after_action
 
     private
-      def unreached_prepend_after_filter
-        @ran_filter << "unreached_preprend_after_filter_after_render"
+      def unreached_prepend_after_action
+        @ran_filter << "unreached_preprend_after_action_after_render"
       end
   end
 
-  class BeforeFilterRedirectionController < ActionController::Base
-    before_filter :before_filter_redirects
-    after_filter :unreached_after_filter
+  class BeforeActionRedirectionController < ActionController::Base
+    before_action :before_action_redirects
+    after_action :unreached_after_action
 
     def show
       @ran_action = true
@@ -122,23 +122,23 @@ class FilterTest < ActionController::TestCase
     end
 
     private
-      def before_filter_redirects
+      def before_action_redirects
         @ran_filter ||= []
-        @ran_filter << "before_filter_redirects"
+        @ran_filter << "before_action_redirects"
         redirect_to(:action => 'target_of_redirection')
       end
 
-      def unreached_after_filter
-        @ran_filter << "unreached_after_filter_after_redirection"
+      def unreached_after_action
+        @ran_filter << "unreached_after_action_after_redirection"
       end
   end
 
-  class BeforeFilterRedirectionForPrependAfterFilterController < BeforeFilterRedirectionController
-    prepend_after_filter :unreached_prepend_after_filter_after_redirection
+  class BeforeActionRedirectionForPrependAfterActionController < BeforeActionRedirectionController
+    prepend_after_action :unreached_prepend_after_action_after_redirection
 
     private
-      def unreached_prepend_after_filter_after_redirection
-        @ran_filter << "unreached_prepend_after_filter_after_redirection"
+      def unreached_prepend_after_action_after_redirection
+        @ran_filter << "unreached_prepend_after_action_after_redirection"
       end
   end
 
@@ -151,8 +151,8 @@ class FilterTest < ActionController::TestCase
       render :inline => "ran action"
     end
 
-    def show_without_filter
-      render :inline => "ran action without filter"
+    def show_without_action
+      render :inline => "ran action without action"
     end
 
     private
@@ -168,70 +168,70 @@ class FilterTest < ActionController::TestCase
   end
 
   class ConditionalCollectionFilterController < ConditionalFilterController
-    before_filter :ensure_login, :except => [ :show_without_filter, :another_action ]
+    before_action :ensure_login, :except => [ :show_without_action, :another_action ]
   end
 
   class OnlyConditionSymController < ConditionalFilterController
-    before_filter :ensure_login, :only => :show
+    before_action :ensure_login, :only => :show
   end
 
   class ExceptConditionSymController < ConditionalFilterController
-    before_filter :ensure_login, :except => :show_without_filter
+    before_action :ensure_login, :except => :show_without_action
   end
 
   class BeforeAndAfterConditionController < ConditionalFilterController
-    before_filter :ensure_login, :only => :show
-    after_filter  :clean_up_tmp, :only => :show
+    before_action :ensure_login, :only => :show
+    after_action  :clean_up_tmp, :only => :show
   end
 
   class OnlyConditionProcController < ConditionalFilterController
-    before_filter(:only => :show) {|c| c.instance_variable_set(:"@ran_proc_filter", true) }
+    before_action(:only => :show) {|c| c.instance_variable_set(:"@ran_proc_action", true) }
   end
 
   class ExceptConditionProcController < ConditionalFilterController
-    before_filter(:except => :show_without_filter) {|c| c.instance_variable_set(:"@ran_proc_filter", true) }
+    before_action(:except => :show_without_action) {|c| c.instance_variable_set(:"@ran_proc_action", true) }
   end
 
   class ConditionalClassFilter
-    def self.before(controller) controller.instance_variable_set(:"@ran_class_filter", true) end
+    def self.before(controller) controller.instance_variable_set(:"@ran_class_action", true) end
   end
 
   class OnlyConditionClassController < ConditionalFilterController
-    before_filter ConditionalClassFilter, :only => :show
+    before_action ConditionalClassFilter, :only => :show
   end
 
   class ExceptConditionClassController < ConditionalFilterController
-    before_filter ConditionalClassFilter, :except => :show_without_filter
+    before_action ConditionalClassFilter, :except => :show_without_action
   end
 
   class AnomolousYetValidConditionController < ConditionalFilterController
-    before_filter(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.instance_variable_set(:"@ran_proc_filter1", true)}, :except => :show_without_filter) { |c| c.instance_variable_set(:"@ran_proc_filter2", true)}
+    before_action(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.instance_variable_set(:"@ran_proc_action1", true)}, :except => :show_without_action) { |c| c.instance_variable_set(:"@ran_proc_action2", true)}
   end
 
   class OnlyConditionalOptionsFilter < ConditionalFilterController
-    before_filter :ensure_login, :only => :index, :if => Proc.new {|c| c.instance_variable_set(:"@ran_conditional_index_proc", true) }
+    before_action :ensure_login, :only => :index, :if => Proc.new {|c| c.instance_variable_set(:"@ran_conditional_index_proc", true) }
   end
 
   class ConditionalOptionsFilter < ConditionalFilterController
-    before_filter :ensure_login, :if => Proc.new { |c| true }
-    before_filter :clean_up_tmp, :if => Proc.new { |c| false }
+    before_action :ensure_login, :if => Proc.new { |c| true }
+    before_action :clean_up_tmp, :if => Proc.new { |c| false }
   end
 
   class ConditionalOptionsSkipFilter < ConditionalFilterController
-    before_filter :ensure_login
-    before_filter :clean_up_tmp
+    before_action :ensure_login
+    before_action :clean_up_tmp
 
-    skip_before_filter :ensure_login, if: -> { false }
-    skip_before_filter :clean_up_tmp, if: -> { true }
+    skip_before_action :ensure_login, if: -> { false }
+    skip_before_action :clean_up_tmp, if: -> { true }
   end
 
   class ClassController < ConditionalFilterController
-    before_filter ConditionalClassFilter
+    before_action ConditionalClassFilter
   end
 
   class PrependingController < TestController
-    prepend_before_filter :wonderful_life
-    # skip_before_filter :fire_flash
+    prepend_before_action :wonderful_life
+    # skip_before_action :fire_flash
 
     private
       def wonderful_life
@@ -241,8 +241,8 @@ class FilterTest < ActionController::TestCase
   end
 
   class SkippingAndLimitedController < TestController
-    skip_before_filter :ensure_login
-    before_filter :ensure_login, :only => :index
+    skip_before_action :ensure_login
+    before_action :ensure_login, :only => :index
 
     def index
       render :text => 'ok'
@@ -254,9 +254,9 @@ class FilterTest < ActionController::TestCase
   end
 
   class SkippingAndReorderingController < TestController
-    skip_before_filter :ensure_login
-    before_filter :find_record
-    before_filter :ensure_login
+    skip_before_action :ensure_login
+    before_action :find_record
+    before_action :ensure_login
 
     def index
       render :text => 'ok'
@@ -270,10 +270,10 @@ class FilterTest < ActionController::TestCase
   end
 
   class ConditionalSkippingController < TestController
-    skip_before_filter :ensure_login, :only => [ :login ]
-    skip_after_filter  :clean_up,     :only => [ :login ]
+    skip_before_action :ensure_login, :only => [ :login ]
+    skip_after_action  :clean_up,     :only => [ :login ]
 
-    before_filter :find_user, :only => [ :change_password ]
+    before_action :find_user, :only => [ :change_password ]
 
     def login
       render :inline => "ran action"
@@ -291,8 +291,8 @@ class FilterTest < ActionController::TestCase
   end
 
   class ConditionalParentOfConditionalSkippingController < ConditionalFilterController
-    before_filter :conditional_in_parent_before, :only => [:show, :another_action]
-    after_filter  :conditional_in_parent_after, :only => [:show, :another_action]
+    before_action :conditional_in_parent_before, :only => [:show, :another_action]
+    after_action  :conditional_in_parent_after, :only => [:show, :another_action]
 
     private
 
@@ -308,20 +308,20 @@ class FilterTest < ActionController::TestCase
   end
 
   class ChildOfConditionalParentController < ConditionalParentOfConditionalSkippingController
-    skip_before_filter :conditional_in_parent_before, :only => :another_action
-    skip_after_filter  :conditional_in_parent_after, :only => :another_action
+    skip_before_action :conditional_in_parent_before, :only => :another_action
+    skip_after_action  :conditional_in_parent_after, :only => :another_action
   end
 
   class AnotherChildOfConditionalParentController < ConditionalParentOfConditionalSkippingController
-    skip_before_filter :conditional_in_parent_before, :only => :show
+    skip_before_action :conditional_in_parent_before, :only => :show
   end
 
   class ProcController < PrependingController
-    before_filter(proc { |c| c.instance_variable_set(:"@ran_proc_filter", true) })
+    before_action(proc { |c| c.instance_variable_set(:"@ran_proc_action", true) })
   end
 
   class ImplicitProcController < PrependingController
-    before_filter { |c| c.instance_variable_set(:"@ran_proc_filter", true) }
+    before_action { |c| c.instance_variable_set(:"@ran_proc_action", true) }
   end
 
   class AuditFilter
@@ -367,7 +367,7 @@ class FilterTest < ActionController::TestCase
   end
 
   class AuditController < ActionController::Base
-    before_filter(AuditFilter)
+    before_action(AuditFilter)
 
     def show
       render :text => "hello"
@@ -375,14 +375,14 @@ class FilterTest < ActionController::TestCase
   end
 
   class AroundFilterController < PrependingController
-    around_filter AroundFilter.new
+    around_action AroundFilter.new
   end
 
   class BeforeAfterClassFilterController < PrependingController
     begin
       filter = AroundFilter.new
-      before_filter filter
-      after_filter filter
+      before_action filter
+      after_action filter
     end
   end
 
@@ -394,18 +394,18 @@ class FilterTest < ActionController::TestCase
       super()
     end
 
-    before_filter { |c| c.class.execution_log << " before procfilter "  }
-    prepend_around_filter AroundFilter.new
+    before_action { |c| c.class.execution_log << " before procfilter "  }
+    prepend_around_action AroundFilter.new
 
-    after_filter  { |c| c.class.execution_log << " after procfilter " }
-    append_around_filter AppendedAroundFilter.new
+    after_action  { |c| c.class.execution_log << " after procfilter " }
+    append_around_action AppendedAroundFilter.new
   end
 
   class MixedSpecializationController < ActionController::Base
     class OutOfOrder < StandardError; end
 
-    before_filter :first
-    before_filter :second, :only => :foo
+    before_action :first
+    before_action :second, :only => :foo
 
     def foo
       render :text => 'foo'
@@ -426,7 +426,7 @@ class FilterTest < ActionController::TestCase
   end
 
   class DynamicDispatchController < ActionController::Base
-    before_filter :choose
+    before_action :choose
 
     %w(foo bar baz).each do |action|
       define_method(action) { render :text => action }
@@ -439,9 +439,9 @@ class FilterTest < ActionController::TestCase
   end
 
   class PrependingBeforeAndAfterController < ActionController::Base
-    prepend_before_filter :before_all
-    prepend_after_filter :after_all
-    before_filter :between_before_all_and_after_all
+    prepend_before_action :before_all
+    prepend_after_action :after_all
+    before_action :between_before_all_and_after_all
 
     def before_all
       @ran_filter ||= []
@@ -473,7 +473,7 @@ class FilterTest < ActionController::TestCase
   end
 
   class RescuedController < ActionController::Base
-    around_filter RescuingAroundFilterWithBlock.new
+    around_action RescuingAroundFilterWithBlock.new
 
     def show
       raise ErrorToRescue.new("Something made the bad noise.")
@@ -482,10 +482,10 @@ class FilterTest < ActionController::TestCase
 
   class NonYieldingAroundFilterController < ActionController::Base
 
-    before_filter :filter_one
-    around_filter :non_yielding_filter
-    before_filter :filter_two
-    after_filter :filter_three
+    before_action :filter_one
+    around_action :non_yielding_action
+    before_action :action_two
+    after_action :action_three
 
     def index
       render :inline => "index"
@@ -498,24 +498,24 @@ class FilterTest < ActionController::TestCase
         @filters  << "filter_one"
       end
 
-      def filter_two
-        @filters  << "filter_two"
+      def action_two
+        @filters  << "action_two"
       end
 
-      def non_yielding_filter
+      def non_yielding_action
         @filters  << "it didn't yield"
         @filter_return_value
       end
 
-      def filter_three
-        @filters  << "filter_three"
+      def action_three
+        @filters  << "action_three"
       end
 
   end
 
   class ImplicitActionsController < ActionController::Base
-    before_filter :find_only, :only => :edit
-    before_filter :find_except, :except => :edit
+    before_action :find_only, :only => :edit
+    before_action :find_except, :except => :edit
 
     private
 
@@ -528,7 +528,7 @@ class FilterTest < ActionController::TestCase
     end
   end
 
-  def test_non_yielding_around_filters_not_returning_false_do_not_raise
+  def test_non_yielding_around_actions_not_returning_false_do_not_raise
     controller = NonYieldingAroundFilterController.new
     controller.instance_variable_set "@filter_return_value", true
     assert_nothing_raised do
@@ -536,7 +536,7 @@ class FilterTest < ActionController::TestCase
     end
   end
 
-  def test_non_yielding_around_filters_returning_false_do_not_raise
+  def test_non_yielding_around_actions_returning_false_do_not_raise
     controller = NonYieldingAroundFilterController.new
     controller.instance_variable_set "@filter_return_value", false
     assert_nothing_raised do
@@ -544,64 +544,64 @@ class FilterTest < ActionController::TestCase
     end
   end
 
-  def test_after_filters_are_not_run_if_around_filter_returns_false
+  def test_after_actions_are_not_run_if_around_action_returns_false
     controller = NonYieldingAroundFilterController.new
     controller.instance_variable_set "@filter_return_value", false
     test_process(controller, "index")
     assert_equal ["filter_one", "it didn't yield"], controller.assigns['filters']
   end
 
-  def test_after_filters_are_not_run_if_around_filter_does_not_yield
+  def test_after_actions_are_not_run_if_around_action_does_not_yield
     controller = NonYieldingAroundFilterController.new
     controller.instance_variable_set "@filter_return_value", true
     test_process(controller, "index")
     assert_equal ["filter_one", "it didn't yield"], controller.assigns['filters']
   end
 
-  def test_added_filter_to_inheritance_graph
-    assert_equal [ :ensure_login ], TestController.before_filters
+  def test_added_action_to_inheritance_graph
+    assert_equal [ :ensure_login ], TestController.before_actions
   end
 
   def test_base_class_in_isolation
-    assert_equal [ ], ActionController::Base.before_filters
+    assert_equal [ ], ActionController::Base.before_actions
   end
 
-  def test_prepending_filter
-    assert_equal [ :wonderful_life, :ensure_login ], PrependingController.before_filters
+  def test_prepending_action
+    assert_equal [ :wonderful_life, :ensure_login ], PrependingController.before_actions
   end
 
-  def test_running_filters
+  def test_running_actions
     test_process(PrependingController)
     assert_equal %w( wonderful_life ensure_login ), assigns["ran_filter"]
   end
 
-  def test_running_filters_with_proc
+  def test_running_actions_with_proc
     test_process(ProcController)
-    assert assigns["ran_proc_filter"]
+    assert assigns["ran_proc_action"]
   end
 
-  def test_running_filters_with_implicit_proc
+  def test_running_actions_with_implicit_proc
     test_process(ImplicitProcController)
-    assert assigns["ran_proc_filter"]
+    assert assigns["ran_proc_action"]
   end
 
-  def test_running_filters_with_class
+  def test_running_actions_with_class
     test_process(AuditController)
     assert assigns["was_audited"]
   end
 
-  def test_running_anomolous_yet_valid_condition_filters
+  def test_running_anomolous_yet_valid_condition_actions
     test_process(AnomolousYetValidConditionController)
     assert_equal %w( ensure_login ), assigns["ran_filter"]
-    assert assigns["ran_class_filter"]
-    assert assigns["ran_proc_filter1"]
-    assert assigns["ran_proc_filter2"]
+    assert assigns["ran_class_action"]
+    assert assigns["ran_proc_action1"]
+    assert assigns["ran_proc_action2"]
 
-    test_process(AnomolousYetValidConditionController, "show_without_filter")
+    test_process(AnomolousYetValidConditionController, "show_without_action")
     assert_nil assigns["ran_filter"]
-    assert !assigns["ran_class_filter"]
-    assert !assigns["ran_proc_filter1"]
-    assert !assigns["ran_proc_filter2"]
+    assert !assigns["ran_class_action"]
+    assert !assigns["ran_proc_action1"]
+    assert !assigns["ran_proc_action2"]
   end
 
   def test_running_conditional_options
@@ -614,59 +614,59 @@ class FilterTest < ActionController::TestCase
     assert_equal %w( ensure_login ), assigns["ran_filter"]
   end
 
-  def test_skipping_class_filters
+  def test_skipping_class_actions
     test_process(ClassController)
-    assert_equal true, assigns["ran_class_filter"]
+    assert_equal true, assigns["ran_class_action"]
 
     skipping_class_controller = Class.new(ClassController) do
-      skip_before_filter ConditionalClassFilter
+      skip_before_action ConditionalClassFilter
     end
 
     test_process(skipping_class_controller)
-    assert_nil assigns['ran_class_filter']
+    assert_nil assigns['ran_class_action']
   end
 
-  def test_running_collection_condition_filters
+  def test_running_collection_condition_actions
     test_process(ConditionalCollectionFilterController)
     assert_equal %w( ensure_login ), assigns["ran_filter"]
-    test_process(ConditionalCollectionFilterController, "show_without_filter")
+    test_process(ConditionalCollectionFilterController, "show_without_action")
     assert_nil assigns["ran_filter"]
     test_process(ConditionalCollectionFilterController, "another_action")
     assert_nil assigns["ran_filter"]
   end
 
-  def test_running_only_condition_filters
+  def test_running_only_condition_actions
     test_process(OnlyConditionSymController)
     assert_equal %w( ensure_login ), assigns["ran_filter"]
-    test_process(OnlyConditionSymController, "show_without_filter")
+    test_process(OnlyConditionSymController, "show_without_action")
     assert_nil assigns["ran_filter"]
 
     test_process(OnlyConditionProcController)
-    assert assigns["ran_proc_filter"]
-    test_process(OnlyConditionProcController, "show_without_filter")
-    assert !assigns["ran_proc_filter"]
+    assert assigns["ran_proc_action"]
+    test_process(OnlyConditionProcController, "show_without_action")
+    assert !assigns["ran_proc_action"]
 
     test_process(OnlyConditionClassController)
-    assert assigns["ran_class_filter"]
-    test_process(OnlyConditionClassController, "show_without_filter")
-    assert !assigns["ran_class_filter"]
+    assert assigns["ran_class_action"]
+    test_process(OnlyConditionClassController, "show_without_action")
+    assert !assigns["ran_class_action"]
   end
 
-  def test_running_except_condition_filters
+  def test_running_except_condition_actions
     test_process(ExceptConditionSymController)
     assert_equal %w( ensure_login ), assigns["ran_filter"]
-    test_process(ExceptConditionSymController, "show_without_filter")
+    test_process(ExceptConditionSymController, "show_without_action")
     assert_nil assigns["ran_filter"]
 
     test_process(ExceptConditionProcController)
-    assert assigns["ran_proc_filter"]
-    test_process(ExceptConditionProcController, "show_without_filter")
-    assert !assigns["ran_proc_filter"]
+    assert assigns["ran_proc_action"]
+    test_process(ExceptConditionProcController, "show_without_action")
+    assert !assigns["ran_proc_action"]
 
     test_process(ExceptConditionClassController)
-    assert assigns["ran_class_filter"]
-    test_process(ExceptConditionClassController, "show_without_filter")
-    assert !assigns["ran_class_filter"]
+    assert assigns["ran_class_action"]
+    test_process(ExceptConditionClassController, "show_without_action")
+    assert !assigns["ran_class_action"]
   end
 
   def test_running_only_condition_and_conditional_options
@@ -674,70 +674,70 @@ class FilterTest < ActionController::TestCase
     assert_not assigns["ran_conditional_index_proc"]
   end
 
-  def test_running_before_and_after_condition_filters
+  def test_running_before_and_after_condition_actions
     test_process(BeforeAndAfterConditionController)
     assert_equal %w( ensure_login clean_up_tmp), assigns["ran_filter"]
-    test_process(BeforeAndAfterConditionController, "show_without_filter")
+    test_process(BeforeAndAfterConditionController, "show_without_action")
     assert_nil assigns["ran_filter"]
   end
 
-  def test_around_filter
+  def test_around_action
     test_process(AroundFilterController)
     assert assigns["before_ran"]
     assert assigns["after_ran"]
   end
 
-  def test_before_after_class_filter
+  def test_before_after_class_action
     test_process(BeforeAfterClassFilterController)
     assert assigns["before_ran"]
     assert assigns["after_ran"]
   end
 
-  def test_having_properties_in_around_filter
+  def test_having_properties_in_around_action
     test_process(AroundFilterController)
     assert_equal "before and after", assigns["execution_log"]
   end
 
-  def test_prepending_and_appending_around_filter
+  def test_prepending_and_appending_around_action
     test_process(MixedFilterController)
     assert_equal " before aroundfilter  before procfilter  before appended aroundfilter " +
                  " after appended aroundfilter  after procfilter  after aroundfilter ",
                  MixedFilterController.execution_log
   end
 
-  def test_rendering_breaks_filtering_chain
+  def test_rendering_breaks_actioning_chain
     response = test_process(RenderingController)
     assert_equal "something else", response.body
     assert !assigns["ran_action"]
   end
 
-  def test_before_filter_rendering_breaks_filtering_chain_for_after_filter
+  def test_before_action_rendering_breaks_actioning_chain_for_after_action
     test_process(RenderingController)
-    assert_equal %w( before_filter_rendering ), assigns["ran_filter"]
+    assert_equal %w( before_action_rendering ), assigns["ran_filter"]
     assert !assigns["ran_action"]
   end
 
-  def test_before_filter_redirects_breaks_filtering_chain_for_after_filter
-    test_process(BeforeFilterRedirectionController)
+  def test_before_action_redirects_breaks_actioning_chain_for_after_action
+    test_process(BeforeActionRedirectionController)
     assert_response :redirect
-    assert_equal "http://test.host/filter_test/before_filter_redirection/target_of_redirection", redirect_to_url
-    assert_equal %w( before_filter_redirects ), assigns["ran_filter"]
+    assert_equal "http://test.host/filter_test/before_action_redirection/target_of_redirection", redirect_to_url
+    assert_equal %w( before_action_redirects ), assigns["ran_filter"]
   end
 
-  def test_before_filter_rendering_breaks_filtering_chain_for_preprend_after_filter
-    test_process(RenderingForPrependAfterFilterController)
-    assert_equal %w( before_filter_rendering ), assigns["ran_filter"]
+  def test_before_action_rendering_breaks_actioning_chain_for_preprend_after_action
+    test_process(RenderingForPrependAfterActionController)
+    assert_equal %w( before_action_rendering ), assigns["ran_filter"]
     assert !assigns["ran_action"]
   end
 
-  def test_before_filter_redirects_breaks_filtering_chain_for_preprend_after_filter
-    test_process(BeforeFilterRedirectionForPrependAfterFilterController)
+  def test_before_action_redirects_breaks_actioning_chain_for_preprend_after_action
+    test_process(BeforeActionRedirectionForPrependAfterActionController)
     assert_response :redirect
-    assert_equal "http://test.host/filter_test/before_filter_redirection_for_prepend_after_filter/target_of_redirection", redirect_to_url
-    assert_equal %w( before_filter_redirects ), assigns["ran_filter"]
+    assert_equal "http://test.host/filter_test/before_action_redirection_for_prepend_after_action/target_of_redirection", redirect_to_url
+    assert_equal %w( before_action_redirects ), assigns["ran_filter"]
   end
 
-  def test_filters_with_mixed_specialization_run_in_order
+  def test_actions_with_mixed_specialization_run_in_order
     assert_nothing_raised do
       response = test_process(MixedSpecializationController, 'bar')
       assert_equal 'bar', response.body
@@ -758,7 +758,7 @@ class FilterTest < ActionController::TestCase
     end
   end
 
-  def test_running_prepended_before_and_after_filter
+  def test_running_prepended_before_and_after_action
     test_process(PrependingBeforeAndAfterController)
     assert_equal %w( before_all between_before_all_and_after_all after_all ), assigns["ran_filter"]
   end
@@ -775,26 +775,26 @@ class FilterTest < ActionController::TestCase
     assert_equal %w( find_record ensure_login ), assigns["ran_filter"]
   end
 
-  def test_conditional_skipping_of_filters
+  def test_conditional_skipping_of_actions
     test_process(ConditionalSkippingController, "login")
     assert_nil assigns["ran_filter"]
     test_process(ConditionalSkippingController, "change_password")
     assert_equal %w( ensure_login find_user ), assigns["ran_filter"]
 
     test_process(ConditionalSkippingController, "login")
-    assert !@controller.instance_variable_defined?("@ran_after_filter")
+    assert !@controller.instance_variable_defined?("@ran_after_action")
     test_process(ConditionalSkippingController, "change_password")
-    assert_equal %w( clean_up ), @controller.instance_variable_get("@ran_after_filter")
+    assert_equal %w( clean_up ), @controller.instance_variable_get("@ran_after_action")
   end
 
-  def test_conditional_skipping_of_filters_when_parent_filter_is_also_conditional
+  def test_conditional_skipping_of_actions_when_parent_action_is_also_conditional
     test_process(ChildOfConditionalParentController)
     assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), assigns['ran_filter']
     test_process(ChildOfConditionalParentController, 'another_action')
     assert_nil assigns['ran_filter']
   end
 
-  def test_condition_skipping_of_filters_when_siblings_also_have_conditions
+  def test_condition_skipping_of_actions_when_siblings_also_have_conditions
     test_process(ChildOfConditionalParentController)
     assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), assigns['ran_filter']
     test_process(AnotherChildOfConditionalParentController)
@@ -808,7 +808,7 @@ class FilterTest < ActionController::TestCase
     assert_nil assigns['ran_filter']
   end
 
-  def test_a_rescuing_around_filter
+  def test_a_rescuing_around_action
     response = nil
     assert_nothing_raised do
       response = test_process(RescuedController)
@@ -818,7 +818,7 @@ class FilterTest < ActionController::TestCase
     assert_equal("I rescued this: #<FilterTest::ErrorToRescue: Something made the bad noise.>", response.body)
   end
 
-  def test_filters_obey_only_and_except_for_implicit_actions
+  def test_actions_obey_only_and_except_for_implicit_actions
     test_process(ImplicitActionsController, 'show')
     assert_equal 'Except', assigns(:except)
     assert_nil assigns(:only)
@@ -852,7 +852,7 @@ class PostsController < ActionController::Base
     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")
+  module_eval %w(raises_before raises_after raises_both no_raise no_action).map { |action| "def #{action}; default_action end" }.join("\n")
 
   private
     def default_action
@@ -861,9 +861,9 @@ class PostsController < ActionController::Base
 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
+  around_action :raise_before, :only => :raises_before
+  around_action :raise_after, :only => :raises_after
+  around_action :without_exception, :only => :no_raise
 
   private
     def raise_before
@@ -895,7 +895,7 @@ class ControllerWithFilterClass < PostsController
     end
   end
 
-  around_filter YieldingFilter, :only => :raises_after
+  around_action YieldingFilter, :only => :raises_after
 end
 
 class ControllerWithFilterInstance < PostsController
@@ -906,11 +906,11 @@ class ControllerWithFilterInstance < PostsController
     end
   end
 
-  around_filter YieldingFilter.new, :only => :raises_after
+  around_action YieldingFilter.new, :only => :raises_after
 end
 
 class ControllerWithProcFilter < PostsController
-  around_filter(:only => :no_raise) do |c,b|
+  around_action(:only => :no_raise) do |c,b|
     c.instance_variable_set(:"@before", true)
     b.call
     c.instance_variable_set(:"@after", true)
@@ -918,14 +918,14 @@ class ControllerWithProcFilter < PostsController
 end
 
 class ControllerWithNestedFilters < ControllerWithSymbolAsFilter
-  around_filter :raise_before, :raise_after, :without_exception, :only => :raises_both
+  around_action :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
+  before_action :before
+  around_action :around
+  after_action :after
+  around_action :around_again
 
   private
   def before
@@ -951,8 +951,8 @@ class ControllerWithAllTypesOfFilters < PostsController
 end
 
 class ControllerWithTwoLessFilters < ControllerWithAllTypesOfFilters
-  skip_filter :around_again
-  skip_filter :after
+  skip_action_callback :around_again
+  skip_action_callback :after
 end
 
 class YieldingAroundFiltersTest < ActionController::TestCase
@@ -963,7 +963,7 @@ class YieldingAroundFiltersTest < ActionController::TestCase
     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') }
+    assert_nothing_raised { test_process(controller,'no_action') }
   end
 
   def test_with_symbol
@@ -992,7 +992,7 @@ class YieldingAroundFiltersTest < ActionController::TestCase
     assert assigns['after']
   end
 
-  def test_nested_filters
+  def test_nested_actions
     controller = ControllerWithNestedFilters
     assert_nothing_raised do
       begin
@@ -1008,31 +1008,31 @@ class YieldingAroundFiltersTest < ActionController::TestCase
     end
   end
 
-  def test_filter_order_with_all_filter_types
+  def test_action_order_with_all_action_types
     test_process(ControllerWithAllTypesOfFilters,'no_raise')
     assert_equal 'before around (before yield) around_again (before yield) around_again (after yield) after around (after yield)', assigns['ran_filter'].join(' ')
   end
 
-  def test_filter_order_with_skip_filter_method
+  def test_action_order_with_skip_action_method
     test_process(ControllerWithTwoLessFilters,'no_raise')
     assert_equal 'before around (before yield) around (after yield)', assigns['ran_filter'].join(' ')
   end
 
-  def test_first_filter_in_multiple_before_filter_chain_halts
+  def test_first_action_in_multiple_before_action_chain_halts
     controller = ::FilterTest::TestMultipleFiltersController.new
     response = test_process(controller, 'fail_1')
     assert_equal ' ', response.body
     assert_equal 1, controller.instance_variable_get(:@try)
   end
 
-  def test_second_filter_in_multiple_before_filter_chain_halts
+  def test_second_action_in_multiple_before_action_chain_halts
     controller = ::FilterTest::TestMultipleFiltersController.new
     response = test_process(controller, 'fail_2')
     assert_equal ' ', response.body
     assert_equal 2, controller.instance_variable_get(:@try)
   end
 
-  def test_last_filter_in_multiple_before_filter_chain_halts
+  def test_last_action_in_multiple_before_action_chain_halts
     controller = ::FilterTest::TestMultipleFiltersController.new
     response = test_process(controller, 'fail_3')
     assert_equal ' ', response.body
diff --git a/actionpack/test/controller/test_case_test.rb b/actionpack/test/controller/test_case_test.rb
index 18a5d8b094..1141feeff7 100644
--- a/actionpack/test/controller/test_case_test.rb
+++ b/actionpack/test/controller/test_case_test.rb
@@ -164,7 +164,7 @@ XML
   end
 
   class DefaultUrlOptionsCachingController < ActionController::Base
-    before_filter { @dynamic_opt = 'opt' }
+    before_action { @dynamic_opt = 'opt' }
 
     def test_url_options_reset
       render text: url_for(params)
diff --git a/railties/lib/rails/info_controller.rb b/railties/lib/rails/info_controller.rb
index 908c4ce65e..49e5431a16 100644
--- a/railties/lib/rails/info_controller.rb
+++ b/railties/lib/rails/info_controller.rb
@@ -5,7 +5,7 @@ class Rails::InfoController < Rails::ApplicationController # :nodoc:
   prepend_view_path ActionDispatch::DebugExceptions::RESCUES_TEMPLATE_PATH
   layout -> { request.xhr? ? false : 'application' }
 
-  before_filter :require_local!
+  before_action :require_local!
 
   def index
     redirect_to action: :routes
diff --git a/railties/lib/rails/mailers_controller.rb b/railties/lib/rails/mailers_controller.rb
index dd318f52e5..32740d66da 100644
--- a/railties/lib/rails/mailers_controller.rb
+++ b/railties/lib/rails/mailers_controller.rb
@@ -3,8 +3,8 @@ require 'rails/application_controller'
 class Rails::MailersController < Rails::ApplicationController # :nodoc:
   prepend_view_path ActionDispatch::DebugExceptions::RESCUES_TEMPLATE_PATH
 
-  before_filter :require_local!
-  before_filter :find_preview, only: :preview
+  before_action :require_local!
+  before_action :find_preview, only: :preview
 
   def index
     @previews = ActionMailer::Preview.all
@@ -70,4 +70,4 @@ class Rails::MailersController < Rails::ApplicationController # :nodoc:
         @email
       end
     end
-end
\ No newline at end of file
+end