activerecord 3.0.0.beta3 → 3.0.0.beta4

data/lib/active_record/attribute_methods/primary_key.rb

@@ -6,7 +6,7 @@ module ActiveRecord
       # Returns this record's primary key value wrapped in an Array
       # or nil if the record is a new_record?
       def to_key
-        new_record? ? nil : [ send(self.class.primary_key) ]
+        new_record? ? nil : [ id ]
       end
 
       module ClassMethods

data/lib/active_record/autosave_association.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/array/wrap'
+
 module ActiveRecord
   # AutosaveAssociation is a module that takes care of automatically saving
   # your associations when the parent is saved. In addition to saving, it
@@ -130,8 +132,6 @@ module ActiveRecord
     ASSOCIATION_TYPES = %w{ has_one belongs_to has_many has_and_belongs_to_many }
 
     included do
-      alias_method_chain :reload, :autosave_associations
-
       ASSOCIATION_TYPES.each do |type|
         send("valid_keys_for_#{type}_association") << :autosave
       end
@@ -196,9 +196,9 @@ module ActiveRecord
     end
 
     # Reloads the attributes of the object as usual and removes a mark for destruction.
-    def reload_with_autosave_associations(options = nil)
+    def reload(options = nil)
       @marked_for_destruction = false
-      reload_without_autosave_associations(options)
+      super
     end
 
     # Marks this record to be destroyed as part of the parents save transaction.
@@ -216,6 +216,12 @@ module ActiveRecord
       @marked_for_destruction
     end
 
+    # Returns whether or not this record has been changed in any way (including whether
+    # any of its nested autosave associations are likewise changed)
+    def changed_for_autosave?
+      new_record? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
+    end
+    
     private
 
     # Returns the record for an association collection that should be validated
@@ -225,12 +231,21 @@ module ActiveRecord
       if new_record
         association
       elsif autosave
-        association.target.find_all { |record| record.new_record? || record.changed? || record.marked_for_destruction? }
+        association.target.find_all { |record| record.changed_for_autosave? }
       else
         association.target.find_all { |record| record.new_record? }
       end
     end
 
+    # go through nested autosave associations that are loaded in memory (without loading
+    # any new ones), and return true if is changed for autosave
+    def nested_records_changed_for_autosave?
+      self.class.reflect_on_all_autosave_associations.any? do |reflection|
+        association = association_instance_get(reflection.name)
+        association && Array.wrap(association.target).any?(&:changed_for_autosave?)
+      end
+    end
+    
     # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
     # turned on for the association specified by +reflection+.
     def validate_single_association(reflection)

data/lib/active_record/base.rb

@@ -480,110 +480,6 @@ module ActiveRecord #:nodoc:
         connection.select_value(sql, "#{name} Count").to_i
       end
 
