activerecord 4.0.13 → 4.1.0.beta1

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -41,8 +41,9 @@ module ActiveRecord
       #   task.read_attribute_before_type_cast('id')           # => '1'
       #   task.read_attribute('completed_on')                  # => Sun, 21 Oct 2012
       #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+      #   task.read_attribute_before_type_cast(:completed_on)  # => "2012-10-21"
       def read_attribute_before_type_cast(attr_name)
-        @attributes[attr_name]
+        @attributes[attr_name.to_s]
       end
 
       # Returns a hash of attributes before typecasting and deserialization.

data/lib/active_record/attribute_methods/dirty.rb

@@ -14,24 +14,12 @@ module ActiveRecord
 
         class_attribute :partial_writes, instance_writer: false
         self.partial_writes = true
-
-        def self.partial_updates=(v); self.partial_writes = v; end
-        def self.partial_updates?; partial_writes?; end
-        def self.partial_updates; partial_writes; end
-
-        ActiveSupport::Deprecation.deprecate_methods(
-          singleton_class,
-          :partial_updates= => :partial_writes=,
-          :partial_updates? => :partial_writes?,
-          :partial_updates  => :partial_writes
-        )
       end
 
       # Attempts to +save+ the record and clears changed attributes if successful.
       def save(*)
         if status = super
-          @previously_changed = changes
-          @changed_attributes.clear
+          changes_applied
         end
         status
       end
@@ -39,16 +27,14 @@ module ActiveRecord
       # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
       def save!(*)
         super.tap do
-          @previously_changed = changes
-          @changed_attributes.clear
+          changes_applied
         end
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          @previously_changed.clear
-          @changed_attributes.clear
+          reset_changes
         end
       end
 
@@ -59,22 +45,22 @@ module ActiveRecord
 
         # The attribute already has an unsaved change.
         if attribute_changed?(attr)
-          old = @changed_attributes[attr]
-          @changed_attributes.delete(attr) unless _field_changed?(attr, old, value)
+          old = changed_attributes[attr]
+          changed_attributes.delete(attr) unless _field_changed?(attr, old, value)
         else
           old = clone_attribute_value(:read_attribute, attr)
-          @changed_attributes[attr] = old if _field_changed?(attr, old, value)
+          changed_attributes[attr] = old if _field_changed?(attr, old, value)
         end
 
         # Carry on.
         super(attr, value)
       end
 
-      def _update_record(*)
+      def update_record(*)
         partial_writes? ? super(keys_for_partial_write) : super
       end
 
-      def _create_record(*)
+      def create_record(*)
         partial_writes? ? super(keys_for_partial_write) : super
       end
 

data/lib/active_record/attribute_methods/primary_key.rb

@@ -37,12 +37,6 @@ module ActiveRecord
         read_attribute_before_type_cast(self.class.primary_key)
       end
 
-      # Returns the primary key previous value.
-      def id_was
-        sync_with_transaction_state
-        attribute_was(self.class.primary_key)
-      end
-
       protected
 
       def attribute_method?(attr_name)
@@ -58,7 +52,7 @@ module ActiveRecord
           end
         end
 
-        ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was).to_set
+        ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast).to_set
 
         def dangerous_attribute_method?(method_name)
           super && !ID_ATTRIBUTE_METHODS.include?(method_name)

data/lib/active_record/attribute_methods/read.rb

@@ -1,6 +1,38 @@
+require 'active_support/core_ext/module/method_transplanting'
+
 module ActiveRecord
   module AttributeMethods
     module Read
