module ActiveSupport::Callbacks::ClassMethods

existing chain rather than appended.
* :prepend - If +true+, the callback will be prepended to the
be called only when they all return a false value.
strings, each naming an instance method or a proc; the callback will
* :unless - A symbol, a string or an array of symbols and
only when they all return a true value.
each naming an instance method or a proc; the callback will be called
* :if - A symbol, a string or an array of symbols and strings,

===== Options

wasn't halted, from the +yield+ call.
Around callbacks can access the return value from the event, if it

after callbacks are called in the reverse order.
Before and around callbacks are called in the order that they are set;

an argument.
of the current object. It can also optionally accept the current object as
If a proc, lambda, or block is given, its body is evaluated in the context

argument to +define_callbacks+.
object that responds to a certain method determined by the :scope
proc, lambda, or block; as a string to be instance evaluated(deprecated); or as an
The callback can be specified as a symbol naming an instance method; as a

set_callback :save, :before_method

means the first example above can also be written as:
+:after+, or +:around+ the event. If omitted, +:before+ is assumed. This
The second argument indicates whether the callback is to be run +:before+,

set_callback :save, :around, ->(r, block) { stuff; result = block.call; stuff }
set_callback :save, :after, :after_method, if: :condition
set_callback :save, :before, :before_method

Install a callback for the given event.

def set_callback(name, *filter_list, &block)
  type, filters, options = normalize_callback_params(filter_list, block)
  self_chain = get_callbacks name
  mapped = filters.map do |filter|
    Callback.build(self_chain, filter, type, options)
  end
  __update_callbacks(name) do |target, chain|
    options[:prepend] ? chain.prepend(*mapped) : chain.append(*mapped)
    target.set_callbacks name, chain
  end
end