-      # Resets one or more counter caches to their correct value using an SQL
-      # count query.  This is useful when adding new counter caches, or if the
-      # counter has been corrupted or modified directly by SQL.
-      #
-      # ==== Parameters
-      #
-      # * +id+ - The id of the object you wish to reset a counter on.
-      # * +counters+ - One or more counter names to reset
-      #
-      # ==== Examples
-      #
-      #   # For Post with id #1 records reset the comments_count
-      #   Post.reset_counters(1, :comments)
-      def reset_counters(id, *counters)
-        object = find(id)
-        counters.each do |association|
-          child_class = reflect_on_association(association).klass
-          counter_name = child_class.reflect_on_association(self.name.downcase.to_sym).counter_cache_column
-
-          connection.update("UPDATE #{quoted_table_name} SET #{connection.quote_column_name(counter_name)} = #{object.send(association).count} WHERE #{connection.quote_column_name(primary_key)} = #{quote_value(object.id)}", "#{name} UPDATE")
-        end
-      end
-
-      # A generic "counter updater" implementation, intended primarily to be
-      # used by increment_counter and decrement_counter, but which may also
-      # be useful on its own. It simply does a direct SQL update for the record
-      # with the given ID, altering the given hash of counters by the amount
-      # given by the corresponding value:
-      #
-      # ==== Parameters
-      #
-      # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
-      # * +counters+ - An Array of Hashes containing the names of the fields
-      #   to update as keys and the amount to update the field by as values.
-      #
-      # ==== Examples
-      #
-      #   # For the Post with id of 5, decrement the comment_count by 1, and
-      #   # increment the action_count by 1
-      #   Post.update_counters 5, :comment_count => -1, :action_count => 1
-      #   # Executes the following SQL:
-      #   # UPDATE posts
-      #   #    SET comment_count = comment_count - 1,
-      #   #        action_count = action_count + 1
-      #   #  WHERE id = 5
-      #
-      #   # For the Posts with id of 10 and 15, increment the comment_count by 1
-      #   Post.update_counters [10, 15], :comment_count => 1
-      #   # Executes the following SQL:
-      #   # UPDATE posts
-      #   #    SET comment_count = comment_count + 1,
-      #   #  WHERE id IN (10, 15)
-      def update_counters(id, counters)
-        updates = counters.inject([]) { |list, (counter_name, increment)|
-          sign = increment < 0 ? "-" : "+"
-          list << "#{connection.quote_column_name(counter_name)} = COALESCE(#{connection.quote_column_name(counter_name)}, 0) #{sign} #{increment.abs}"
-        }.join(", ")
-
-        if id.is_a?(Array)
-          ids_list = id.map {|i| quote_value(i)}.join(', ')
-          condition = "IN  (#{ids_list})"
-        else
-          condition = "= #{quote_value(id)}"
-        end
-
-        update_all(updates, "#{connection.quote_column_name(primary_key)} #{condition}")
-      end
-
-      # Increment a number field by one, usually representing a count.
-      #
-      # This is used for caching aggregate values, so that they don't need to be computed every time.
-      # For example, a DiscussionBoard may cache post_count and comment_count otherwise every time the board is
-      # shown it would have to run an SQL query to find how many posts and comments there are.
-      #
-      # ==== Parameters
-      #
-      # * +counter_name+ - The name of the field that should be incremented.
-      # * +id+ - The id of the object that should be incremented.
-      #
-      # ==== Examples
-      #
-      #   # Increment the post_count column for the record with an id of 5
-      #   DiscussionBoard.increment_counter(:post_count, 5)
-      def increment_counter(counter_name, id)
-        update_counters(id, counter_name => 1)
-      end
-
-      # Decrement a number field by one, usually representing a count.
-      #
-      # This works the same as increment_counter but reduces the column value by 1 instead of increasing it.
-      #
-      # ==== Parameters
-      #
-      # * +counter_name+ - The name of the field that should be decremented.
-      # * +id+ - The id of the object that should be decremented.
-      #
-      # ==== Examples
-      #
-      #   # Decrement the post_count column for the record with an id of 5
-      #   DiscussionBoard.decrement_counter(:post_count, 5)
-      def decrement_counter(counter_name, id)
-        update_counters(id, counter_name => -1)
-      end
-
       # Attributes named in this macro are protected from mass-assignment,
       # such as <tt>new(attributes)</tt>,
       # <tt>update_attributes(attributes)</tt>, or
@@ -772,7 +668,6 @@ module ActiveRecord #:nodoc:
             name = "#{full_table_name_prefix}#{contained}#{undecorated_table_name(base.name)}#{table_name_suffix}"
           end
 
-        @quoted_table_name = nil
         set_table_name(name)
         name
       end
@@ -806,6 +701,7 @@ module ActiveRecord #:nodoc:
       #     set_table_name "project"
       #   end
       def set_table_name(value = nil, &block)
+        @quoted_table_name = nil
         define_attr_method :table_name, value, &block
       end
       alias :table_name= :set_table_name
@@ -931,6 +827,10 @@ module ActiveRecord #:nodoc:
         subclasses.each { |klass| klass.reset_inheritable_attributes; klass.reset_column_information }
       end
 
+      def attribute_method?(attribute)
+        super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, '')))
+      end
+
       # Set the lookup ancestors for ActiveModel.
       def lookup_ancestors #:nodoc:
         klass = self
@@ -1275,11 +1175,10 @@ module ActiveRecord #:nodoc:
           with_scope(method_scoping, :overwrite, &block)
         end
 
-        # ActiveRecord::Base utilizes the inherited hook to know about new subclasses.
-        # You can access the list of currently loaded ActiveRecord::Base subclasses using this accessor.
+        # Returns a list of all subclasses of this class, meaning all descendants.
         def subclasses
           @@subclasses[self] ||= []
