Options

:terminator - Determines when a before filter will halt the
callback chain, preventing following before and around callbacks from being
called and the event from being triggered. This should be a lambda to be
executed. The current object and the result lambda of the callback will be
provided to the terminator lambda.

In this example, if any before validate callbacks returns
false, any successive before and around callback is not
executed.

The default terminator halts the chain when a callback throws
:abort.

:skip_after_callbacks_if_terminated - Determines if after
callbacks should be terminated by the :terminator option. By
default after callbacks are executed no matter if callback chain was
terminated or not. This option makes sense only when
:terminator option is specified.

:scope - Indicates which methods should be executed when an
object is used as a callback.

In the above case whenever you save an account the method
Audit#before will be called. On the other hand

define_callbacks :save, scope: [:kind, :name]

would trigger Audit#before_save instead. That's
constructed by calling #{kind}_#{name} on the given instance.
In this case “kind” is “before” and “name” is “save”. In this context
:kind and :name have special meanings:
:kind refers to the kind of callback (before/after/around) and
:name refers to the method on which callbacks are being
defined.

A declaration like

define_callbacks :save, scope: [:name]

would call Audit#save.

Notes

names passed to define_callbacks must not end
with !, ? or =.

Calling define_callbacks multiple times with the same
names will overwrite previous callbacks registered with
set_callback.

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

set_callback :save, :before_method

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

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

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

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

Options

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

:unless - A symbol, a string (deprecated) or an array of
symbols, each naming an instance method or a proc; the callback will be
called only when they all return a false value.

:prepend - If true, the callback will be
prepended to the existing chain rather than appended.