2004-11-23 20:04:44 -05:00
module ActiveRecord
2007-08-28 19:18:57 -04:00
# Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic
2004-12-07 07:10:57 -05:00
# before or after an alteration of the object state. This can be used to make sure that associated and
2008-09-03 12:58:47 -04:00
# dependent objects are deleted when +destroy+ is called (by overwriting +before_destroy+) or to massage attributes
2007-08-28 19:18:57 -04:00
# before they're validated (by overwriting +before_validation+). As an example of the callbacks initiated, consider
2008-10-16 16:13:06 -04:00
# the <tt>Base#save</tt> call for a new record:
2007-08-28 19:18:57 -04:00
#
# * (-) <tt>save</tt>
# * (-) <tt>valid</tt>
# * (1) <tt>before_validation</tt>
# * (-) <tt>validate</tt>
2009-09-08 11:10:14 -04:00
# * (2) <tt>after_validation</tt>
# * (3) <tt>before_save</tt>
# * (4) <tt>before_create</tt>
2007-08-28 19:18:57 -04:00
# * (-) <tt>create</tt>
2009-09-08 11:10:14 -04:00
# * (5) <tt>after_create</tt>
# * (6) <tt>after_save</tt>
2004-12-07 07:10:57 -05:00
#
2006-02-27 00:10:04 -05:00
# That's a total of eight callbacks, which gives you immense power to react and prepare for each state in the
2009-10-12 23:15:43 -04:00
# Active Record lifecycle. The sequence for calling <tt>Base#save</tt> for an existing record is similar, except that each
2008-10-16 16:13:06 -04:00
# <tt>_on_create</tt> callback is replaced by the corresponding <tt>_on_update</tt> callback.
2004-11-23 20:04:44 -05:00
#
# Examples:
# class CreditCard < ActiveRecord::Base
2004-12-07 07:10:57 -05:00
# # Strip everything but digits, so the user can specify "555 234 34" or
2004-11-23 20:04:44 -05:00
# # "5552-3434" or both will mean "55523434"
# def before_validation_on_create
# self.number = number.gsub(/[^0-9]/, "") if attribute_present?("number")
# end
# end
#
# class Subscription < ActiveRecord::Base
2005-01-01 11:14:15 -05:00
# before_create :record_signup
#
# private
# def record_signup
# self.signed_up_on = Date.today
# end
2004-11-23 20:04:44 -05:00
# end
#
# class Firm < ActiveRecord::Base
# # Destroys the associated clients and people when the firm is destroyed
2005-01-01 11:14:15 -05:00
# before_destroy { |record| Person.destroy_all "firm_id = #{record.id}" }
# before_destroy { |record| Client.destroy_all "client_of = #{record.id}" }
# end
2004-11-23 20:04:44 -05:00
#
# == Inheritable callback queues
#
2008-07-16 08:00:36 -04:00
# Besides the overwritable callback methods, it's also possible to register callbacks through the use of the callback macros.
2004-11-23 20:04:44 -05:00
# Their main advantage is that the macros add behavior into a callback queue that is kept intact down through an inheritance
# hierarchy. Example:
#
# class Topic < ActiveRecord::Base
# before_destroy :destroy_author
# end
#
# class Reply < Topic
# before_destroy :destroy_readers
# end
#
2007-08-28 19:18:57 -04:00
# Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is run, both +destroy_author+ and
# +destroy_readers+ are called. Contrast this to the situation where we've implemented the save behavior through overwriteable
2004-11-23 20:04:44 -05:00
# methods:
#
# class Topic < ActiveRecord::Base
# def before_destroy() destroy_author end
# end
#
# class Reply < Topic
# def before_destroy() destroy_readers end
# end
#
2007-08-28 19:18:57 -04:00
# In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+. So, use the callback macros when
# you want to ensure that a certain callback is called for the entire hierarchy, and use the regular overwriteable methods
2009-01-18 13:10:58 -05:00
# when you want to leave it up to each descendant to decide whether they want to call +super+ and trigger the inherited callbacks.
2004-11-23 20:04:44 -05:00
#
2005-03-19 10:36:41 -05:00
# *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the callbacks before specifying the
# associations. Otherwise, you might trigger the loading of a child before the parent has registered the callbacks and they won't
# be inherited.
#
2004-11-23 20:04:44 -05:00
# == Types of callbacks
#
2004-12-07 07:10:57 -05:00
# There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
2004-11-23 20:04:44 -05:00
# inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects are the
2005-10-26 09:05:48 -04:00
# recommended approaches, inline methods using a proc are sometimes appropriate (such as for creating mix-ins), and inline
2004-11-23 20:04:44 -05:00
# eval methods are deprecated.
#
# The method reference callbacks work by specifying a protected or private method available in the object, like this:
#
# class Topic < ActiveRecord::Base
# before_destroy :delete_parents
#
# private
# def delete_parents
# self.class.delete_all "parent_id = #{id}"
# end
# end
#
# The callback objects have methods named after the callback called with the record as the only parameter, such as:
#
# class BankAccount < ActiveRecord::Base
2009-02-24 07:29:25 -05:00
# before_save EncryptionWrapper.new
# after_save EncryptionWrapper.new
# after_initialize EncryptionWrapper.new
# end
#
# class EncryptionWrapper
# def before_save(record)
# record.credit_card_number = encrypt(record.credit_card_number)
# end
#
# def after_save(record)
# record.credit_card_number = decrypt(record.credit_card_number)
# end
#
# alias_method :after_find, :after_save
#
# private
# def encrypt(value)
# # Secrecy is committed
# end
#
# def decrypt(value)
# # Secrecy is unveiled
# end
# end
#
# So you specify the object you want messaged on a given callback. When that callback is triggered, the object has
# a method by the name of the callback messaged. You can make these callbacks more flexible by passing in other
# initialization data such as the name of the attribute to work with:
#
# class BankAccount < ActiveRecord::Base
2004-11-23 20:04:44 -05:00
# before_save EncryptionWrapper.new("credit_card_number")
# after_save EncryptionWrapper.new("credit_card_number")
# after_initialize EncryptionWrapper.new("credit_card_number")
# end
#
# class EncryptionWrapper
# def initialize(attribute)
# @attribute = attribute
# end
#
# def before_save(record)
2009-02-24 07:29:25 -05:00
# record.send("#{@attribute}=", encrypt(record.send("#{@attribute}")))
2004-11-23 20:04:44 -05:00
# end
#
# def after_save(record)
2009-02-24 07:29:25 -05:00
# record.send("#{@attribute}=", decrypt(record.send("#{@attribute}")))
2004-11-23 20:04:44 -05:00
# end
2004-12-07 07:10:57 -05:00
#
2005-03-13 10:35:49 -05:00
# alias_method :after_find, :after_save
2004-11-23 20:04:44 -05:00
#
# private
# def encrypt(value)
# # Secrecy is committed
# end
#
# def decrypt(value)
2005-02-07 09:15:53 -05:00
# # Secrecy is unveiled
2004-11-23 20:04:44 -05:00
# end
# end
#
# The callback macros usually accept a symbol for the method they're supposed to run, but you can also pass a "method string",
# which will then be evaluated within the binding of the callback. Example:
#
# class Topic < ActiveRecord::Base
# before_destroy 'self.class.delete_all "parent_id = #{id}"'
# end
#
2007-11-12 13:36:42 -05:00
# Notice that single quotes (') are used so the <tt>#{id}</tt> part isn't evaluated until the callback is triggered. Also note that these
2004-11-23 20:04:44 -05:00
# inline callbacks can be stacked just like the regular ones:
#
# class Topic < ActiveRecord::Base
2004-12-07 07:10:57 -05:00
# before_destroy 'self.class.delete_all "parent_id = #{id}"',
2004-11-23 20:04:44 -05:00
# 'puts "Evaluated after parents are destroyed"'
# end
#
2007-08-28 19:18:57 -04:00
# == The +after_find+ and +after_initialize+ exceptions
2004-11-23 20:04:44 -05:00
#
2007-08-28 19:18:57 -04:00
# Because +after_find+ and +after_initialize+ are called for each object found and instantiated by a finder, such as <tt>Base.find(:all)</tt>, we've had
# to implement a simple performance constraint (50% more speed on a simple test case). Unlike all the other callbacks, +after_find+ and
# +after_initialize+ will only be run if an explicit implementation is defined (<tt>def after_find</tt>). In that case, all of the
2005-03-13 19:04:14 -05:00
# callback types will be called.
2005-01-15 12:45:16 -05:00
#
2007-08-28 19:18:57 -04:00
# == <tt>before_validation*</tt> returning statements
2006-07-04 22:44:26 -04:00
#
2007-08-28 19:18:57 -04:00
# If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be aborted and <tt>Base#save</tt> will return +false+.
2008-09-03 12:58:47 -04:00
# If Base#save! is called it will raise a ActiveRecord::RecordInvalid exception.
2006-07-04 22:44:26 -04:00
# Nothing will be appended to the errors object.
#
2007-12-05 13:54:41 -05:00
# == Canceling callbacks
2005-01-15 12:45:16 -05:00
#
2007-08-28 19:18:57 -04:00
# If a <tt>before_*</tt> callback returns +false+, all the later callbacks and the associated action are cancelled. If an <tt>after_*</tt> callback returns
# +false+, all the later callbacks are cancelled. Callbacks are generally run in the order they are defined, with the exception of callbacks
2005-01-15 12:45:16 -05:00
# defined as methods on the model, which are called last.
2008-08-23 20:51:45 -04:00
#
# == Transactions
#
# The entire callback chain of a +save+, <tt>save!</tt>, or +destroy+ call runs
# within a transaction. That includes <tt>after_*</tt> hooks. If everything
# goes fine a COMMIT is executed once the chain has been completed.
#
# If a <tt>before_*</tt> callback cancels the action a ROLLBACK is issued. You
# can also trigger a ROLLBACK raising an exception in any of the callbacks,
# including <tt>after_*</tt> hooks. Note, however, that in that case the client
# needs to be aware of it because an ordinary +save+ will raise such exception
# instead of quietly returning +false+.
2004-11-23 20:04:44 -05:00
module Callbacks
2009-05-28 12:35:36 -04:00
extend ActiveSupport :: Concern
2009-05-11 22:23:47 -04:00
2009-09-08 11:10:14 -04:00
CALLBACKS = [
:after_initialize , :after_find , :before_validation , :after_validation ,
2009-09-08 11:22:45 -04:00
:before_save , :around_save , :after_save , :before_create , :around_create ,
:after_create , :before_update , :around_update , :after_update ,
:before_destroy , :around_destroy , :after_destroy
2009-09-08 11:10:14 -04:00
]
2004-11-23 20:04:44 -05:00
2009-05-11 22:23:47 -04:00
included do
2007-08-30 21:56:39 -04:00
[ :create_or_update , :valid? , :create , :update , :destroy ] . each do | method |
2009-05-11 22:23:47 -04:00
alias_method_chain method , :callbacks
2004-11-23 20:04:44 -05:00
end
2009-12-28 19:15:39 -05:00
extend ActiveModel :: Callbacks
2010-01-06 16:16:49 -05:00
define_callbacks :validation , :terminator = > " result == false " , :scope = > [ :kind , :name ]
2009-12-28 19:15:39 -05:00
define_model_callbacks :initialize , :find , :only = > :after
define_model_callbacks :save , :create , :update , :destroy
2004-11-23 20:04:44 -05:00
end
2009-09-08 11:10:14 -04:00
module ClassMethods
def method_added ( meth )
super
if CALLBACKS . include? ( meth . to_sym )
ActiveSupport :: Deprecation . warn ( " Base # #{ meth } has been deprecated, please use Base. #{ meth } :method instead " , caller [ 0 , 1 ] )
send ( meth . to_sym , meth . to_sym )
end
end
2010-01-06 16:16:49 -05:00
def before_validation ( * args , & block )
options = args . last
if options . is_a? ( Hash ) && options [ :on ]
options [ :if ] = Array ( options [ :if ] )
options [ :if ] << " @_on_validate == : #{ options [ :on ] } "
end
set_callback ( :validation , :before , * args , & block )
end
def after_validation ( * args , & block )
options = args . extract_options!
options [ :prepend ] = true
options [ :if ] = Array ( options [ :if ] )
options [ :if ] << " !halted && value != false "
options [ :if ] << " @_on_validate == : #{ options [ :on ] } " if options [ :on ]
set_callback ( :validation , :after , * ( args << options ) , & block )
end
2004-11-23 20:04:44 -05:00
end
2009-09-08 11:10:14 -04:00
def create_or_update_with_callbacks #:nodoc:
_run_save_callbacks do
create_or_update_without_callbacks
end
end
private :create_or_update_with_callbacks
2004-11-23 20:04:44 -05:00
2009-09-08 11:10:14 -04:00
def create_with_callbacks #:nodoc:
_run_create_callbacks do
create_without_callbacks
end
2004-11-23 20:04:44 -05:00
end
2009-09-08 11:10:14 -04:00
private :create_with_callbacks
2004-11-23 20:04:44 -05:00
2009-09-08 11:10:14 -04:00
def update_with_callbacks ( * args ) #:nodoc:
_run_update_callbacks do
update_without_callbacks ( * args )
end
end
private :update_with_callbacks
2005-07-03 05:04:52 -04:00
2009-09-08 11:10:14 -04:00
def valid_with_callbacks? #:nodoc:
@_on_validate = new_record? ? :create : :update
_run_validation_callbacks do
valid_without_callbacks?
end
end
2005-07-03 05:04:52 -04:00
2009-09-08 11:10:14 -04:00
def destroy_with_callbacks #:nodoc:
_run_destroy_callbacks do
destroy_without_callbacks
end
end
2008-06-03 14:38:00 -04:00
2009-09-08 11:10:14 -04:00
def deprecated_callback_method ( symbol ) #:nodoc:
2010-01-18 03:56:36 -05:00
if respond_to? ( symbol , true )
2009-12-30 05:43:34 -05:00
ActiveSupport :: Deprecation . warn ( " Overwriting #{ symbol } in your models has been deprecated, please use Base # #{ symbol } :method_name instead " )
2009-09-08 11:10:14 -04:00
send ( symbol )
2004-11-23 20:04:44 -05:00
end
2009-09-08 11:10:14 -04:00
end
2004-11-23 20:04:44 -05:00
end
2005-01-15 12:45:16 -05:00
end