-          @@subclasses[self] + extra = @@subclasses[self].inject([]) {|list, subclass| list + subclass.subclasses }
+          @@subclasses[self] + @@subclasses[self].inject([]) {|list, subclass| list + subclass.subclasses }
         end
 
         public :subclasses
@@ -1291,7 +1190,7 @@ module ActiveRecord #:nodoc:
         #     default_scope order('last_name, first_name')
         #   end
         def default_scope(options = {})
-          self.default_scoping << construct_finder_arel(options)
+          self.default_scoping << construct_finder_arel(options, default_scoping.pop)
         end
 
         def scoped_methods #:nodoc:
@@ -1320,7 +1219,9 @@ module ActiveRecord #:nodoc:
               begin
                 constant = candidate.constantize
                 return constant if candidate == constant.to_s
-              rescue NameError
+              rescue NameError => e
+                # We don't want to swallow NoMethodError < NameError errors
+                raise e unless e.instance_of?(NameError)
               rescue ArgumentError
               end
             end
@@ -1459,7 +1360,8 @@ module ActiveRecord #:nodoc:
         def replace_bind_variables(statement, values) #:nodoc:
           raise_if_bind_arity_mismatch(statement, statement.count('?'), values.size)
           bound = values.dup
-          statement.gsub('?') { quote_bound_value(bound.shift) }
+          c = connection
+          statement.gsub('?') { quote_bound_value(bound.shift, c) }
         end
 
         def replace_named_bind_variables(statement, bind_vars) #:nodoc:
@@ -1491,15 +1393,15 @@ module ActiveRecord #:nodoc:
           expanded
         end
 
-        def quote_bound_value(value) #:nodoc:
+        def quote_bound_value(value, c = connection) #:nodoc:
           if value.respond_to?(:map) && !value.acts_like?(:string)
             if value.respond_to?(:empty?) && value.empty?
-              connection.quote(nil)
+              c.quote(nil)
             else
-              value.map { |v| connection.quote(v) }.join(',')
+              value.map { |v| c.quote(v) }.join(',')
             end
           else
-            connection.quote(value)
+            c.quote(value)
           end
         end
 
@@ -1559,7 +1461,14 @@ module ActiveRecord #:nodoc:
         callback(:after_initialize) if respond_to_without_attributes?(:after_initialize)
         cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
         cloned_attributes.delete(self.class.primary_key)
+
         @attributes = cloned_attributes
+
+        @changed_attributes = {}
+        attributes_from_column_definition.each do |attr, orig_value|
+          @changed_attributes[attr] = orig_value if field_changed?(attr, orig_value, @attributes[attr])
+        end
+
         clear_aggregation_cache
         @attributes_cache = {}
         @new_record = true
@@ -1620,186 +1529,6 @@ module ActiveRecord #:nodoc:
         quote_value(id, column_for_attribute(self.class.primary_key))
       end
 
