activerecord 1.0.0 → 4.0.0

data/lib/active_record/callbacks.rb

@@ -1,57 +1,65 @@
-require 'observer'
-
 module ActiveRecord
-  # Callbacks are hooks into the lifecycle of an Active Record object that allows you to trigger logic
-  # before or after an alteration of the object state. This can be used to make sure that associated and 
-  # dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes
-  # before they're validated (by overwriting before_validation). As an example of the callbacks initiated, consider
-  # the Base#save call:
-  #
-  # * (-) save
-  # * (-) valid?
-  # * (1) before_validation
-  # * (2) before_validation_on_create
-  # * (-) validate
-  # * (-) validate_on_create
-  # * (4) after_validation
-  # * (5) after_validation_on_create 
-  # * (6) before_save
-  # * (7) before_create
-  # * (-) create
-  # * (8) after_create
-  # * (9) after_save
-  # 
-  # That's a total of nine callbacks, which gives you immense power to react and prepare for each state in the
-  # Active Record lifecyle.
+  # = Active Record Callbacks
+  #
+  # Callbacks are hooks into the life cycle of an Active Record object that allow you to trigger logic
+  # before or after an alteration of the object state. This can be used to make sure that associated and
+  # dependent objects are deleted when +destroy+ is called (by overwriting +before_destroy+) or to massage attributes
+  # before they're validated (by overwriting +before_validation+). As an example of the callbacks initiated, consider
+  # the <tt>Base#save</tt> call for a new record:
+  #
+  # * (-) <tt>save</tt>
+  # * (-) <tt>valid</tt>
+  # * (1) <tt>before_validation</tt>
+  # * (-) <tt>validate</tt>
+  # * (2) <tt>after_validation</tt>
+  # * (3) <tt>before_save</tt>
+  # * (4) <tt>before_create</tt>
+  # * (-) <tt>create</tt>
+  # * (5) <tt>after_create</tt>
+  # * (6) <tt>after_save</tt>
+  # * (7) <tt>after_commit</tt>
+  #
+  # Also, an <tt>after_rollback</tt> callback can be configured to be triggered whenever a rollback is issued.
+  # Check out <tt>ActiveRecord::Transactions</tt> for more details about <tt>after_commit</tt> and
+  # <tt>after_rollback</tt>.
+  #
+  # Lastly an <tt>after_find</tt> and <tt>after_initialize</tt> callback is triggered for each object that
+  # is found and instantiated by a finder, with <tt>after_initialize</tt> being triggered after new objects
+  # are instantiated as well.
+  #
+  # That's a total of twelve callbacks, which gives you immense power to react and prepare for each state in the
+  # Active Record life cycle. The sequence for calling <tt>Base#save</tt> for an existing record is similar,
+  # except that each <tt>_create</tt> callback is replaced by the corresponding <tt>_update</tt> callback.
   #
   # Examples:
   #   class CreditCard < ActiveRecord::Base
-  #     # Strip everything but digits, so the user can specify "555 234 34" or 
-  #     # "5552-3434" or both will mean "55523434"
-  #     def before_validation_on_create
+  #     # Strip everything but digits, so the user can specify "555 234 34" or
+  #     # "5552-3434" and both will mean "55523434"
+  #     before_validation(on: :create) do
   #       self.number = number.gsub(/[^0-9]/, "") if attribute_present?("number")
   #     end
   #   end
   #
   #   class Subscription < ActiveRecord::Base
-  #     # Automatically assign the signup date
-  #     def before_create
-  #       self.signed_up_on = Date.today
-  #     end
+  #     before_create :record_signup
+  #
+  #     private
+  #       def record_signup
+  #         self.signed_up_on = Date.today
+  #       end
   #   end
   #
   #   class Firm < ActiveRecord::Base
   #     # Destroys the associated clients and people when the firm is destroyed
-  #     def before_destroy
-  #       Client.destroy_all "client_of = #{id}"
-  #       Person.destroy_all "firm_id = #{id}"
-  #     end
+  #     before_destroy { |record| Person.destroy_all "firm_id = #{record.id}"   }
+  #     before_destroy { |record| Client.destroy_all "client_of = #{record.id}" }
+  #   end
   #
   # == Inheritable callback queues
   #
-  # Besides the overwriteable callback methods, it's also possible to register callbacks through the use of the callback macros.
-  # Their main advantage is that the macros add behavior into a callback queue that is kept intact down through an inheritance
-  # hierarchy. Example:
+  # Besides the overwritable callback methods, it's also possible to register callbacks through the
+  # use of the callback macros. Their main advantage is that the macros add behavior into a callback
+  # queue that is kept intact down through an inheritance hierarchy.
   #
   #   class Topic < ActiveRecord::Base
   #     before_destroy :destroy_author
@@ -61,9 +69,9 @@ module ActiveRecord
   #     before_destroy :destroy_readers
   #   end
   #
