callbacks.rb in actionpack-5.0.0.beta1

- old
+ new

@@ -7,11 +7,11 @@
     # for ActiveSupport::Callbacks.
     include ActiveSupport::Callbacks
 
     included do
       define_callbacks :process_action,
-                       terminator: ->(controller,_) { controller.response_body },
+                       terminator: ->(controller, result_lambda) { result_lambda.call if result_lambda.is_a?(Proc); controller.response_body },
                        skip_after_callbacks_if_terminated: true
     end
 
     # Override AbstractController::Base's process_action to run the
     # process_action callbacks around the normal behavior.
@@ -20,56 +20,73 @@
         super
       end
     end
 
     module ClassMethods
-      # If :only or :except are used, convert the options into the
-      # :unless and :if options of ActiveSupport::Callbacks.
-      # The basic idea is that :only => :index gets converted to
-      # :if => proc {|c| c.action_name == "index" }.
+      # If +:only+ or +:except+ are used, convert the options into the
+      # +:if+ and +:unless+ options of ActiveSupport::Callbacks.
       #
+      # The basic idea is that <tt>:only => :index</tt> gets converted to
+      # <tt>:if => proc {|c| c.action_name == "index" }</tt>.
+      #
+      # Note that <tt>:only</tt> has priority over <tt>:if</tt> in case they
+      # are used together.
+      #
+      #   only: :index, if: -> { true } # the :if option will be ignored.
+      #
+      # Note that <tt>:if</tt> has priority over <tt>:except</tt> in case they
+      # are used together.
+      #
+      #   except: :index, if: -> { true } # the :except option will be ignored.
+      #
       # ==== Options
-      # * <tt>only</tt>   - The callback should be run only for this action
-      # * <tt>except</tt>  - The callback should be run for all actions except this action
+      # * <tt>only</tt>   - The callback should be run only for this action.
+      # * <tt>except</tt>  - The callback should be run for all actions except this action.
       def _normalize_callback_options(options)
         _normalize_callback_option(options, :only, :if)
         _normalize_callback_option(options, :except, :unless)
       end
 
       def _normalize_callback_option(options, from, to) # :nodoc:
         if from = options[from]
-          from = Array(from).map {|o| "action_name == '#{o}'"}.join(" || ")
+          _from = Array(from).map(&:to_s).to_set
+          from = proc {|c| _from.include? c.action_name }
           options[to] = Array(options[to]).unshift(from)
         end
       end
 
       # 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_action_callback
+      #   using #skip_action_callback.
       def skip_action_callback(*names)
-        skip_before_action(*names)
-        skip_after_action(*names)
-        skip_around_action(*names)
+        ActiveSupport::Deprecation.warn('`skip_action_callback` is deprecated and will be removed in Rails 5.1. Please use skip_before_action, skip_after_action or skip_around_action instead.')
+        skip_before_action(*names, raise: false)
+        skip_after_action(*names, raise: false)
+        skip_around_action(*names, raise: false)
       end
-      alias_method :skip_filter, :skip_action_callback
 
+      def skip_filter(*names)
+        ActiveSupport::Deprecation.warn("`skip_filter` is deprecated and will be removed in Rails 5.1. Use skip_before_action, skip_after_action or skip_around_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
       # the normalization across several methods that use it.
       #
       # ==== Parameters
       # * <tt>callbacks</tt> - An array of callbacks, with an optional
       #   options hash as the last parameter.
       # * <tt>block</tt>    - A proc that should be added to the callbacks.
       #
       # ==== Block Parameters
-      # * <tt>name</tt>     - The callback to be added
-      # * <tt>options</tt>  - A hash of options to be used when adding the callback
+      # * <tt>name</tt>     - The callback to be added.
+      # * <tt>options</tt>  - A hash of options to be used when adding the callback.
       def _insert_callbacks(callbacks, block = nil)
         options = callbacks.extract_options!
         _normalize_callback_options(options)
         callbacks.push(block) if block
         callbacks.each do |callback|
@@ -167,30 +184,46 @@
         define_method "#{callback}_action" do |*names, &blk|
           _insert_callbacks(names, blk) do |name, options|
             set_callback(:process_action, callback, name, options)
           end
         end
-        alias_method :"#{callback}_filter", :"#{callback}_action"
 
+        define_method "#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("#{callback}_filter is deprecated and will be removed in Rails 5.1. 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|
             set_callback(:process_action, callback, name, options.merge(:prepend => true))
           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 be removed in Rails 5.1. 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.
         define_method "skip_#{callback}_action" do |*names|
           _insert_callbacks(names) do |name, options|
             skip_callback(:process_action, callback, name, options)
           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 be removed in Rails 5.1. 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_#{callback}_filter", :"#{callback}_action"
+
+        define_method "append_#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("append_#{callback}_filter is deprecated and will be removed in Rails 5.1. Use append_#{callback}_action instead.")
+          send("append_#{callback}_action", *names, &blk)
+        end
       end
     end
   end
 end