-      # Returns true if this object hasn't been saved yet -- that is, a record for the object doesn't exist yet; otherwise, returns false.
-      def new_record?
-        @new_record
-      end
-
-      # Returns true if this object has been destroyed, otherwise returns false.
-      def destroyed?
-        @destroyed
-      end
-
-      # Returns if the record is persisted, i.e. it's not a new record and it was not destroyed.
-      def persisted?
-        !(new_record? || destroyed?)
-      end
-
-      # :call-seq:
-      #   save(options)
-      #
-      # Saves the model.
-      #
-      # If the model is new a record gets created in the database, otherwise
-      # the existing record gets updated.
-      #
-      # By default, save always run validations. If any of them fail the action
-      # is cancelled and +save+ returns +false+. However, if you supply
-      # :validate => false, validations are bypassed altogether. See
-      # ActiveRecord::Validations for more information.
-      #
-      # There's a series of callbacks associated with +save+. If any of the
-      # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
-      # +save+ returns +false+. See ActiveRecord::Callbacks for further
-      # details.
-      def save
-        create_or_update
-      end
-
-      # Saves the model.
-      #
-      # If the model is new a record gets created in the database, otherwise
-      # the existing record gets updated.
-      #
-      # With <tt>save!</tt> validations always run. If any of them fail
-      # ActiveRecord::RecordInvalid gets raised. See ActiveRecord::Validations
-      # for more information.
-      #
-      # There's a series of callbacks associated with <tt>save!</tt>. If any of
-      # the <tt>before_*</tt> callbacks return +false+ the action is cancelled
-      # and <tt>save!</tt> raises ActiveRecord::RecordNotSaved. See
-      # ActiveRecord::Callbacks for further details.
-      def save!
-        create_or_update || raise(RecordNotSaved)
-      end
-
-      # Deletes the record in the database and freezes this instance to
-      # reflect that no changes should be made (since they can't be
-      # persisted). Returns the frozen instance.
-      #
-      # The row is simply removed with a SQL +DELETE+ statement on the
-      # record's primary key, and no callbacks are executed.
-      #
-      # To enforce the object's +before_destroy+ and +after_destroy+
-      # callbacks, Observer methods, or any <tt>:dependent</tt> association
-      # options, use <tt>#destroy</tt>.
-      def delete
-        self.class.delete(id) if persisted?
-        @destroyed = true
-        freeze
-      end
-
-      # Deletes the record in the database and freezes this instance to reflect that no changes should
-      # be made (since they can't be persisted).
-      def destroy
-        if persisted?
-          self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).delete_all
-        end
-
-        @destroyed = true
-        freeze
-      end
-
-      # Returns an instance of the specified +klass+ with the attributes of the current record. This is mostly useful in relation to
-      # single-table inheritance structures where you want a subclass to appear as the superclass. This can be used along with record
-      # identification in Action Pack to allow, say, <tt>Client < Company</tt> to do something like render <tt>:partial => @client.becomes(Company)</tt>
-      # to render that instance using the companies/company partial instead of clients/client.
-      #
-      # Note: The new instance will share a link to the same attributes as the original class. So any change to the attributes in either
-      # instance will affect the other.
-      def becomes(klass)
-        became = klass.new
-        became.instance_variable_set("@attributes", @attributes)
-        became.instance_variable_set("@attributes_cache", @attributes_cache)
-        became.instance_variable_set("@new_record", new_record?)
-        became.instance_variable_set("@destroyed", destroyed?)
-        became
-      end
-
-      # Updates a single attribute and saves the record without going through the normal validation procedure.
-      # This is especially useful for boolean flags on existing records. The regular +update_attribute+ method
-      # in Base is replaced with this when the validations module is mixed in, which it is by default.
-      def update_attribute(name, value)
-        send("#{name}=", value)
-        save(:validate => false)
-      end
-
-      # Updates all the attributes from the passed-in Hash and saves the record. If the object is invalid, the saving will
-      # fail and false will be returned.
-      def update_attributes(attributes)
-        self.attributes = attributes
-        save
-      end
-
-      # Updates an object just like Base.update_attributes but calls save! instead of save so an exception is raised if the record is invalid.
-      def update_attributes!(attributes)
-        self.attributes = attributes
-        save!
-      end
-
-      # Initializes +attribute+ to zero if +nil+ and adds the value passed as +by+ (default is 1).
-      # The increment is performed directly on the underlying attribute, no setter is invoked.
-      # Only makes sense for number-based attributes. Returns +self+.
-      def increment(attribute, by = 1)
-        self[attribute] ||= 0
-        self[attribute] += by
-        self
-      end
-
-      # Wrapper around +increment+ that saves the record. This method differs from
-      # its non-bang version in that it passes through the attribute setter.
-      # Saving is not subjected to validation checks. Returns +true+ if the
-      # record could be saved.
-      def increment!(attribute, by = 1)
-        increment(attribute, by).update_attribute(attribute, self[attribute])
-      end
-
-      # Initializes +attribute+ to zero if +nil+ and subtracts the value passed as +by+ (default is 1).
-      # The decrement is performed directly on the underlying attribute, no setter is invoked.
-      # Only makes sense for number-based attributes. Returns +self+.
-      def decrement(attribute, by = 1)
-        self[attribute] ||= 0
-        self[attribute] -= by
-        self
-      end
-
-      # Wrapper around +decrement+ that saves the record. This method differs from
-      # its non-bang version in that it passes through the attribute setter.
-      # Saving is not subjected to validation checks. Returns +true+ if the
-      # record could be saved.
-      def decrement!(attribute, by = 1)
-        decrement(attribute, by).update_attribute(attribute, self[attribute])
-      end
-
-      # Assigns to +attribute+ the boolean opposite of <tt>attribute?</tt>. So
-      # if the predicate returns +true+ the attribute will become +false+. This
-      # method toggles directly the underlying value without calling any setter.
-      # Returns +self+.
-      def toggle(attribute)
-        self[attribute] = !send("#{attribute}?")
-        self
-      end
-
-      # Wrapper around +toggle+ that saves the record. This method differs from
-      # its non-bang version in that it passes through the attribute setter.
-      # Saving is not subjected to validation checks. Returns +true+ if the
-      # record could be saved.
-      def toggle!(attribute)
-        toggle(attribute).update_attribute(attribute, self[attribute])
-      end
-
-      # Reloads the attributes of this object from the database.
-      # The optional options argument is passed to find when reloading so you
-      # may do e.g. record.reload(:lock => true) to reload the same record with
-      # an exclusive row lock.
-      def reload(options = nil)
-        clear_aggregation_cache
-        clear_association_cache
-        @attributes.update(self.class.send(:with_exclusive_scope) { self.class.find(self.id, options) }.instance_variable_get('@attributes'))
-        @attributes_cache = {}
-        self
-      end
-
       # Returns true if the given attribute is in the attributes hash
       def has_attribute?(attr_name)
         @attributes.has_key?(attr_name.to_s)
