activerecord 1.15.6 → 2.0.0

data/lib/active_record/calculations.rb

@@ -6,79 +6,82 @@ module ActiveRecord
     end
 
     module ClassMethods
-      # Count operates using three different approaches. 
+      # Count operates using three different approaches.
       #
       # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
-      # * Count by conditions or joins: This API has been deprecated and will be removed in Rails 2.0
+      # * Count using column : By passing a column name to count, it will return a count of all the rows for the model with supplied column present
       # * Count using options will find the row count matched by the options used.
       #
-      # The last approach, count using options, accepts an option hash as the only parameter. The options are:
+      # The third approach, count using options, accepts an option hash as the only parameter. The options are:
       #
       # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro.
-      # * <tt>:joins</tt>: An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
-      #   The records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+      # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
+      #    or names associations in the same form used for the :include option.
+      #   If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+      #   Pass :readonly => false to override.
+      #   See adding joins for associations under Associations.
+      #
       # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
-      #   to already defined associations. When using named associations count returns the number DISTINCT items for the model you're counting.
+      #   to already defined associations. When using named associations, count returns the number of DISTINCT items for the model you're counting.
       #   See eager loading under Associations.
       # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
       # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-      # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
+      # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example, want to do a join but not
       #   include the joined columns.
       # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
       #
       # Examples for counting all:
       #   Person.count         # returns the total count of all people
       #
-      # Examples for count by +conditions+ and +joins+ (this has been deprecated):
-      #   Person.count("age > 26")  # returns the number of people older than 26
-      #   Person.find("age > 26 AND job.salary > 60000", "LEFT JOIN jobs on jobs.person_id = person.id") # returns the total number of rows matching the conditions and joins fetched by SELECT COUNT(*).
+      # Examples for counting by column:
+      #   Person.count(:age)  # returns the total count of all people whose age is present in database
       #
       # Examples for count with options:
       #   Person.count(:conditions => "age > 26")
       #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
-      #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins. 
+      #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins.
       #   Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
       #   Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
       #
       # Note: Person.count(:all) will not work because it will use :all as the condition.  Use Person.count instead.
       def count(*args)
-        calculate(:count, *construct_count_options_from_legacy_args(*args))
+        calculate(:count, *construct_count_options_from_args(*args))
       end
 
-      # Calculates average value on a given column.  The value is returned as a float.  See #calculate for examples with options.
+      # Calculates the average value on a given column.  The value is returned as a float.  See #calculate for examples with options.
       #
       #   Person.average('age')
       def average(column_name, options = {})
         calculate(:avg, column_name, options)
       end
 
-      # Calculates the minimum value on a given column.  The value is returned with the same data type of the column..  See #calculate for examples with options.
+      # Calculates the minimum value on a given column.  The value is returned with the same data type of the column.  See #calculate for examples with options.
       #
       #   Person.minimum('age')
       def minimum(column_name, options = {})
         calculate(:min, column_name, options)
       end
 
-      # Calculates the maximum value on a given column.  The value is returned with the same data type of the column..  See #calculate for examples with options.
+      # Calculates the maximum value on a given column.  The value is returned with the same data type of the column.  See #calculate for examples with options.
       #
       #   Person.maximum('age')
       def maximum(column_name, options = {})
         calculate(:max, column_name, options)
       end
 
-      # Calculates the sum value on a given column.  The value is returned with the same data type of the column..  See #calculate for examples with options.
+      # Calculates the sum of values on a given column.  The value is returned with the same data type of the column.  See #calculate for examples with options.
       #
       #   Person.sum('age')
       def sum(column_name, options = {})
         calculate(:sum, column_name, options)
       end
 
-      # This calculates aggregate values in the given column:  Methods for count, sum, average, minimum, and maximum have been added as shortcuts.
-      # Options such as :conditions, :order, :group, :having, and :joins can be passed to customize the query.  
+      # This calculates aggregate values in the given column.  Methods for count, sum, average, minimum, and maximum have been added as shortcuts.
+      # Options such as :conditions, :order, :group, :having, and :joins can be passed to customize the query.
       #
       # There are two basic forms of output:
       #   * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float for AVG, and the given column's type for everything else.
-      #   * Grouped values: This returns an ordered hash of the values and groups them by the :group option.  It takes either a column name, or the name 
+      #   * Grouped values: This returns an ordered hash of the values and groups them by the :group option.  It takes either a column name, or the name
       #     of a belongs_to association.
       #
       #       values = Person.maximum(:age, :group => 'last_name')
