Deprecate all *_filter callbacks in favor of *_action callbacks

This is the continuation of the work started at
9d62e04838f01f5589fa50b0baa480d60c815e2c

1 files changed, 190 insertions, 190 deletions

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