-  # Now, when Topic#destroy is run only +destroy_author+ is called. When Reply#destroy is run both +destroy_author+ and
-  # +destroy_readers+ is called. Contrast this to the situation where we've implemented the save behavior through overwriteable
-  # methods:
+  # 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 following situation
+  # where the +before_destroy+ method is overridden:
   #
   #   class Topic < ActiveRecord::Base
   #     def before_destroy() destroy_author end
@@ -73,16 +81,21 @@ module ActiveRecord
   #     def before_destroy() destroy_readers end
   #   end
   #
-  # In that case, Reply#destroy 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 the regular overwriteable methods when you
-  # want to leave it up to each descendent to decide whether they want to call +super+ and trigger the inherited callbacks.
+  # 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 overwritable methods when you want to leave it up to each descendant
+  # to decide whether they want to call +super+ and trigger the inherited callbacks.
+  #
+  # *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.
   #
   # == Types of callbacks
   #
-  # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects, 
-  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects are the
-  # recommended approaches, inline methods using a proc is some times appropriate (such as for creating mix-ins), and inline
-  # eval methods are deprecated.
+  # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
+  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects
+  # are the recommended approaches, inline methods using a proc are sometimes appropriate (such as for
+  # creating mix-ins), and inline eval methods are deprecated.
   #
   # The method reference callbacks work by specifying a protected or private method available in the object, like this:
   #
@@ -98,6 +111,37 @@ module ActiveRecord
   # The callback objects have methods named after the callback called with the record as the only parameter, such as:
   #
   #   class BankAccount < ActiveRecord::Base
+  #     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
   #     before_save      EncryptionWrapper.new("credit_card_number")
   #     after_save       EncryptionWrapper.new("credit_card_number")
   #     after_initialize EncryptionWrapper.new("credit_card_number")
@@ -109,14 +153,14 @@ module ActiveRecord
   #     end
   #
   #     def before_save(record)
-  #       record.credit_card_number = encrypt(record.credit_card_number)
+  #       record.send("#{@attribute}=", encrypt(record.send("#{@attribute}")))
   #     end
   #
   #     def after_save(record)
-  #       record.credit_card_number = decrypt(record.credit_card_number)
+  #       record.send("#{@attribute}=", decrypt(record.send("#{@attribute}")))
   #     end
-  #     
-  #     alias_method :after_initialize, :after_save
+  #
+  #     alias_method :after_find, :after_save
   #
   #     private
   #       def encrypt(value)
@@ -124,214 +168,143 @@ module ActiveRecord
   #       end
   #
   #       def decrypt(value)
-  #         # Secrecy is unvieled
+  #         # 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.
-  #
-  # 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:
+  # 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
   #
-  # Notice that single plings (') are used so the #{id} part isn't evaluated until the callback is triggered. Also note that these
-  # inline callbacks can be stacked just like the regular ones:
+  # Notice that single quotes (') are used so the <tt>#{id}</tt> part isn't evaluated until the callback
+  # is triggered. Also note that these inline callbacks can be stacked just like the regular ones:
   #
   #   class Topic < ActiveRecord::Base
-  #     before_destroy 'self.class.delete_all "parent_id = #{id}"', 
+  #     before_destroy 'self.class.delete_all "parent_id = #{id}"',
   #                    'puts "Evaluated after parents are destroyed"'
   #   end
   #
-  # == The after_find and after_initialize exceptions
+  # == <tt>before_validation*</tt> returning statements
+  #
+  # 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+. If Base#save! is called it will raise a
+  # ActiveRecord::RecordInvalid exception. Nothing will be appended to the errors object.
+  #
+  # == Canceling callbacks
+  #
+  # 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 defined as
+  # methods on the model, which are called last.
+  #
+  # == Ordering callbacks
+  #
+  # Sometimes the code needs that the callbacks execute in a specific order. For example, a +before_destroy+
+  # callback (+log_children+ in this case) should be executed before the children get destroyed by the +dependent: destroy+ option.
+  #
+  # Let's look at the code below:
+  #
+  #   class Topic < ActiveRecord::Base
+  #     has_many :children, dependent: destroy
+  #
+  #     before_destroy :log_children
+  #
+  #     private
+  #       def log_children
+  #         # Child processing
+  #       end
+  #   end
+  #
+  # In this case, the problem is that when the +before_destroy+ callback is executed, the children are not available
+  # because the +destroy+ callback gets executed first. You can use the +prepend+ option on the +before_destroy+ callback to avoid this.
+  #
+  #   class Topic < ActiveRecord::Base
+  #     has_many :children, dependent: destroy
+  #
+  #     before_destroy :log_children, prepend: true
+  #
+  #     private
+  #       def log_children
+  #         # Child processing
+  #       end
+  #   end
+  #
+  # This way, the +before_destroy+ gets executed before the <tt>dependent: destroy</tt> is called, and the data is still available.
+  #
+  # == 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+.
+  #
+  # == Debugging callbacks
+  #
+  # The callback chain is accessible via the <tt>_*_callbacks</tt> method on an object. ActiveModel Callbacks support
+  # <tt>:before</tt>, <tt>:after</tt> and <tt>:around</tt> as values for the <tt>kind</tt> property. The <tt>kind</tt> property
+  # defines what part of the chain the callback runs in.
+  #
+  # To find all callbacks in the before_save callback chain:
+  #
+  #   Topic._save_callbacks.select { |cb| cb.kind.eql?(:before) }
+  #
+  # Returns an array of callback objects that form the before_save chain.
+  #
+  # To further check if the before_save chain contains a proc defined as <tt>rest_when_dead</tt> use the <tt>filter</tt> property of the callback object:
+  #
+  #   Topic._save_callbacks.select { |cb| cb.kind.eql?(:before) }.collect(&:filter).include?(:rest_when_dead)
+  #
+  # Returns true or false depending on whether the proc is contained in the before_save callback chain on a Topic model.
   #