@@ -95,14 +98,15 @@ module ActiveRecord
       #       end
       #
       # Options:
-      # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro.
-      # * <tt>:joins</tt>: An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
+      # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro.
+      # * <tt>:include</tt>: Eager loading, see Associations for details.  Since calculations don't load anything, the purpose of this is to access fields on joined tables in your conditions, order, or group clauses.
+      # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
       #   The records will be returned read-only since they will have attributes that do not correspond to the table's columns.
-      # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
-      # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-      # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
+      # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
+      # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
+      # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
       #   include the joined columns.
-      # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
+      # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
       #
       # Examples:
       #   Person.calculate(:count, :all) # The same as Person.count
@@ -125,60 +129,54 @@ module ActiveRecord
       end
 
       protected
-        def construct_count_options_from_legacy_args(*args)
+        def construct_count_options_from_args(*args)
           options     = {}
           column_name = :all
-
+          
           # We need to handle
           #   count()
+          #   count(:column_name=:all)
           #   count(options={})
           #   count(column_name=:all, options={})
-          #   count(conditions=nil, joins=nil)      # deprecated
-          if args.size > 2
-            raise ArgumentError, "Unexpected parameters passed to count(options={}): #{args.inspect}"
-          elsif args.size > 0
-            if args[0].is_a?(Hash)
-              options = args[0]
-            elsif args[1].is_a?(Hash)
-              column_name, options = args
-            else
-              # Deprecated count(conditions, joins=nil)
-              ActiveSupport::Deprecation.warn(
-                "You called count(#{args[0].inspect}, #{args[1].inspect}), which is a deprecated API call. " +
-                "Instead you should use count(column_name, options). Passing the conditions and joins as " +
-                "string parameters will be removed in Rails 2.0.", caller(2)
-              )
-              options.merge!(:conditions => args[0])
-              options.merge!(:joins      => args[1]) if args[1]
-            end
-          end
-
+          case args.size
+          when 1
+            args[0].is_a?(Hash) ? options = args[0] : column_name = args[0]
+          when 2
+            column_name, options = args
+          else
+            raise ArgumentError, "Unexpected parameters passed to count(): #{args.inspect}"
+          end if args.size > 0
+          
           [column_name, options]
         end
 
         def construct_calculation_sql(operation, column_name, options) #:nodoc:
           operation = operation.to_s.downcase
-          options = options.symbolize_keys          
-          
+          options = options.symbolize_keys
+
           scope           = scope(:find)
           merged_includes = merge_includes(scope ? scope[:include] : [], options[:include])
           aggregate_alias = column_alias_for(operation, column_name)
-          use_workaround  = !Base.connection.supports_count_distinct? && options[:distinct] && operation.to_s.downcase == 'count'
-          join_dependency = nil
 
-          if merged_includes.any? && operation.to_s.downcase == 'count'
-            options[:distinct] = true
-            column_name = options[:select] || [table_name, primary_key] * '.'
+          if operation == 'count'
+            if merged_includes.any?
+              options[:distinct] = true
+              column_name = options[:select] || [connection.quote_table_name(table_name), primary_key] * '.'
+            end
+
+            if options[:distinct]
+              use_workaround = !connection.supports_count_distinct?
+            end
           end
 
-          sql  = "SELECT #{operation}(#{'DISTINCT ' if options[:distinct]}#{column_name}) AS #{aggregate_alias}"
+          sql = "SELECT #{operation}(#{'DISTINCT ' if options[:distinct]}#{column_name}) AS #{aggregate_alias}"
 
           # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
           sql = "SELECT COUNT(*) AS #{aggregate_alias}" if use_workaround
-          
+
           sql << ", #{options[:group_field]} AS #{options[:group_alias]}" if options[:group]
           sql << " FROM (SELECT DISTINCT #{column_name}" if use_workaround
-          sql << " FROM #{table_name} "
+          sql << " FROM #{connection.quote_table_name(table_name)} "
           if merged_includes.any?
             join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merged_includes, options[:joins])
             sql << join_dependency.join_associations.collect{|join| join.association_join }.join
@@ -188,17 +186,17 @@ module ActiveRecord
           add_limited_ids_condition!(sql, options, join_dependency) if join_dependency && !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
 
           if options[:group]
-            group_key = Base.connection.adapter_name == 'FrontBase' ?  :group_alias : :group_field
+            group_key = connection.adapter_name == 'FrontBase' ?  :group_alias : :group_field
             sql << " GROUP BY #{options[group_key]} "
           end
 
           if options[:group] && options[:having]
             # FrontBase requires identifiers in the HAVING clause and chokes on function calls
