Class Index [+]

Quicksearch

ActiveSupport::Callbacks::ClassMethods

Public Instance Methods

define_callbacks(*callbacks) click to toggle source

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
589:       def define_callbacks(*callbacks)
590:         config = callbacks.last.is_a?(Hash) ? callbacks.pop : {}
591:         callbacks.each do |callback|
592:           extlib_inheritable_reader("_#{callback}_callbacks") do
593:             CallbackChain.new(callback, config)
594:           end
595:           __define_runner(callback)
596:         end
597:       end
reset_callbacks(symbol) click to toggle source

Reset callbacks for a given type.

     # File lib/active_support/callbacks.rb, line 514
514:       def reset_callbacks(symbol)
515:         callbacks = send("_#{symbol}_callbacks")
516: 
517:         ActiveSupport::DescendantsTracker.descendants(self).each do |target|
518:           chain = target.send("_#{symbol}_callbacks")
519:           callbacks.each { |c| chain.delete(c) }
520:           target.__define_runner(symbol)
521:         end
522: 
523:         callbacks.clear
524:         __define_runner(symbol)
525:       end
set_callback(name, *filter_list, &block) click to toggle source

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
478:       def set_callback(name, *filter_list, &block)
479:         mapped = nil
480: 
481:         __update_callbacks(name, filter_list, block) do |chain, type, filters, options|
482:           mapped ||= filters.map do |filter|
483:             Callback.new(chain, filter, type, options.dup, self)
484:           end
485: 
486:           filters.each do |filter|
487:             chain.delete_if {|c| c.matches?(type, filter) }
488:           end
489: 
490:           options[:prepend] ? chain.unshift(*mapped) : chain.push(*mapped)
491:         end
492:       end
skip_callback(name, *filter_list, &block) click to toggle source

Skip a previously defined callback for a given type.

     # File lib/active_support/callbacks.rb, line 496
496:       def skip_callback(name, *filter_list, &block)
497:         __update_callbacks(name, filter_list, block) do |chain, type, filters, options|
498:           filters.each do |filter|
499:             filter = chain.find {|c| c.matches?(type, filter) }
500: 
501:             if filter && options.any?
502:               new_filter = filter.clone(chain, self)
503:               chain.insert(chain.index(filter), new_filter)
504:               new_filter.recompile!(options, options[:per_key] || {})
505:             end
506: 
507:             chain.delete(filter)
508:           end
509:         end
510:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.