-  # Because after_find and after_initialize is called for each object instantiated found by a finder, such as Base.find_all, 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 can only be declared using an explicit implementation. So using the inheritable callback queue for after_find and
-  # after_initialize won't work.
   module Callbacks
-    CALLBACKS = %w( 
-      after_find after_initialize before_save after_save before_create after_create before_update after_update before_validation 
-      after_validation before_validation_on_create after_validation_on_create before_validation_on_update
-      after_validation_on_update before_destroy after_destroy
-    )
-
-    def self.append_features(base) #:nodoc:
-      super
-
-      base.extend(ClassMethods)
-      base.class_eval do
-        class << self
-          include Observable
-          alias_method :instantiate_without_callbacks, :instantiate
-          alias_method :instantiate, :instantiate_with_callbacks
-        end
-      end
+    extend ActiveSupport::Concern
 
-      base.class_eval do
-        alias_method :initialize_without_callbacks, :initialize
-        alias_method :initialize, :initialize_with_callbacks
+    CALLBACKS = [
+      :after_initialize, :after_find, :after_touch, :before_validation, :after_validation,
+      :before_save, :around_save, :after_save, :before_create, :around_create,
+      :after_create, :before_update, :around_update, :after_update,
+      :before_destroy, :around_destroy, :after_destroy, :after_commit, :after_rollback
+    ]
 
-        alias_method :create_or_update_without_callbacks, :create_or_update
-        alias_method :create_or_update, :create_or_update_with_callbacks
-
-        alias_method :valid_without_callbacks, :valid?
-        alias_method :valid?, :valid_with_callbacks
-
-        alias_method :create_without_callbacks, :create
-        alias_method :create, :create_with_callbacks
-
-        alias_method :update_without_callbacks, :update
-        alias_method :update, :update_with_callbacks
-
-        alias_method :destroy_without_callbacks, :destroy
-        alias_method :destroy, :destroy_with_callbacks
-      end
-
-      CALLBACKS.each { |cb| base.class_eval("def self.#{cb}(*methods) write_inheritable_array(\"#{cb}\", methods) end") }
-    end
-
-    module ClassMethods #:nodoc:
-      def instantiate_with_callbacks(record)
-        object = instantiate_without_callbacks(record)
-        object.callback(:after_find) if object.respond_to_without_attributes?(:after_find)
-        object.callback(:after_initialize) if object.respond_to_without_attributes?(:after_initialize)
-        object
-      end
+    module ClassMethods
+      include ActiveModel::Callbacks
     end
 
-    # Is called when the object was instantiated by one of the finders, like Base.find.
-    # def after_find() end
+    included do
+      include ActiveModel::Validations::Callbacks
 
-    # Is called after the object has been instantiated by a call to Base.new.
-    # def after_initialize() end
-    def initialize_with_callbacks(attributes = nil) #:nodoc:
-      initialize_without_callbacks(attributes)
-      yield self if block_given?
-      after_initialize if respond_to_without_attributes?(:after_initialize)
+      define_model_callbacks :initialize, :find, :touch, :only => :after
+      define_model_callbacks :save, :create, :update, :destroy
     end
-    
-    # Is called _before_ Base.save (regardless of whether it's a create or update save).
-    def before_save() end
 
-    # Is called _after_ Base.save (regardless of whether it's a create or update save).
-    def after_save()  end
-    def create_or_update_with_callbacks #:nodoc:
-      callback(:before_save)
-      create_or_update_without_callbacks
-      callback(:after_save)
+    def destroy #:nodoc:
+      run_callbacks(:destroy) { super }
     end
 
