module ActiveSupport::Callbacks::ClassMethods

existing chain rather than appended.
* :prepend - If +true+, the callback will be prepended to the
callback will be called only when it returns a +false+ value.
* :unless - A symbol naming an instance method or a proc; the
callback will be called only when it returns a +true+ value.
* :if - A symbol naming an instance method or a proc; the

===== 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_callback+.
object that responds to a certain method determined by the :scope
proc, lambda, or block; as a string to be instance evaluated; or as an
The callback can be specified as a symbol naming an instance method; as a

set_callback :save, :before_meth

means the first example above can also be written as:
+:after+, or +:around+ the event. If omitted, +:before+ is assumed. This
The second arguments 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_meth, if: :condition
set_callback :save, :before, :before_meth

Install a callback for the given event.

def set_callback(name, *filter_list, &block)
  mapped = nil
  __update_callbacks(name, filter_list, block) do |target, chain, type, filters, options|
    mapped ||= filters.map do |filter|
      Callback.new(chain, filter, type, options.dup, self)
    end
    options[:prepend] ? chain.prepend(*mapped) : chain.append(*mapped)
    target.send("_#{name}_callbacks=", chain)
  end
end