module ActiveSupport::Callbacks::ClassMethods

existing chain rather than appended.
* :prepend - If +true+, the callback will be prepended to the
an argument.
current object. It can also optionally accept the current object as
If a proc is given, its body is evaluated in the context of the

all return a false value.
instance method or a proc; the callback will be called only when they
* :unless - A symbol or an array of symbols, each naming an
an argument.
current object. It can also optionally accept the current object as
If a proc is given, its body is evaluated in the context of the

a true value.
method or a proc; the callback will be called only when they all return
* :if - A symbol or an array of symbols, each naming an instance

===== 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

determined by the :scope argument to +define_callbacks+.
proc, lambda, or block; or as an object that responds to a certain method
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