-    # Is called _before_ Base.save on new objects that haven't been saved yet (no record exists).
-    def before_create() end
-
-    # Is called _after_ Base.save on new objects that haven't been saved yet (no record exists).
-    def after_create() end
-    def create_with_callbacks #:nodoc:
-      callback(:before_create)
-      create_without_callbacks
-      callback(:after_create)
+    def touch(*) #:nodoc:
+      run_callbacks(:touch) { super }
     end
 
-    # Is called _before_ Base.save on existing objects that has a record.
-    def before_update() end
-
-    # Is called _after_ Base.save on existing objects that has a record.
-    def after_update() end
+  private
 
-    def update_with_callbacks #:nodoc:
-      callback(:before_update)
-      update_without_callbacks
-      callback(:after_update)
+    def create_or_update #:nodoc:
+      run_callbacks(:save) { super }
     end
 
-    # Is called _before_ Validations.validate (which is part of the Base.save call).
-    def before_validation() end
-
-    # Is called _after_ Validations.validate (which is part of the Base.save call).
-    def after_validation() end
-
-    # Is called _before_ Validations.validate (which is part of the Base.save call) on new objects
-    # that haven't been saved yet (no record exists).
-    def before_validation_on_create() end
-
-    # Is called _after_ Validations.validate (which is part of the Base.save call) on new objects
-    # that haven't been saved yet (no record exists).
-    def after_validation_on_create()  end
-
-    # Is called _before_ Validations.validate (which is part of the Base.save call) on 
-    # existing objects that has a record.
-    def before_validation_on_update() end
-
-    # Is called _after_ Validations.validate (which is part of the Base.save call) on 
-    # existing objects that has a record.
-    def after_validation_on_update()  end
-
-    def valid_with_callbacks #:nodoc:
-      callback(:before_validation)
-      if new_record? then callback(:before_validation_on_create) else callback(:before_validation_on_update) end
-
-      result = valid_without_callbacks
-
-      callback(:after_validation)
-      if new_record? then callback(:after_validation_on_create) else callback(:after_validation_on_update) end
-      
-      return result
-    end
-
-    # Is called _before_ Base.destroy.
-    def before_destroy() end
-
-    # Is called _after_ Base.destroy (and all the attributes have been frozen).
-    def after_destroy()  end
-    def destroy_with_callbacks #:nodoc:
-      callback(:before_destroy)
-      destroy_without_callbacks
-      callback(:after_destroy)
-    end
-
-    def callback(callback_method) #:nodoc:
-      run_callbacks(callback_method)
-      send(callback_method)
-      notify(callback_method)
+    def create_record #:nodoc:
+      run_callbacks(:create) { super }
     end
 
-    def run_callbacks(callback_method)
-      filters = self.class.read_inheritable_attribute(callback_method.to_s)
-      if filters.nil? then return end
-      filters.each do |filter| 
-        if Symbol === filter
-          self.send(filter)
-        elsif String === filter
-          eval(filter, binding)
-        elsif filter_block?(filter)
-          filter.call(self)
-        elsif filter_class?(filter, callback_method)
-          filter.send(callback_method, self)
-        else
-          raise(
-            ActiveRecordError, 
-            "Filters need to be either a symbol, string (to be eval'ed), proc/method, or " +
-            "class implementing a static filter method"
-          )
-        end
-      end
-    end
-    
-    def filter_block?(filter)
-      filter.respond_to?("call") && (filter.arity == 1 || filter.arity == -1)
-    end
-    
-    def filter_class?(filter, callback_method)
-      filter.respond_to?(callback_method)
-    end
-    
-    def notify(callback_method) #:nodoc:
-      self.class.changed
-      self.class.notify_observers(callback_method, self)
+    def update_record(*) #:nodoc:
+      run_callbacks(:update) { super }
     end
   end
-end
+end

data/lib/active_record/coders/yaml_column.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+
+module ActiveRecord
+  module Coders # :nodoc:
+    class YAMLColumn # :nodoc:
+
+      attr_accessor :object_class
+
+      def initialize(object_class = Object)
+        @object_class = object_class
+      end
+
+      def dump(obj)
+        return if obj.nil?
+
+        unless obj.is_a?(object_class)
+          raise SerializationTypeMismatch,
+            "Attribute was supposed to be a #{object_class}, but was a #{obj.class}. -- #{obj.inspect}"
+        end
+        YAML.dump obj
+      end
+
+      def load(yaml)
+        return object_class.new if object_class != Object && yaml.nil?
+        return yaml unless yaml.is_a?(String) && yaml =~ /^---/
+        obj = YAML.load(yaml)
+
+        unless obj.is_a?(object_class) || obj.nil?
+          raise SerializationTypeMismatch,
+            "Attribute was supposed to be a #{object_class}, but was a #{obj.class}"
+        end
+        obj ||= object_class.new if object_class != Object
+
+        obj
+      end
+    end
+  end
+end