Defines callbacks types:
define_callbacks :validate
This macro accepts the following options:
:terminator - Indicates when a before filter is considered
to be halted.
define_callbacks :validate, :terminator => "result == false"
In the example above, if any before validate callbacks returns false, other callbacks are not executed. Defaults to “false”, meaning no value halts the chain.
:rescuable - By default, after filters are not executed if
the given block or a before filter raises an error. Set this option to true to change this behavior.
:scope - Indicates which methods should be executed when a class
is given as callback. Defaults to [:kind].
class Audit def before(caller) puts 'Audit: before is called' end def before_save(caller) puts 'Audit: before_save is called' end end class Account include ActiveSupport::Callbacks define_callbacks :save set_callback :save, :before, Audit.new def save run_callbacks :save do puts 'save in main' end end end
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.
# File lib/active_support/callbacks.rb, line 589 def define_callbacks(*callbacks) config = callbacks.last.is_a?(Hash) ? callbacks.pop : {} callbacks.each do |callback| extlib_inheritable_reader("_#{callback}_callbacks") do CallbackChain.new(callback, config) end __define_runner(callback) end end
Reset callbacks for a given type.
# File lib/active_support/callbacks.rb, line 514 def reset_callbacks(symbol) callbacks = send("_#{symbol}_callbacks") ActiveSupport::DescendantsTracker.descendants(self).each do |target| chain = target.send("_#{symbol}_callbacks") callbacks.each { |c| chain.delete(c) } target.__define_runner(symbol) end callbacks.clear __define_runner(symbol) end
Set callbacks for a previously defined callback.
Syntax:
set_callback :save, :before, :before_meth set_callback :save, :after, :after_meth, :if => :condition set_callback :save, :around, lambda { |r| stuff; yield; stuff }
Use skip_callback to skip any defined one.
When creating or skipping callbacks, you can specify conditions that are always the same for a given key. For instance, in Action Pack, we convert :only and :except conditions into per-key conditions.
before_filter :authenticate, :except => "index"
becomes
dispatch_callback :before, :authenticate, :per_key => {:unless => proc {|c| c.action_name == "index"}}
Per-Key conditions are evaluated only once per use of a given key. In the case of the above example, you would do:
run_callbacks(:dispatch, action_name) { ... dispatch stuff ... }
In that case, each action_name would get its own compiled callback method that took into consideration the per_key conditions. This is a speed improvement for ActionPack.
# File lib/active_support/callbacks.rb, line 478 def set_callback(name, *filter_list, &block) mapped = nil __update_callbacks(name, filter_list, block) do |chain, type, filters, options| mapped ||= filters.map do |filter| Callback.new(chain, filter, type, options.dup, self) end filters.each do |filter| chain.delete_if {|c| c.matches?(type, filter) } end options[:prepend] ? chain.unshift(*(mapped.reverse)) : chain.push(*mapped) end end
Skip a previously defined callback for a given type.
# File lib/active_support/callbacks.rb, line 496 def skip_callback(name, *filter_list, &block) __update_callbacks(name, filter_list, block) do |chain, type, filters, options| filters.each do |filter| filter = chain.find {|c| c.matches?(type, filter) } if filter && options.any? new_filter = filter.clone(chain, self) chain.insert(chain.index(filter), new_filter) new_filter.recompile!(options, options[:per_key] || {}) end chain.delete(filter) end end end
Generated with the Darkfish Rdoc Generator 2.