@@ -1845,8 +1574,7 @@ module ActiveRecord #:nodoc:
       #   user.is_admin?  # => true
       def attributes=(new_attributes, guard_protected_attributes = true)
         return if new_attributes.nil?
-        attributes = new_attributes.dup
-        attributes.stringify_keys!
+        attributes = new_attributes.stringify_keys
 
         multi_parameter_attributes = []
         attributes = remove_attributes_protected_from_mass_assignment(attributes) if guard_protected_attributes
@@ -1978,40 +1706,6 @@ module ActiveRecord #:nodoc:
       end
 
     private
-      def create_or_update
-        raise ReadOnlyRecord if readonly?
-        result = new_record? ? create : update
-        result != false
-      end
-
-      # Updates the associated record with values matching those of the instance attributes.
-      # Returns the number of affected rows.
-      def update(attribute_names = @attributes.keys)
-        attributes_with_values = arel_attributes_values(false, false, attribute_names)
-        return 0 if attributes_with_values.empty?
-        self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(attributes_with_values)
-      end
-
-      # Creates a record with values matching those of the instance attributes
-      # and returns its id.
-      def create
-        if self.id.nil? && connection.prefetch_primary_key?(self.class.table_name)
-          self.id = connection.next_sequence_value(self.class.sequence_name)
-        end
-
-        attributes_values = arel_attributes_values
-
-        new_id = if attributes_values.empty?
-          self.class.unscoped.insert connection.empty_insert_statement_value
-        else
-          self.class.unscoped.insert attributes_values
-        end
-
-        self.id ||= new_id
-
-        @new_record = false
-        id
-      end
 
       # Sets the attribute used for single table inheritance to this class name if this is not the ActiveRecord::Base descendant.
       # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to do Reply.new without having to
@@ -2094,18 +1788,7 @@ module ActiveRecord #:nodoc:
       # Interpolate custom SQL string in instance context.
       # Optional record argument is meant for custom insert_sql.
       def interpolate_sql(sql, record = nil)
-        instance_eval("%@#{sql.gsub('@', '\@')}@")
-      end
-
-      # Initializes the attributes array with keys matching the columns from the linked table and
-      # the values matching the corresponding default value of that column, so
-      # that a new instance, or one populated from a passed-in Hash, still has all the attributes
-      # that instances loaded from the database would.
-      def attributes_from_column_definition
-        self.class.columns.inject({}) do |attributes, column|
-          attributes[column.name] = column.default unless column.name == self.class.primary_key
-          attributes
-        end
+        instance_eval("%@#{sql.gsub('@', '\@')}@", __FILE__, __LINE__)
       end
 
       # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
@@ -2223,12 +1906,14 @@ module ActiveRecord #:nodoc:
   end
 
   Base.class_eval do
+    include ActiveRecord::Persistence
     extend ActiveModel::Naming
     extend QueryCache::ClassMethods
     extend ActiveSupport::Benchmarkable
 
     include ActiveModel::Conversion
     include Validations
+    extend CounterCache
     include Locking::Optimistic, Locking::Pessimistic
     include AttributeMethods
     include AttributeMethods::Read, AttributeMethods::Write, AttributeMethods::BeforeTypeCast, AttributeMethods::Query