Use NewCallbacks on ActionDispatch::Callbacks.

5 files changed, 53 insertions, 35 deletions

diff --git a/actionpack/lib/abstract_controller/logger.rb b/actionpack/lib/abstract_controller/logger.rb
index 79444761d3..f4d017b8e5 100644
--- a/actionpack/lib/abstract_controller/logger.rb
+++ b/actionpack/lib/abstract_controller/logger.rb
@@ -47,7 +47,8 @@ module AbstractController
     # Override process_action in the AbstractController::Base
     # to log details about the method.
     def process_action(action)
-      event = ActiveSupport::Orchestra.instrument(:process_action, :action => action) do
+      event = ActiveSupport::Orchestra.instrument(:process_action,
+                :controller => self, :action => action) do
         super
       end
 
diff --git a/actionpack/lib/action_controller/dispatch/dispatcher.rb b/actionpack/lib/action_controller/dispatch/dispatcher.rb
index 9ad1cadfd3..ba316b9e63 100644
--- a/actionpack/lib/action_controller/dispatch/dispatcher.rb
+++ b/actionpack/lib/action_controller/dispatch/dispatcher.rb
@@ -54,7 +54,7 @@ module ActionController
         end
       end
 
-      delegate :to_prepare, :prepare_dispatch, :before_dispatch, :after_dispatch,
+      delegate :to_prepare, :before_dispatch, :around_dispatch, :after_dispatch,
         :to => ActionDispatch::Callbacks
 
       def new
diff --git a/actionpack/lib/action_dispatch/middleware/callbacks.rb b/actionpack/lib/action_dispatch/middleware/callbacks.rb
index 0a2b4cf5f7..2f86a382c2 100644
--- a/actionpack/lib/action_dispatch/middleware/callbacks.rb
+++ b/actionpack/lib/action_dispatch/middleware/callbacks.rb
@@ -1,40 +1,55 @@
 module ActionDispatch
   class Callbacks
-    include ActiveSupport::Callbacks
-    define_callbacks :prepare, :before, :after
+    include ActiveSupport::NewCallbacks
+
+    define_callbacks :call, :terminator => "result == false", :scope => :kind
+    define_callbacks :prepare, :scope => :name
+
+    # Add a preparation callback. Preparation callbacks are run before every
+    # request in development mode, and before the first request in production mode.
+    #
+    # If a symbol with a block is given, the symbol is used as an identifier.
+    # That allows to_prepare to be called again with the same identifier to
+    # replace the existing callback. Passing an identifier is a suggested
+    # practice if the code adding a preparation block may be reloaded.
+    def self.to_prepare(*args, &block)
+      if args.first.is_a?(Symbol) && block_given?
+        define_method :"__#{args.first}", &block
+        set_callback(:prepare, :"__#{args.first}")
+      else
+        set_callback(:prepare, *args, &block)
+      end
+    end
+
+    def self.before(*args, &block)
+      set_callback(:call, :before, *args, &block)
+    end
+
+    def self.around(*args, &block)
+      set_callback(:call, :around, *args, &block)
+    end
+
+    def self.after(*args, &block)
+      set_callback(:call, :after, *args, &block)
+    end
 
     class << self
       # DEPRECATED
-      alias_method :prepare_dispatch, :prepare
       alias_method :before_dispatch, :before
+      alias_method :around_dispatch, :around
       alias_method :after_dispatch, :after
     end
 
-    # Add a preparation callback. Preparation callbacks are run before every
-    # request in development mode, and before the first request in production
-    # mode.
-    #
-    # An optional identifier may be supplied for the callback. If provided,
-    # to_prepare may be called again with the same identifier to replace the
-    # existing callback. Passing an identifier is a suggested practice if the
-    # code adding a preparation block may be reloaded.
-    def self.to_prepare(identifier = nil, &block)
-      @prepare_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new
-      callback = ActiveSupport::Callbacks::Callback.new(:prepare, block, :identifier => identifier)
-      @prepare_callbacks.replace_or_append!(callback)
-    end
-
     def initialize(app, prepare_each_request = false)
       @app, @prepare_each_request = app, prepare_each_request
-      run_callbacks :prepare
+      _run_prepare_callbacks
     end
 
     def call(env)
-      run_callbacks :before
-      run_callbacks :prepare if @prepare_each_request
-      @app.call(env)
-    ensure
-      run_callbacks :after, :enumerator => :reverse_each
+      _run_call_callbacks do
+        _run_prepare_callbacks if @prepare_each_request
+        @app.call(env)
+      end
     end
   end
 end
diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb
index 9fae1fcf63..150fc83cde 100644
--- a/actionpack/test/controller/dispatcher_test.rb
+++ b/actionpack/test/controller/dispatcher_test.rb
@@ -3,13 +3,16 @@ require 'abstract_unit'
 class DispatcherTest < Test::Unit::TestCase
   Dispatcher = ActionController::Dispatcher
 
+  class Foo
+    cattr_accessor :a, :b
+  end
+
   def setup
     ENV['REQUEST_METHOD'] = 'GET'
 
     # Clear callbacks as they are redefined by Dispatcher#define_dispatcher_callbacks
-    ActionDispatch::Callbacks.instance_variable_set("@prepare_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
-    ActionDispatch::Callbacks.instance_variable_set("@before_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
-    ActionDispatch::Callbacks.instance_variable_set("@after_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    ActionDispatch::Callbacks.reset_callbacks(:prepare)
+    ActionDispatch::Callbacks.reset_callbacks(:call)
 
     @old_router, Dispatcher.router = Dispatcher.router, mock()
     Dispatcher.router.stubs(:call).returns([200, {}, 'response'])
@@ -68,13 +71,12 @@ class DispatcherTest < Test::Unit::TestCase
   end
 
   def test_to_prepare_with_identifier_replaces
-    a = b = nil
-    Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
-    Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
+    Dispatcher.to_prepare(:unique_id) { |*args| Foo.a, Foo.b = 1, 1 }
+    Dispatcher.to_prepare(:unique_id) { |*args| Foo.a = 2 }
 
     dispatch
-    assert_equal 2, a
-    assert_equal nil, b
+    assert_equal 2, Foo.a
+    assert_equal nil, Foo.b
   end
 
   private
diff --git a/activesupport/lib/active_support/new_callbacks.rb b/activesupport/lib/active_support/new_callbacks.rb
index e78a3b2b6f..c56b9ad1ac 100644
--- a/activesupport/lib/active_support/new_callbacks.rb
+++ b/activesupport/lib/active_support/new_callbacks.rb
@@ -295,7 +295,7 @@ module ActiveSupport
           "(#{filter})"
         when Proc
           @klass.send(:define_method, method_name, &filter)
-          return method_name if filter.arity == 0
+          return method_name if filter.arity <= 0
 
           method_name << (filter.arity == 1 ? "(self)" : " self, Proc.new ")
         else
@@ -374,7 +374,7 @@ module ActiveSupport
       #   save
       # end
       #
-      # The _run_set_callback :save,s method can optionally take a key, which
+      # The _run_set_callback :save method can optionally take a key, which
       # will be used to compile an optimized callback method for each
       # key. See #define_callbacks for more information.
       #