vendor/rails/activerecord/lib/active_record/callbacks.rb

   1 require 'observer'
   2
   3 module ActiveRecord
   4   # Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic
   5   # before or after an alteration of the object state. This can be used to make sure that associated and
   6   # dependent objects are deleted when +destroy+ is called (by overwriting +before_destroy+) or to massage attributes
   7   # before they're validated (by overwriting +before_validation+). As an example of the callbacks initiated, consider
   8   # the <tt>Base#save</tt> call for a new record:
   9   #
  10   # * (-) <tt>save</tt>
  11   # * (-) <tt>valid</tt>
  12   # * (1) <tt>before_validation</tt>
  13   # * (2) <tt>before_validation_on_create</tt>
  14   # * (-) <tt>validate</tt>
  15   # * (-) <tt>validate_on_create</tt>
  16   # * (3) <tt>after_validation</tt>
  17   # * (4) <tt>after_validation_on_create</tt>
  18   # * (5) <tt>before_save</tt>
  19   # * (6) <tt>before_create</tt>
  20   # * (-) <tt>create</tt>
  21   # * (7) <tt>after_create</tt>
  22   # * (8) <tt>after_save</tt>
  23   #
  24   # That's a total of eight callbacks, which gives you immense power to react and prepare for each state in the
  25   # Active Record lifecycle. The sequence for calling <tt>Base#save</tt> an existing record is similar, except that each
  26   # <tt>_on_create</tt> callback is replaced by the corresponding <tt>_on_update</tt> callback.
  27   #
  28   # Examples:
  29   #   class CreditCard < ActiveRecord::Base
  30   #     # Strip everything but digits, so the user can specify "555 234 34" or
  31   #     # "5552-3434" or both will mean "55523434"
  32   #     def before_validation_on_create
  33   #       self.number = number.gsub(/[^0-9]/, "") if attribute_present?("number")
  34   #     end
  35   #   end
  36   #
  37   #   class Subscription < ActiveRecord::Base
  38   #     before_create :record_signup
  39   #
  40   #     private
  41   #       def record_signup
  42   #         self.signed_up_on = Date.today
  43   #       end
  44   #   end
  45   #
  46   #   class Firm < ActiveRecord::Base
  47   #     # Destroys the associated clients and people when the firm is destroyed
  48   #     before_destroy { |record| Person.destroy_all "firm_id = #{record.id}"   }
  49   #     before_destroy { |record| Client.destroy_all "client_of = #{record.id}" }
  50   #   end
  51   #
  52   # == Inheritable callback queues
  53   #
  54   # Besides the overwritable callback methods, it's also possible to register callbacks through the use of the callback macros.
  55   # Their main advantage is that the macros add behavior into a callback queue that is kept intact down through an inheritance
  56   # hierarchy. Example:
  57   #
  58   #   class Topic < ActiveRecord::Base
  59   #     before_destroy :destroy_author
  60   #   end
  61   #
  62   #   class Reply < Topic
  63   #     before_destroy :destroy_readers
  64   #   end
  65   #
  66   # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is run, both +destroy_author+ and
  67   # +destroy_readers+ are called. Contrast this to the situation where we've implemented the save behavior through overwriteable
  68   # methods:
  69   #
  70   #   class Topic < ActiveRecord::Base
  71   #     def before_destroy() destroy_author end
  72   #   end
  73   #
  74   #   class Reply < Topic
  75   #     def before_destroy() destroy_readers end
  76   #   end
  77   #
  78   # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+. So, use the callback macros when
  79   # you want to ensure that a certain callback is called for the entire hierarchy, and use the regular overwriteable methods
  80   # when you want to leave it up to each descendant to decide whether they want to call +super+ and trigger the inherited callbacks.
  81   #
  82   # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the callbacks before specifying the
  83   # associations. Otherwise, you might trigger the loading of a child before the parent has registered the callbacks and they won't
  84   # be inherited.
  85   #
  86   # == Types of callbacks
  87   #
  88   # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
  89   # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects are the
  90   # recommended approaches, inline methods using a proc are sometimes appropriate (such as for creating mix-ins), and inline
  91   # eval methods are deprecated.
  92   #
  93   # The method reference callbacks work by specifying a protected or private method available in the object, like this:
  94   #
  95   #   class Topic < ActiveRecord::Base
  96   #     before_destroy :delete_parents
  97   #
  98   #     private
  99   #       def delete_parents
 100   #         self.class.delete_all "parent_id = #{id}"
 101   #       end
 102   #   end
 103   #
 104   # The callback objects have methods named after the callback called with the record as the only parameter, such as:
 105   #
 106   #   class BankAccount < ActiveRecord::Base
 107   #     before_save      EncryptionWrapper.new
 108   #     after_save       EncryptionWrapper.new
 109   #     after_initialize EncryptionWrapper.new
 110   #   end
 111   #
 112   #   class EncryptionWrapper
 113   #     def before_save(record)
 114   #       record.credit_card_number = encrypt(record.credit_card_number)
 115   #     end
 116   #
 117   #     def after_save(record)
 118   #       record.credit_card_number = decrypt(record.credit_card_number)
 119   #     end
 120   #
 121   #     alias_method :after_find, :after_save
 122   #
 123   #     private
 124   #       def encrypt(value)
 125   #         # Secrecy is committed
 126   #       end
 127   #
 128   #       def decrypt(value)
 129   #         # Secrecy is unveiled
 130   #       end
 131   #   end
 132   #
 133   # So you specify the object you want messaged on a given callback. When that callback is triggered, the object has
 134   # a method by the name of the callback messaged. You can make these callbacks more flexible by passing in other
 135   # initialization data such as the name of the attribute to work with:
 136   #
 137   #   class BankAccount < ActiveRecord::Base
 138   #     before_save      EncryptionWrapper.new("credit_card_number")
 139   #     after_save       EncryptionWrapper.new("credit_card_number")
 140   #     after_initialize EncryptionWrapper.new("credit_card_number")
 141   #   end
 142   #
 143   #   class EncryptionWrapper
 144   #     def initialize(attribute)
 145   #       @attribute = attribute
 146   #     end
 147   #
 148   #     def before_save(record)
 149   #       record.send("#{@attribute}=", encrypt(record.send("#{@attribute}")))
 150   #     end
 151   #
 152   #     def after_save(record)
 153   #       record.send("#{@attribute}=", decrypt(record.send("#{@attribute}")))
 154   #     end
 155   #
 156   #     alias_method :after_find, :after_save
 157   #
 158   #     private
 159   #       def encrypt(value)
 160   #         # Secrecy is committed
 161   #       end
 162   #
 163   #       def decrypt(value)
 164   #         # Secrecy is unveiled
 165   #       end
 166   #   end
 167   #
 168   # The callback macros usually accept a symbol for the method they're supposed to run, but you can also pass a "method string",
 169   # which will then be evaluated within the binding of the callback. Example:
 170   #
 171   #   class Topic < ActiveRecord::Base
 172   #     before_destroy 'self.class.delete_all "parent_id = #{id}"'
 173   #   end
 174   #
 175   # Notice that single quotes (') are used so the <tt>#{id}</tt> part isn't evaluated until the callback is triggered. Also note that these
 176   # inline callbacks can be stacked just like the regular ones:
 177   #
 178   #   class Topic < ActiveRecord::Base
 179   #     before_destroy 'self.class.delete_all "parent_id = #{id}"',
 180   #                    'puts "Evaluated after parents are destroyed"'
 181   #   end
 182   #
 183   # == The +after_find+ and +after_initialize+ exceptions
 184   #
 185   # 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
 186   # to implement a simple performance constraint (50% more speed on a simple test case). Unlike all the other callbacks, +after_find+ and
 187   # +after_initialize+ will only be run if an explicit implementation is defined (<tt>def after_find</tt>). In that case, all of the
 188   # callback types will be called.
 189   #
 190   # == <tt>before_validation*</tt> returning statements
 191   #
 192   # 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+.
 193   # If Base#save! is called it will raise a ActiveRecord::RecordInvalid exception.
 194   # Nothing will be appended to the errors object.
 195   #
 196   # == Canceling callbacks
 197   #
 198   # 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
 199   # +false+, all the later callbacks are cancelled. Callbacks are generally run in the order they are defined, with the exception of callbacks
 200   # defined as methods on the model, which are called last.
 201   #
 202   # == Transactions
 203   #
 204   # The entire callback chain of a +save+, <tt>save!</tt>, or +destroy+ call runs
 205   # within a transaction. That includes <tt>after_*</tt> hooks. If everything
 206   # goes fine a COMMIT is executed once the chain has been completed.
 207   #
 208   # If a <tt>before_*</tt> callback cancels the action a ROLLBACK is issued. You
 209   # can also trigger a ROLLBACK raising an exception in any of the callbacks,
 210   # including <tt>after_*</tt> hooks. Note, however, that in that case the client
 211   # needs to be aware of it because an ordinary +save+ will raise such exception
 212   # instead of quietly returning +false+.
 213   module Callbacks
 214     CALLBACKS = %w(
 215       after_find after_initialize before_save after_save before_create after_create before_update after_update before_validation
 216       after_validation before_validation_on_create after_validation_on_create before_validation_on_update
 217       after_validation_on_update before_destroy after_destroy
 218     )
 219
 220     def self.included(base) #:nodoc:
 221       base.extend Observable
 222
 223       [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
 224         base.send :alias_method_chain, method, :callbacks
 225       end
 226
 227       base.send :include, ActiveSupport::Callbacks
 228       base.define_callbacks *CALLBACKS
 229     end
 230
 231     # Is called when the object was instantiated by one of the finders, like <tt>Base.find</tt>.
 232     #def after_find() end
 233
 234     # Is called after the object has been instantiated by a call to <tt>Base.new</tt>.
 235     #def after_initialize() end
 236
 237     # Is called _before_ <tt>Base.save</tt> (regardless of whether it's a +create+ or +update+ save).
 238     def before_save() end
 239
 240     # Is called _after_ <tt>Base.save</tt> (regardless of whether it's a +create+ or +update+ save).
 241     # Note that this callback is still wrapped in the transaction around +save+. For example, if you
 242     # invoke an external indexer at this point it won't see the changes in the database.
 243     #
 244     #  class Contact < ActiveRecord::Base
 245     #    after_save { logger.info( 'New contact saved!' ) }
 246     #  end
 247     def after_save()  end
 248     def create_or_update_with_callbacks #:nodoc:
 249       return false if callback(:before_save) == false
 250       if result = create_or_update_without_callbacks
 251         callback(:after_save)
 252       end
 253       result
 254     end
 255     private :create_or_update_with_callbacks
 256
 257     # Is called _before_ <tt>Base.save</tt> on new objects that haven't been saved yet (no record exists).
 258     def before_create() end
 259
 260     # Is called _after_ <tt>Base.save</tt> on new objects that haven't been saved yet (no record exists).
 261     # Note that this callback is still wrapped in the transaction around +save+. For example, if you
 262     # invoke an external indexer at this point it won't see the changes in the database.
 263     def after_create() end
 264     def create_with_callbacks #:nodoc:
 265       return false if callback(:before_create) == false
 266       result = create_without_callbacks
 267       callback(:after_create)
 268       result
 269     end
 270     private :create_with_callbacks
 271
 272     # Is called _before_ <tt>Base.save</tt> on existing objects that have a record.
 273     def before_update() end
 274
 275     # Is called _after_ <tt>Base.save</tt> on existing objects that have a record.
 276     # Note that this callback is still wrapped in the transaction around +save+. For example, if you
 277     # invoke an external indexer at this point it won't see the changes in the database.
 278     def after_update() end
 279
 280     def update_with_callbacks(*args) #:nodoc:
 281       return false if callback(:before_update) == false
 282       result = update_without_callbacks(*args)
 283       callback(:after_update)
 284       result
 285     end
 286     private :update_with_callbacks
 287
 288     # Is called _before_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call).
 289     def before_validation() end
 290
 291     # Is called _after_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call).
 292     def after_validation() end
 293
 294     # Is called _before_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on new objects
 295     # that haven't been saved yet (no record exists).
 296     def before_validation_on_create() end
 297
 298     # Is called _after_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on new objects
 299     # that haven't been saved yet (no record exists).
 300     def after_validation_on_create()  end
 301
 302     # Is called _before_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on
 303     # existing objects that have a record.
 304     def before_validation_on_update() end
 305
 306     # Is called _after_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on
 307     # existing objects that have a record.
 308     def after_validation_on_update()  end
 309
 310     def valid_with_callbacks? #:nodoc:
 311       return false if callback(:before_validation) == false
 312       if new_record? then result = callback(:before_validation_on_create) else result = callback(:before_validation_on_update) end
 313       return false if false == result
 314
 315       result = valid_without_callbacks?
 316
 317       callback(:after_validation)
 318       if new_record? then callback(:after_validation_on_create) else callback(:after_validation_on_update) end
 319
 320       return result
 321     end
 322
 323     # Is called _before_ <tt>Base.destroy</tt>.
 324     #
 325     # Note: If you need to _destroy_ or _nullify_ associated records first,
 326     # use the <tt>:dependent</tt> option on your associations.
 327     def before_destroy() end
 328
 329     # Is called _after_ <tt>Base.destroy</tt> (and all the attributes have been frozen).
 330     #
 331     #  class Contact < ActiveRecord::Base
 332     #    after_destroy { |record| logger.info( "Contact #{record.id} was destroyed." ) }
 333     #  end
 334     def after_destroy()  end
 335     def destroy_with_callbacks #:nodoc:
 336       return false if callback(:before_destroy) == false
 337       result = destroy_without_callbacks
 338       callback(:after_destroy)
 339       result
 340     end
 341
 342     private
 343       def callback(method)
 344         result = run_callbacks(method) { |result, object| false == result }
 345
 346         if result != false && respond_to_without_attributes?(method)
 347           result = send(method)
 348         end
 349
 350         notify(method)
 351
 352         return result
 353       end
 354
 355       def notify(method) #:nodoc:
 356         self.class.changed
 357         self.class.notify_observers(method, self)
 358       end
 359   end
 360 end