+      ReaderMethodCache = Class.new(AttributeMethodCache) {
+        private
+        # We want to generate the methods via module_eval rather than
+        # define_method, because define_method is slower on dispatch.
+        # Evaluating many similar methods may use more memory as the instruction
+        # sequences are duplicated and cached (in MRI).  define_method may
+        # be slower on dispatch, but if you're careful about the closure
+        # created, then define_method will consume much less memory.
+        #
+        # But sometimes the database might return columns with
+        # characters that are not allowed in normal method names (like
+        # 'my_column(omg)'. So to work around this we first define with
+        # the __temp__ identifier, and then use alias method to rename
+        # it to what we want.
+        #
+        # We are also defining a constant to hold the frozen string of
+        # the attribute name. Using a constant means that we do not have
+        # to allocate an object on each call to the attribute method.
+        # Making it frozen means that it doesn't get duped when used to
+        # key the @attributes_cache in read_attribute.
+        def method_body(method_name, const_name)
+          <<-EOMETHOD
+          def #{method_name}
+            name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{const_name}
+            read_attribute(name) { |n| missing_attribute(n, caller) }
+          end
+          EOMETHOD
+        end
+      }.new
+
       extend ActiveSupport::Concern
 
       ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
@@ -32,35 +64,30 @@ module ActiveRecord
 
         protected
 