-            if Base.connection.adapter_name == 'FrontBase'
+            if connection.adapter_name == 'FrontBase'
               options[:having].downcase!
               options[:having].gsub!(/#{operation}\s*\(\s*#{column_name}\s*\)/, aggregate_alias)
             end
-              
+
             sql << " HAVING #{options[:having]} "
           end
 
@@ -231,7 +229,8 @@ module ActiveRecord
           end
 
           calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
-            key   = associated ? key_records[row[group_alias].to_i] : type_cast_calculated_value(row[group_alias], group_column)
+            key   = type_cast_calculated_value(row[group_alias], group_column)
+            key   = key_records[key] if associated
             value = row[aggregate_alias]
             all << [key, type_cast_calculated_value(value, column, operation)]
           end
@@ -243,7 +242,7 @@ module ActiveRecord
         end
 
         # Converts a given key to the value that the database adapter returns as
-        # as a usable column name.
+        # a usable column name.
         #   users.id #=> users_id
         #   sum(id) #=> sum_id
         #   count(distinct users.id) #=> count_distinct_users_id
@@ -261,7 +260,7 @@ module ActiveRecord
           operation = operation.to_s.downcase
           case operation
             when 'count' then value.to_i
-            when 'avg'   then value.to_f
+            when 'avg'   then value && value.to_f
             else column ? column.type_cast(value) : value
           end
         end

data/lib/active_record/callbacks.rb

@@ -1,25 +1,25 @@
 require 'observer'
 
 module ActiveRecord
-  # Callbacks are hooks into the lifecycle of an Active Record object that allows you to trigger logic
+  # Callbacks are hooks into the lifecycle 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 Base#save call:
-  #
-  # * (-) save
-  # * (-) valid?
-  # * (1) before_validation
-  # * (2) before_validation_on_create
-  # * (-) validate
-  # * (-) validate_on_create
-  # * (3) after_validation
-  # * (4) after_validation_on_create
-  # * (5) before_save
-  # * (6) before_create
-  # * (-) create
-  # * (7) after_create
-  # * (8) after_save
+  # 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:
+  #
+  # * (-) <tt>save</tt>
+  # * (-) <tt>valid</tt>
+  # * (1) <tt>before_validation</tt>
+  # * (2) <tt>before_validation_on_create</tt>
+  # * (-) <tt>validate</tt>
+  # * (-) <tt>validate_on_create</tt>
+  # * (3) <tt>after_validation</tt>
+  # * (4) <tt>after_validation_on_create</tt>
+  # * (5) <tt>before_save</tt>
+  # * (6) <tt>before_create</tt>
+  # * (-) <tt>create</tt>
+  # * (7) <tt>after_create</tt>
+  # * (8) <tt>after_save</tt>
   #
   # That's a total of eight callbacks, which gives you immense power to react and prepare for each state in the
   # Active Record lifecycle.
@@ -62,8 +62,8 @@ 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
+  # 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
   # methods:
   #
   #   class Topic < ActiveRecord::Base
@@ -74,9 +74,9 @@ 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 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.
   #
   # *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
@@ -143,7 +143,7 @@ module ActiveRecord
   #     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
+  # 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
@@ -151,23 +151,23 @@ module ActiveRecord
   #                    'puts "Evaluated after parents are destroyed"'
   #   end
   #
-  # == The after_find and after_initialize exceptions
+  # == The +after_find+ and +after_initialize+ exceptions
   #
-  # Because after_find and after_initialize are called for each object found and instantiated 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 will only be run if an explicit implementation is defined (<tt>def after_find</tt>). In that case, all of the
+  # 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
   # callback types will be called.
   #
-  # == before_validation* returning statements
+  # == <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 Base#save will return false.
-  # If Base#save! is called it will raise a RecordNotSave error.
+  # 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 <tt>Base#save!</tt> is called it will raise a +RecordNotSaved+ exception.
   # Nothing will be appended to the errors object.
   #
-  # == Cancelling callbacks
+  # == Canceling callbacks
   #
-  # If a before_* callback returns false, all the later callbacks and the associated action are cancelled. If an after_* callback returns
-  # false, all the later callbacks are cancelled. Callbacks are generally run in the order they are defined, with the exception of 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.
   module Callbacks
     CALLBACKS = %w(
@@ -177,16 +177,10 @@ module ActiveRecord
     )
 
     def self.included(base) #:nodoc:
-      base.extend(ClassMethods)
-      base.class_eval do
-        class << self
-          include Observable
-          alias_method_chain :instantiate, :callbacks
-        end
+      base.extend Observable
 
-        [:initialize, :create_or_update, :valid?, :create, :update, :destroy].each do |method|
-          alias_method_chain method, :callbacks
-        end
+      [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
+        base.send :alias_method_chain, method, :callbacks
       end
 
       CALLBACKS.each do |method|
@@ -199,39 +193,16 @@ module ActiveRecord
       end
     end
 
-    module ClassMethods #:nodoc:
-      def instantiate_with_callbacks(record)
-        object = instantiate_without_callbacks(record)
-
-        if object.respond_to_without_attributes?(:after_find)
-          object.send(:callback, :after_find)
-        end
-
-        if object.respond_to_without_attributes?(:after_initialize)
-          object.send(:callback, :after_initialize)
-        end
-
-        object
-      end
-    end
-
-    # Is called when the object was instantiated by one of the finders, like Base.find.
+    # Is called when the object was instantiated by one of the finders, like <tt>Base.find</tt>.
     #def after_find() end
 
-    # Is called after the object has been instantiated by a call to Base.new.
+    # Is called after the object has been instantiated by a call to <tt>Base.new</tt>.
     #def after_initialize() end
 
-    def initialize_with_callbacks(attributes = nil) #:nodoc:
-      initialize_without_callbacks(attributes)
-      result = yield self if block_given?
-      callback(:after_initialize) if respond_to_without_attributes?(:after_initialize)
-      result
-    end
-
-    # Is called _before_ Base.save (regardless of whether it's a create or update save).
+    # Is called _before_ <tt>Base.save</tt> (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).
+    # Is called _after_ <tt>Base.save</tt> (regardless of whether it's a +create+ or +update+ save).
     #
     #  class Contact < ActiveRecord::Base
     #    after_save { logger.info( 'New contact saved!' ) }
@@ -243,11 +214,12 @@ module ActiveRecord
       callback(:after_save)
       result
     end
+    private :create_or_update_with_callbacks
 
-    # Is called _before_ Base.save on new objects that haven't been saved yet (no record exists).
+    # Is called _before_ <tt>Base.save</tt> 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).
+    # Is called _after_ <tt>Base.save</tt> on new objects that haven't been saved yet (no record exists).
     def after_create() end
     def create_with_callbacks #:nodoc:
       return false if callback(:before_create) == false
@@ -255,11 +227,12 @@ module ActiveRecord
       callback(:after_create)
       result
     end
+    private :create_with_callbacks
 
-    # Is called _before_ Base.save on existing objects that have a record.
+    # Is called _before_ <tt>Base.save</tt> on existing objects that have a record.
     def before_update() end
 
-    # Is called _after_ Base.save on existing objects that have a record.
+    # Is called _after_ <tt>Base.save</tt> on existing objects that have a record.
     def after_update() end
 
     def update_with_callbacks #:nodoc:
@@ -268,26 +241,27 @@ module ActiveRecord
       callback(:after_update)
       result
     end
+    private :update_with_callbacks
 
-    # Is called _before_ Validations.validate (which is part of the Base.save call).
+    # Is called _before_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call).
     def before_validation() end
 
-    # Is called _after_ Validations.validate (which is part of the Base.save call).
+    # Is called _after_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call).
     def after_validation() end
 
-    # Is called _before_ Validations.validate (which is part of the Base.save call) on new objects
+    # Is called _before_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> 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
+    # Is called _after_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> 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
+    # Is called _before_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on
     # existing objects that have a record.
     def before_validation_on_update() end
 
-    # Is called _after_ Validations.validate (which is part of the Base.save call) on
+    # Is called _after_ <tt>Validations.validate</tt> (which is part of the <tt>Base.save</tt> call) on
     # existing objects that have a record.
     def after_validation_on_update()  end
 
@@ -304,13 +278,13 @@ module ActiveRecord
       return result
     end
 
-    # Is called _before_ Base.destroy.
+    # Is called _before_ <tt>Base.destroy</tt>.
     #
     # Note: If you need to _destroy_ or _nullify_ associated records first,
-    # use the _:dependent_ option on your associations.
+    # use the <tt>:dependent</tt> option on your associations.
     def before_destroy() end
 
-    # Is called _after_ Base.destroy (and all the attributes have been frozen).
+    # Is called _after_ <tt>Base.destroy</tt> (and all the attributes have been frozen).
     #
     #  class Contact < ActiveRecord::Base
     #    after_destroy { |record| logger.info( "Contact #{record.id} was destroyed." ) }