-        # We want to generate the methods via module_eval rather than
-        # define_method, because define_method is slower on dispatch.
-        # Evaluating many similar methods may use more memory as the instruction
-        # sequences are duplicated and cached (in MRI).  define_method may
-        # be slower on dispatch, but if you're careful about the closure
-        # created, then define_method will consume much less memory.
-        #
-        # But sometimes the database might return columns with
-        # characters that are not allowed in normal method names (like
-        # 'my_column(omg)'. So to work around this we first define with
-        # the __temp__ identifier, and then use alias method to rename
-        # it to what we want.
-        #
-        # We are also defining a constant to hold the frozen string of
-        # the attribute name. Using a constant means that we do not have
-        # to allocate an object on each call to the attribute method.
-        # Making it frozen means that it doesn't get duped when used to
-        # key the @attributes_cache in read_attribute.
-        def define_method_attribute(name)
-          safe_name = name.unpack('h*').first
-          generated_attribute_methods::AttrNames.set_name_cache safe_name, name
-
-          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-            def __temp__#{safe_name}
-              read_attribute(AttrNames::ATTR_#{safe_name}) { |n| missing_attribute(n, caller) }
+        if Module.methods_transplantable?
+          def define_method_attribute(name)
+            method = ReaderMethodCache[name]
+            generated_attribute_methods.module_eval { define_method name, method }
+          end
+        else
+          def define_method_attribute(name)
+            safe_name = name.unpack('h*').first
+            temp_method = "__temp__#{safe_name}"
+
+            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+              def #{temp_method}
+                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+                read_attribute(name) { |n| missing_attribute(n, caller) }
+              end
+            STR
+
+            generated_attribute_methods.module_eval do
+              alias_method name, temp_method
+              undef_method temp_method
             end
-            alias_method #{name.inspect}, :__temp__#{safe_name}
-            undef_method :__temp__#{safe_name}
-          STR
+          end
         end
 
         private

data/lib/active_record/attribute_methods/serialization.rb

@@ -24,11 +24,13 @@ module ActiveRecord
         # serialized object must be of that class on retrieval or
         # <tt>SerializationTypeMismatch</tt> will be raised.
         #
+        # A notable side effect of serialized attributes is that the model will
+        # be updated on every save, even if it is not dirty.
+        #
         # ==== Parameters
         #
         # * +attr_name+ - The field name that should be serialized.
-        # * +class_name_or_coder+ - Optional, a coder object, which responds to `.load` / `.dump`
-        #   or a class name that the object type should be equal to.
+        # * +class_name+ - Optional, class name that the object type should be equal to.
         #
         # ==== Example
         #
@@ -36,23 +38,13 @@ module ActiveRecord
         #   class User < ActiveRecord::Base
         #     serialize :preferences
         #   end
-        #
-        #   # Serialize preferences using JSON as coder.
-        #   class User < ActiveRecord::Base
-        #     serialize :preferences, JSON
-        #   end
-        #
-        #   # Serialize preferences as Hash using YAML coder.
-        #   class User < ActiveRecord::Base
-        #     serialize :preferences, Hash
-        #   end
-        def serialize(attr_name, class_name_or_coder = Object)
+        def serialize(attr_name, class_name = Object)
           include Behavior
 
-          coder = if [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
-                    class_name_or_coder
+          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
+                    class_name
                   else
-                    Coders::YAMLColumn.new(class_name_or_coder)
+                    Coders::YAMLColumn.new(class_name)
                   end
 
           # merge new serialized attribute and create new hash to ensure that each class in inheritance hierarchy
@@ -61,13 +53,6 @@ module ActiveRecord
         end
       end
 
-      # *DEPRECATED*: Use ActiveRecord::AttributeMethods::Serialization::ClassMethods#serialized_attributes class level method instead.
-      def serialized_attributes
-        message = "Instance level serialized_attributes method is deprecated, please use class level method."
-        ActiveSupport::Deprecation.warn message
-        defined?(@serialized_attributes) ? @serialized_attributes : self.class.serialized_attributes
-      end
-
       class Type # :nodoc:
         def initialize(column)
           @column = column
@@ -84,6 +69,10 @@ module ActiveRecord
         def type
           @column.type
         end
+
+        def accessor
+          ActiveRecord::Store::IndifferentHashAccessor
+        end
       end
 
       class Attribute < Struct.new(:coder, :value, :state) # :nodoc:
@@ -167,16 +156,6 @@ module ActiveRecord
             super
           end
         end
-
-        def attributes_for_coder
-          attribute_names.each_with_object({}) do |name, attrs|
-            attrs[name] = if self.class.serialized_attributes.include?(name)
-                            @attributes[name].serialized_value
-                          else
-                            read_attribute(name)
-                          end
-          end
-        end
       end
     end
   end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -34,7 +34,7 @@ module ActiveRecord
           if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
             method_body, line = <<-EOV, __LINE__ + 1
               def #{attr_name}=(time)
-                time_with_zone = convert_value_to_time_zone(time)
+                time_with_zone = time.respond_to?(:in_time_zone) ? time.in_time_zone : nil
                 previous_time = attribute_changed?("#{attr_name}") ? changed_attributes["#{attr_name}"] : read_attribute(:#{attr_name})
                 write_attribute(:#{attr_name}, time)
                 #{attr_name}_will_change! if previous_time != time_with_zone
@@ -54,18 +54,6 @@ module ActiveRecord
             (:datetime == column.type || :timestamp == column.type)
         end
       end
-
-      private
-
-      def convert_value_to_time_zone(value)
-        if value.is_a?(Array)
-          value.map { |v| convert_value_to_time_zone(v) }
-        elsif value.respond_to?(:in_time_zone)
-          value.in_time_zone
-        else
-          nil
-        end
-      end
     end
   end
 end

data/lib/active_record/attribute_methods/write.rb

@@ -1,6 +1,21 @@
+require 'active_support/core_ext/module/method_transplanting'
+
 module ActiveRecord
   module AttributeMethods
     module Write
+      WriterMethodCache = Class.new(AttributeMethodCache) {
+        private
+
+        def method_body(method_name, const_name)
+          <<-EOMETHOD
+          def #{method_name}(value)
+            name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{const_name}
+            write_attribute(name, value)
+          end
+          EOMETHOD
+        end
+      }.new
+
       extend ActiveSupport::Concern
 
       included do
@@ -10,19 +25,29 @@ module ActiveRecord
       module ClassMethods
         protected
 
-        # See define_method_attribute in read.rb for an explanation of
-        # this code.
-        def define_method_attribute=(name)
-          safe_name = name.unpack('h*').first
-          generated_attribute_methods::AttrNames.set_name_cache safe_name, name
+        if Module.methods_transplantable?
+          # See define_method_attribute in read.rb for an explanation of
+          # this code.
+          def define_method_attribute=(name)
+            method = WriterMethodCache[name]
+            generated_attribute_methods.module_eval {
+              define_method "#{name}=", method
+            }
+          end
+        else
+          def define_method_attribute=(name)
+            safe_name = name.unpack('h*').first
+            ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
 
-          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-            def __temp__#{safe_name}=(value)
-              write_attribute(AttrNames::ATTR_#{safe_name}, value)
-            end
-            alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
-            undef_method :__temp__#{safe_name}=
-          STR
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+              def __temp__#{safe_name}=(value)
+                name = ::ActiveRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+                write_attribute(name, value)
+              end
+              alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
+              undef_method :__temp__#{safe_name}=
+            STR
+          end
         end
       end
 

data/lib/active_record/autosave_association.rb

@@ -127,87 +127,87 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     module AssociationBuilderExtension #:nodoc:
-      def build
+      def self.build(model, reflection)
         model.send(:add_autosave_association_callbacks, reflection)
-        super
+      end
+
+      def self.valid_options
+        [ :autosave ]
       end
     end
 
     included do
-      Associations::Builder::Association.class_eval do
-        self.valid_options << :autosave
-        include AssociationBuilderExtension
-      end
+      Associations::Builder::Association.extensions << AssociationBuilderExtension
     end
 
     module ClassMethods
       private
 
-      def define_non_cyclic_method(name, reflection, &block)
-        define_method(name) do |*args|
-          result = true; @_already_called ||= {}
-          # Loop prevention for validation of associations
-          unless @_already_called[[name, reflection.name]]
-            begin
-              @_already_called[[name, reflection.name]]=true
-              result = instance_eval(&block)
-            ensure
-              @_already_called[[name, reflection.name]]=false
+        def define_non_cyclic_method(name, &block)
+          define_method(name) do |*args|
+            result = true; @_already_called ||= {}
+            # Loop prevention for validation of associations
+            unless @_already_called[name]
+              begin
+                @_already_called[name]=true
+                result = instance_eval(&block)
+              ensure
+                @_already_called[name]=false
+              end
             end
-          end
 
-          result
+            result
+          end
         end
-      end
 
-      # Adds validation and save callbacks for the association as specified by
-      # the +reflection+.
-      #
-      # For performance reasons, we don't check whether to validate at runtime.
-      # However the validation and callback methods are lazy and those methods
-      # get created when they are invoked for the very first time. However,
-      # this can change, for instance, when using nested attributes, which is
-      # called _after_ the association has been defined. Since we don't want
-      # the callbacks to get defined multiple times, there are guards that
-      # check if the save or validation methods have already been defined
-      # before actually defining them.
-      def add_autosave_association_callbacks(reflection)
-        save_method = :"autosave_associated_records_for_#{reflection.name}"
-        validation_method = :"validate_associated_records_for_#{reflection.name}"
-        collection = reflection.collection?
-
-        unless method_defined?(save_method)
-          if collection
-            before_save :before_save_collection_association
-
-            define_non_cyclic_method(save_method, reflection) { save_collection_association(reflection) }
-            # Doesn't use after_save as that would save associations added in after_create/after_update twice
-            after_create save_method
-            after_update save_method
-          elsif reflection.macro == :has_one
-            define_method(save_method) { save_has_one_association(reflection) }
-            # Configures two callbacks instead of a single after_save so that
-            # the model may rely on their execution order relative to its
-            # own callbacks.
-            #
-            # For example, given that after_creates run before after_saves, if
-            # we configured instead an after_save there would be no way to fire
-            # a custom after_create callback after the child association gets
-            # created.
-            after_create save_method
-            after_update save_method
-          else
-            define_non_cyclic_method(save_method, reflection) { save_belongs_to_association(reflection) }
-            before_save save_method
+        # Adds validation and save callbacks for the association as specified by
+        # the +reflection+.
+        #
+        # For performance reasons, we don't check whether to validate at runtime.
+        # However the validation and callback methods are lazy and those methods
+        # get created when they are invoked for the very first time. However,
+        # this can change, for instance, when using nested attributes, which is
+        # called _after_ the association has been defined. Since we don't want
+        # the callbacks to get defined multiple times, there are guards that
+        # check if the save or validation methods have already been defined
+        # before actually defining them.
+        def add_autosave_association_callbacks(reflection)
+          save_method = :"autosave_associated_records_for_#{reflection.name}"
+          validation_method = :"validate_associated_records_for_#{reflection.name}"
+          collection = reflection.collection?
+
+          unless method_defined?(save_method)
+            if collection
+              before_save :before_save_collection_association
+
+              define_non_cyclic_method(save_method) { save_collection_association(reflection) }
+              # Doesn't use after_save as that would save associations added in after_create/after_update twice
+              after_create save_method
+              after_update save_method
+            elsif reflection.macro == :has_one
+              define_method(save_method) { save_has_one_association(reflection) }
+              # Configures two callbacks instead of a single after_save so that
+              # the model may rely on their execution order relative to its
+              # own callbacks.
+              #
+              # For example, given that after_creates run before after_saves, if
+              # we configured instead an after_save there would be no way to fire
+              # a custom after_create callback after the child association gets
+              # created.
+              after_create save_method
+              after_update save_method
+            else
+              define_non_cyclic_method(save_method) { save_belongs_to_association(reflection) }
+              before_save save_method
+            end
           end
-        end
 
-        if reflection.validate? && !method_defined?(validation_method)
-          method = (collection ? :validate_collection_association : :validate_single_association)
-          define_non_cyclic_method(validation_method, reflection) { send(method, reflection) }
-          validate validation_method
+          if reflection.validate? && !method_defined?(validation_method)
+            method = (collection ? :validate_collection_association : :validate_single_association)
+            define_non_cyclic_method(validation_method) { send(method, reflection) }
+            validate validation_method
+          end
         end
-      end
     end
 
     # Reloads the attributes of the object as usual and clears <tt>marked_for_destruction</tt> flag.
@@ -254,179 +254,179 @@ module ActiveRecord
 
     private
 
-    # Returns the record for an association collection that should be validated
-    # or saved. If +autosave+ is +false+ only new records will be returned,
-    # unless the parent is/was a new record itself.
-    def associated_records_to_validate_or_save(association, new_record, autosave)
-      if new_record
-        association && association.target
-      elsif autosave
-        association.target.find_all { |record| record.changed_for_autosave? }
-      else
-        association.target.find_all { |record| record.new_record? }
+      # Returns the record for an association collection that should be validated
+      # or saved. If +autosave+ is +false+ only new records will be returned,
+      # unless the parent is/was a new record itself.
+      def associated_records_to_validate_or_save(association, new_record, autosave)
+        if new_record
+          association && association.target
+        elsif autosave
+          association.target.find_all { |record| record.changed_for_autosave? }
+        else
+          association.target.find_all { |record| record.new_record? }
+        end
       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? { |a| a.changed_for_autosave? }
+      # 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? { |a| a.changed_for_autosave? }
+        end
       end
-    end
 
-    # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
-    # turned on for the association.
-    def validate_single_association(reflection)
-      association = association_instance_get(reflection.name)
-      record      = association && association.reader
-      association_valid?(reflection, record) if record
-    end
+      # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
+      # turned on for the association.
+      def validate_single_association(reflection)
+        association = association_instance_get(reflection.name)
+        record      = association && association.reader
+        association_valid?(reflection, record) if record
+      end
 
-    # Validate the associated records if <tt>:validate</tt> or
-    # <tt>:autosave</tt> is turned on for the association specified by
-    # +reflection+.
-    def validate_collection_association(reflection)
-      if association = association_instance_get(reflection.name)
-        if records = associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave])
-          records.each { |record| association_valid?(reflection, record) }
+      # Validate the associated records if <tt>:validate</tt> or
+      # <tt>:autosave</tt> is turned on for the association specified by
+      # +reflection+.
+      def validate_collection_association(reflection)
+        if association = association_instance_get(reflection.name)
+          if records = associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave])
+            records.each { |record| association_valid?(reflection, record) }
+          end
         end
       end
-    end
 
-    # Returns whether or not the association is valid and applies any errors to
-    # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
-    # enabled records if they're marked_for_destruction? or destroyed.
-    def association_valid?(reflection, record)
-      return true if record.destroyed? || record.marked_for_destruction?
-
-      unless valid = record.valid?
-        if reflection.options[:autosave]
-          record.errors.each do |attribute, message|
-            attribute = "#{reflection.name}.#{attribute}"
-            errors[attribute] << message
-            errors[attribute].uniq!
+      # Returns whether or not the association is valid and applies any errors to
+      # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
+      # enabled records if they're marked_for_destruction? or destroyed.
+      def association_valid?(reflection, record)
+        return true if record.destroyed? || record.marked_for_destruction?
+
+        unless valid = record.valid?
+          if reflection.options[:autosave]
+            record.errors.each do |attribute, message|
+              attribute = "#{reflection.name}.#{attribute}"
+              errors[attribute] << message
+              errors[attribute].uniq!
+            end
+          else
+            errors.add(reflection.name)
           end
-        else
-          errors.add(reflection.name)
         end
+        valid
       end
-      valid
-    end
 
-    # Is used as a before_save callback to check while saving a collection
-    # association whether or not the parent was a new record before saving.
-    def before_save_collection_association
-      @new_record_before_save = new_record?
-      true
-    end
+      # Is used as a before_save callback to check while saving a collection
+      # association whether or not the parent was a new record before saving.
+      def before_save_collection_association
+        @new_record_before_save = new_record?
+        true
+      end
 
-    # Saves any new associated records, or all loaded autosave associations if
-    # <tt>:autosave</tt> is enabled on the association.
-    #
-    # In addition, it destroys all children that were marked for destruction
-    # with mark_for_destruction.
-    #
-    # This all happens inside a transaction, _if_ the Transactions module is included into
-    # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
-    def save_collection_association(reflection)
-      if association = association_instance_get(reflection.name)
-        autosave = reflection.options[:autosave]
-
-        if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
-
-          if autosave
-            records_to_destroy = records.select(&:marked_for_destruction?)
-            records_to_destroy.each { |record| association.destroy(record) }
-            records -= records_to_destroy
-          end
+      # Saves any new associated records, or all loaded autosave associations if
+      # <tt>:autosave</tt> is enabled on the association.
+      #
+      # In addition, it destroys all children that were marked for destruction
+      # with mark_for_destruction.
+      #
+      # This all happens inside a transaction, _if_ the Transactions module is included into
+      # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
+      def save_collection_association(reflection)
+        if association = association_instance_get(reflection.name)
+          autosave = reflection.options[:autosave]
+
+          if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+
+            if autosave
+              records_to_destroy = records.select(&:marked_for_destruction?)
+              records_to_destroy.each { |record| association.destroy(record) }
+              records -= records_to_destroy
+            end
 
-          records.each do |record|
-            next if record.destroyed?
+            records.each do |record|
+              next if record.destroyed?
 
-            saved = true
+              saved = true
 
-            if autosave != false && (@new_record_before_save || record.new_record?)
-              if autosave
-                saved = association.insert_record(record, false)
-              else
-                association.insert_record(record) unless reflection.nested?
+              if autosave != false && (@new_record_before_save || record.new_record?)
+                if autosave
+                  saved = association.insert_record(record, false)
+                else
+                  association.insert_record(record) unless reflection.nested?
+                end
+              elsif autosave
+                saved = record.save(:validate => false)
               end
-            elsif autosave
-              saved = record.save(:validate => false)
-            end
 
-            raise ActiveRecord::Rollback unless saved
+              raise ActiveRecord::Rollback unless saved
+            end
           end
-        end
 
-        # reconstruct the scope now that we know the owner's id
-        association.reset_scope if association.respond_to?(:reset_scope)
+          # reconstruct the scope now that we know the owner's id
+          association.reset_scope if association.respond_to?(:reset_scope)
+        end
       end
-    end
 
-    # Saves the associated record if it's new or <tt>:autosave</tt> is enabled
-    # on the association.
-    #
-    # In addition, it will destroy the association if it was marked for
-    # destruction with mark_for_destruction.
-    #
-    # This all happens inside a transaction, _if_ the Transactions module is included into
-    # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
-    def save_has_one_association(reflection)
-      association = association_instance_get(reflection.name)
-      record      = association && association.load_target
-      if record && !record.destroyed?
-        autosave = reflection.options[:autosave]
-
-        if autosave && record.marked_for_destruction?
-          record.destroy
-        elsif autosave != false
-          key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
-
-          if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
-            unless reflection.through_reflection
-              record[reflection.foreign_key] = key
-            end
+      # Saves the associated record if it's new or <tt>:autosave</tt> is enabled
+      # on the association.
+      #
+      # In addition, it will destroy the association if it was marked for
+      # destruction with mark_for_destruction.
+      #
+      # This all happens inside a transaction, _if_ the Transactions module is included into
+      # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
+      def save_has_one_association(reflection)
+        association = association_instance_get(reflection.name)
+        record      = association && association.load_target
+        if record && !record.destroyed?
+          autosave = reflection.options[:autosave]
 
-            saved = record.save(:validate => !autosave)
-            raise ActiveRecord::Rollback if !saved && autosave
-            saved
+          if autosave && record.marked_for_destruction?
+            record.destroy
+          else
+            key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
+            if autosave != false && (autosave || new_record? || record_changed?(reflection, record, key))
+
+              unless reflection.through_reflection
+                record[reflection.foreign_key] = key
+              end
+
+              saved = record.save(:validate => !autosave)
+              raise ActiveRecord::Rollback if !saved && autosave
+              saved
+            end
           end
         end
       end
-    end
 
-    # If the record is new or it has changed, returns true.
-    def record_changed?(reflection, record, key)
-      record.new_record? || record[reflection.foreign_key] != key || record.changed_attributes.include?(reflection.foreign_key)
-    end
+      # If the record is new or it has changed, returns true.
+      def record_changed?(reflection, record, key)
+        record.new_record? || record[reflection.foreign_key] != key || record.attribute_changed?(reflection.foreign_key)
+      end
 
-    # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
-    #
-    # In addition, it will destroy the association if it was marked for destruction.
-    def save_belongs_to_association(reflection)
-      association = association_instance_get(reflection.name)
-      record      = association && association.load_target
-      if record && !record.destroyed?
-        autosave = reflection.options[:autosave]
-
-        if autosave && record.marked_for_destruction?
-          self[reflection.foreign_key] = nil
-          record.destroy
-        elsif autosave != false
-          saved = record.save(:validate => !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
-
-          if association.updated?
-            association_id = record.send(reflection.options[:primary_key] || :id)
-            self[reflection.foreign_key] = association_id
-            association.loaded!
-          end
+      # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
+      #
+      # In addition, it will destroy the association if it was marked for destruction.
+      def save_belongs_to_association(reflection)
+        association = association_instance_get(reflection.name)
+        record      = association && association.load_target
+        if record && !record.destroyed?
+          autosave = reflection.options[:autosave]
+
+          if autosave && record.marked_for_destruction?
+            self[reflection.foreign_key] = nil
+            record.destroy
+          elsif autosave != false
+            saved = record.save(:validate => !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
+
+            if association.updated?
+              association_id = record.send(reflection.options[:primary_key] || :id)
+              self[reflection.foreign_key] = association_id
+              association.loaded!
+            end
 
-          saved if autosave
+            saved if autosave
+          end
         end
       end
-    end
   end
 end