activerecord 5.0.7.2 → 5.1.0.beta1

data/lib/active_record/attribute/user_provided_default.rb

@@ -1,4 +1,4 @@
-require 'active_record/attribute'
+require "active_record/attribute"
 
 module ActiveRecord
   class Attribute # :nodoc:
@@ -20,9 +20,11 @@ module ActiveRecord
         self.class.new(name, user_provided_value, type, original_attribute)
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :user_provided_value
+        attr_reader :user_provided_value
     end
   end
 end

data/lib/active_record/attribute_assignment.rb

@@ -1,4 +1,4 @@
-require 'active_model/forbidden_attributes_protection'
+require "active_model/forbidden_attributes_protection"
 
 module ActiveRecord
   module AttributeAssignment
@@ -12,80 +12,80 @@ module ActiveRecord
 
     private
 
-    def _assign_attributes(attributes) # :nodoc:
-      multi_parameter_attributes  = {}
-      nested_parameter_attributes = {}
+      def _assign_attributes(attributes)
+        multi_parameter_attributes  = {}
+        nested_parameter_attributes = {}
 
-      attributes.each do |k, v|
-        if k.include?("(")
-          multi_parameter_attributes[k] = attributes.delete(k)
-        elsif v.is_a?(Hash)
-          nested_parameter_attributes[k] = attributes.delete(k)
+        attributes.each do |k, v|
+          if k.include?("(")
+            multi_parameter_attributes[k] = attributes.delete(k)
+          elsif v.is_a?(Hash)
+            nested_parameter_attributes[k] = attributes.delete(k)
+          end
         end
-      end
-      super(attributes)
+        super(attributes)
 
-      assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
-      assign_multiparameter_attributes(multi_parameter_attributes) unless multi_parameter_attributes.empty?
-    end
+        assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
+        assign_multiparameter_attributes(multi_parameter_attributes) unless multi_parameter_attributes.empty?
+      end
 
-    # Assign any deferred nested attributes after the base attributes have been set.
-    def assign_nested_parameter_attributes(pairs)
-      pairs.each { |k, v| _assign_attribute(k, v) }
-    end
+      # Assign any deferred nested attributes after the base attributes have been set.
+      def assign_nested_parameter_attributes(pairs)
+        pairs.each { |k, v| _assign_attribute(k, v) }
+      end
 
-    # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
-    # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
-    # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
-    # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
-    # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Integer and
-    # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
-    def assign_multiparameter_attributes(pairs)
-      execute_callstack_for_multiparameter_attributes(
-        extract_callstack_for_multiparameter_attributes(pairs)
-      )
-    end
+      # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
+      # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
+      # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
+      # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
+      # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Integer and
+      # f for Float. If all the values for a given attribute are empty, the attribute will be set to +nil+.
+      def assign_multiparameter_attributes(pairs)
+        execute_callstack_for_multiparameter_attributes(
+          extract_callstack_for_multiparameter_attributes(pairs)
+        )
+      end
 
-    def execute_callstack_for_multiparameter_attributes(callstack)
-      errors = []
-      callstack.each do |name, values_with_empty_parameters|
-        begin
-          if values_with_empty_parameters.each_value.all?(&:nil?)
-            values = nil
-          else
-            values = values_with_empty_parameters
+      def execute_callstack_for_multiparameter_attributes(callstack)
+        errors = []
+        callstack.each do |name, values_with_empty_parameters|
+          begin
+            if values_with_empty_parameters.each_value.all?(&:nil?)
+              values = nil
+            else
+              values = values_with_empty_parameters
+            end
+            send("#{name}=", values)
+          rescue => ex
+            errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
           end
-          send("#{name}=", values)
-        rescue => ex
-          errors << AttributeAssignmentError.new("error on assignment #{values_with_empty_parameters.values.inspect} to #{name} (#{ex.message})", ex, name)
+        end
+        unless errors.empty?
+          error_descriptions = errors.map(&:message).join(",")
+          raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
         end
       end
-      unless errors.empty?
-        error_descriptions = errors.map(&:message).join(",")
-        raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes [#{error_descriptions}]"
-      end
-    end
 
-    def extract_callstack_for_multiparameter_attributes(pairs)
-      attributes = {}
+      def extract_callstack_for_multiparameter_attributes(pairs)
+        attributes = {}
 
-      pairs.each do |(multiparameter_name, value)|
-        attribute_name = multiparameter_name.split("(").first
-        attributes[attribute_name] ||= {}
+        pairs.each do |(multiparameter_name, value)|
+          attribute_name = multiparameter_name.split("(").first
+          attributes[attribute_name] ||= {}
 
-        parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
-        attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
-      end
+          parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
+          attributes[attribute_name][find_parameter_position(multiparameter_name)] ||= parameter_value
+        end
 
-      attributes
-    end
+        attributes
+      end
 
-    def type_cast_attribute_value(multiparameter_name, value)
-      multiparameter_name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
-    end
+      def type_cast_attribute_value(multiparameter_name, value)
+        multiparameter_name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
+      end
 
-    def find_parameter_position(multiparameter_name)
-      multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
-    end
+      def find_parameter_position(multiparameter_name)
+        multiparameter_name.scan(/\(([0-9]*).*\)/).first.first.to_i
+      end
   end
 end

data/lib/active_record/attribute_decorators.rb

@@ -8,12 +8,34 @@ module ActiveRecord
     end
 
     module ClassMethods # :nodoc:
+      # This method is an internal API used to create class macros such as
+      # +serialize+, and features like time zone aware attributes.
+      #
+      # Used to wrap the type of an attribute in a new type.
+      # When the schema for a model is loaded, attributes with the same name as
+      # +column_name+ will have their type yielded to the given block. The
+      # return value of that block will be used instead.
+      #
+      # Subsequent calls where +column_name+ and +decorator_name+ are the same
+      # will override the previous decorator, not decorate twice. This can be
+      # used to create idempotent class macros like +serialize+
       def decorate_attribute_type(column_name, decorator_name, &block)
         matcher = ->(name, _) { name == column_name.to_s }
         key = "_#{column_name}_#{decorator_name}"
         decorate_matching_attribute_types(matcher, key, &block)
       end
 
+      # This method is an internal API used to create higher level features like
+      # time zone aware attributes.
+      #
+      # When the schema for a model is loaded, +matcher+ will be called for each
+      # attribute with its name and type. If the matcher returns a truthy value,
+      # the type will then be yielded to the given block, and the return value
+      # of that block will replace the type.
+      #
+      # Subsequent calls to this method with the same value for +decorator_name+
+      # will replace the previous decorator, not decorate twice. This can be
+      # used to ensure that class macros are idempotent.
       def decorate_matching_attribute_types(matcher, decorator_name, &block)
         reload_schema_from_cache
         decorator_name = decorator_name.to_s
@@ -24,13 +46,13 @@ module ActiveRecord
 
       private
 
-      def load_schema!
-        super
-        attribute_types.each do |name, type|
-          decorated_type = attribute_type_decorations.apply(name, type)
-          define_attribute(name, decorated_type)
+        def load_schema!
+          super
+          attribute_types.each do |name, type|
+            decorated_type = attribute_type_decorations.apply(name, type)
+            define_attribute(name, decorated_type)
+          end
         end
-      end
     end
 
     class TypeDecorator # :nodoc:
@@ -53,15 +75,15 @@ module ActiveRecord
 
       private
 
-      def decorators_for(name, type)
-        matching(name, type).map(&:last)
-      end
+        def decorators_for(name, type)
+          matching(name, type).map(&:last)
+        end
 
-      def matching(name, type)
-        @decorations.values.select do |(matcher, _)|
-          matcher.call(name, type)
+        def matching(name, type)
+          @decorations.values.select do |(matcher, _)|
+            matcher.call(name, type)
+          end
         end
-      end
     end
   end
 end

data/lib/active_record/attribute_methods.rb

@@ -1,7 +1,7 @@
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/string/filters'
-require 'mutex_m'
-require 'concurrent/map'
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/string/filters"
+require "mutex_m"
+require "concurrent/map"
 
 module ActiveRecord
   # = Active Record Attribute Methods
@@ -148,7 +148,7 @@ module ActiveRecord
       #   Person.attribute_method?(:age=)    # => true
       #   Person.attribute_method?(:nothing) # => false
       def attribute_method?(attribute)
-        super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, '')))
+        super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, "")))
       end
 
       # Returns an array of column names as strings if it's not an abstract class and
@@ -161,10 +161,10 @@ module ActiveRecord
       #   # => ["id", "created_at", "updated_at", "name", "age"]
       def attribute_names
         @attribute_names ||= if !abstract_class? && table_exists?
-            attribute_types.keys
-          else
-            []
-          end
+          attribute_types.keys
+        else
+          []
+        end
       end
 
       # Returns true if the given attribute exists, otherwise false.
@@ -209,13 +209,13 @@ module ActiveRecord
     #   end
     #
     #   person = Person.new
-    #   person.respond_to(:name)    # => true
-    #   person.respond_to(:name=)   # => true
-    #   person.respond_to(:name?)   # => true
-    #   person.respond_to('age')    # => true
-    #   person.respond_to('age=')   # => true
-    #   person.respond_to('age?')   # => true
-    #   person.respond_to(:nothing) # => false
+    #   person.respond_to?(:name)    # => true
+    #   person.respond_to?(:name=)   # => true
+    #   person.respond_to?(:name?)   # => true
+    #   person.respond_to?('age')    # => true
+    #   person.respond_to?('age=')   # => true
+    #   person.respond_to?('age?')   # => true
+    #   person.respond_to?(:nothing) # => false
     def respond_to?(name, include_private = false)
       return false unless super
 
@@ -330,8 +330,6 @@ module ActiveRecord
     #
     # Note: +:id+ is always present.
     #
-    # Alias for the #read_attribute method.
-    #
     #   class Person < ActiveRecord::Base
     #     belongs_to :organization
     #   end
@@ -396,65 +394,58 @@ module ActiveRecord
 
     protected
 
-    def clone_attribute_value(reader_method, attribute_name) # :nodoc:
-      value = send(reader_method, attribute_name)
-      value.duplicable? ? value.clone : value
-    rescue TypeError, NoMethodError
-      value
-    end
-
-    def arel_attributes_with_values_for_create(attribute_names) # :nodoc:
-      arel_attributes_with_values(attributes_for_create(attribute_names))
-    end
+      def attribute_method?(attr_name) # :nodoc:
+        # We check defined? because Syck calls respond_to? before actually calling initialize.
+        defined?(@attributes) && @attributes.key?(attr_name)
+      end
 
-    def arel_attributes_with_values_for_update(attribute_names) # :nodoc:
-      arel_attributes_with_values(attributes_for_update(attribute_names))
-    end
+    private
 
-    def attribute_method?(attr_name) # :nodoc:
-      # We check defined? because Syck calls respond_to? before actually calling initialize.
-      defined?(@attributes) && @attributes.key?(attr_name)
-    end
+      def arel_attributes_with_values_for_create(attribute_names)
+        arel_attributes_with_values(attributes_for_create(attribute_names))
+      end
 
-    private
+      def arel_attributes_with_values_for_update(attribute_names)
+        arel_attributes_with_values(attributes_for_update(attribute_names))
+      end
 
-    # Returns a Hash of the Arel::Attributes and attribute values that have been
-    # typecasted for use in an Arel insert/update method.
-    def arel_attributes_with_values(attribute_names)
-      attrs = {}
-      arel_table = self.class.arel_table
+      # Returns a Hash of the Arel::Attributes and attribute values that have been
+      # typecasted for use in an Arel insert/update method.
+      def arel_attributes_with_values(attribute_names)
+        attrs = {}
+        arel_table = self.class.arel_table
 
-      attribute_names.each do |name|
-        attrs[arel_table[name]] = typecasted_attribute_value(name)
+        attribute_names.each do |name|
+          attrs[arel_table[name]] = typecasted_attribute_value(name)
+        end
+        attrs
       end
-      attrs
-    end
 
-    # Filters the primary keys and readonly attributes from the attribute names.
-    def attributes_for_update(attribute_names)
-      attribute_names.reject do |name|
-        readonly_attribute?(name)
+      # Filters the primary keys and readonly attributes from the attribute names.
+      def attributes_for_update(attribute_names)
+        attribute_names.reject do |name|
+          readonly_attribute?(name)
+        end
       end
-    end
 
-    # Filters out the primary keys, from the attribute names, when the primary
-    # key is to be generated (e.g. the id attribute has no value).
-    def attributes_for_create(attribute_names)
-      attribute_names.reject do |name|
-        pk_attribute?(name) && id.nil?
+      # Filters out the primary keys, from the attribute names, when the primary
+      # key is to be generated (e.g. the id attribute has no value).
+      def attributes_for_create(attribute_names)
+        attribute_names.reject do |name|
+          pk_attribute?(name) && id.nil?
+        end
       end
-    end
 
-    def readonly_attribute?(name)
-      self.class.readonly_attributes.include?(name)
-    end
+      def readonly_attribute?(name)
+        self.class.readonly_attributes.include?(name)
+      end
 
-    def pk_attribute?(name)
-      name == self.class.primary_key
-    end
+      def pk_attribute?(name)
+        name == self.class.primary_key
+      end
 
-    def typecasted_attribute_value(name)
-      _read_attribute(name)
-    end
+      def typecasted_attribute_value(name)
+        _read_attribute(name)
+      end
   end
 end

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -63,14 +63,14 @@ module ActiveRecord
 
       private
 
-      # Handle *_before_type_cast for method_missing.
-      def attribute_before_type_cast(attribute_name)
-        read_attribute_before_type_cast(attribute_name)
-      end
+        # Handle *_before_type_cast for method_missing.
+        def attribute_before_type_cast(attribute_name)
+          read_attribute_before_type_cast(attribute_name)
+        end
 
-      def attribute_came_from_user?(attribute_name)
-        @attributes[attribute_name].came_from_user?
-      end
+        def attribute_came_from_user?(attribute_name)
+          @attributes[attribute_name].came_from_user?
+        end
     end
   end
 end

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,5 +1,6 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_record/attribute_mutation_tracker'
+# frozen_string_literal: true
+require "active_support/core_ext/module/attribute_accessors"
+require "active_record/attribute_mutation_tracker"
 
 module ActiveRecord
   module AttributeMethods
@@ -15,6 +16,18 @@ module ActiveRecord
 
         class_attribute :partial_writes, instance_writer: false
         self.partial_writes = true
+
+        after_create { changes_internally_applied }
+        after_update { changes_internally_applied }
+
+        # Attribute methods for "changed in last call to save?"
+        attribute_method_affix(prefix: "saved_change_to_", suffix: "?")
+        attribute_method_prefix("saved_change_to_")
+        attribute_method_suffix("_before_last_save")
+
+        # Attribute methods for "will change if I call save?"
+        attribute_method_affix(prefix: "will_save_change_to_", suffix: "?")
+        attribute_method_suffix("_change_to_be_saved", "_in_database")
       end
 
       # Attempts to +save+ the record and clears changed attributes if successful.
@@ -35,8 +48,8 @@ module ActiveRecord
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          @mutation_tracker = nil
           @previous_mutation_tracker = nil
+          clear_mutation_trackers
           @changed_attributes = HashWithIndifferentAccess.new
         end
       end
@@ -46,19 +59,26 @@ module ActiveRecord
         @attributes = self.class._default_attributes.map do |attr|
           attr.with_value_from_user(@attributes.fetch_value(attr.name))
         end
-        @mutation_tracker = nil
+        clear_mutation_trackers
+      end
+
+      def changes_internally_applied # :nodoc:
+        @mutations_before_last_save = mutation_tracker
+        forget_attribute_assignments
+        @mutations_from_database = AttributeMutationTracker.new(@attributes)
       end
 
       def changes_applied
         @previous_mutation_tracker = mutation_tracker
         @changed_attributes = HashWithIndifferentAccess.new
-        store_original_attributes
+        clear_mutation_trackers
       end
 
       def clear_changes_information
         @previous_mutation_tracker = nil
         @changed_attributes = HashWithIndifferentAccess.new
-        store_original_attributes
+        forget_attribute_assignments
+        clear_mutation_trackers
       end
 
       def raw_write_attribute(attr_name, *)
@@ -80,17 +100,27 @@ module ActiveRecord
         if defined?(@cached_changed_attributes)
           @cached_changed_attributes
         else
+          emit_warning_if_needed("changed_attributes", "saved_changes.transform_values(&:first)")
           super.reverse_merge(mutation_tracker.changed_values).freeze
         end
       end
 
       def changes
         cache_changed_attributes do
+          emit_warning_if_needed("changes", "saved_changes")
           super
         end
       end
 
       def previous_changes
+        unless previous_mutation_tracker.equal?(mutations_before_last_save)
+          ActiveSupport::Deprecation.warn(<<-EOW.strip_heredoc)
+            The behavior of `previous_changes` inside of after callbacks is
+            deprecated without replacement. In the next release of Rails,
+            this method inside of `after_save` will return the changes that
+            were just saved.
+          EOW
+        end
         previous_mutation_tracker.changes
       end
 
@@ -98,54 +128,206 @@ module ActiveRecord
         mutation_tracker.changed_in_place?(attr_name)
       end
 
-      private
+      # Did this attribute change when we last saved? This method can be invoked
+      # as `saved_change_to_name?` instead of `saved_change_to_attribute?("name")`.
+      # Behaves similarly to +attribute_changed?+. This method is useful in
+      # after callbacks to determine if the call to save changed a certain
+      # attribute.
+      #
+      # ==== Options
+      #
+      # +from+ When passed, this method will return false unless the original
+      # value is equal to the given option
+      #
+      # +to+ When passed, this method will return false unless the value was
+      # changed to the given value
+      def saved_change_to_attribute?(attr_name, **options)
+        mutations_before_last_save.changed?(attr_name, **options)
+      end
 
-      def mutation_tracker
-        unless defined?(@mutation_tracker)
-          @mutation_tracker = nil
-        end
-        @mutation_tracker ||= AttributeMutationTracker.new(@attributes)
+      # Returns the change to an attribute during the last save. If the
+      # attribute was changed, the result will be an array containing the
+      # original value and the saved value.
+      #
+      # Behaves similarly to +attribute_change+. This method is useful in after
+      # callbacks, to see the change in an attribute that just occurred
+      #
+      # This method can be invoked as `saved_change_to_name` in instead of
+      # `saved_change_to_attribute("name")`
+      def saved_change_to_attribute(attr_name)
+        mutations_before_last_save.change_to_attribute(attr_name)
+      end
+
+      # Returns the original value of an attribute before the last save.
+      # Behaves similarly to +attribute_was+. This method is useful in after
+      # callbacks to get the original value of an attribute before the save that
+      # just occurred
+      def attribute_before_last_save(attr_name)
+        mutations_before_last_save.original_value(attr_name)
+      end
+
+      # Did the last call to `save` have any changes to change?
+      def saved_changes?
+        mutations_before_last_save.any_changes?
       end
 
-      def changes_include?(attr_name)
-        super || mutation_tracker.changed?(attr_name)
+      # Returns a hash containing all the changes that were just saved.
+      def saved_changes
+        mutations_before_last_save.changes
       end
 
-      def clear_attribute_change(attr_name)
-        mutation_tracker.forget_change(attr_name)
+      # Alias for `attribute_changed?`
+      def will_save_change_to_attribute?(attr_name, **options)
+        mutations_from_database.changed?(attr_name, **options)
       end
 
-      def _update_record(*)
-        partial_writes? ? super(keys_for_partial_write) : super
+      # Alias for `attribute_change`
+      def attribute_change_to_be_saved(attr_name)
+        mutations_from_database.change_to_attribute(attr_name)
       end
 
-      def _create_record(*)
-        partial_writes? ? super(keys_for_partial_write) : super
+      # Alias for `attribute_was`
+      def attribute_in_database(attr_name)
+        mutations_from_database.original_value(attr_name)
       end
 
-      def keys_for_partial_write
-        changed & self.class.column_names
+      # Alias for `changed?`
+      def has_changes_to_save?
+        mutations_from_database.any_changes?
       end
 
-      def store_original_attributes
-        @attributes = @attributes.map(&:forgetting_assignment)
-        @mutation_tracker = nil
+      # Alias for `changes`
+      def changes_to_save
+        mutations_from_database.changes
       end
 
-      def previous_mutation_tracker
-        @previous_mutation_tracker ||= NullMutationTracker.instance
+      # Alias for `changed`
+      def changed_attribute_names_to_save
+        changes_to_save.keys
       end
 
-      def cache_changed_attributes
-        @cached_changed_attributes = changed_attributes
-        yield
-      ensure
-        clear_changed_attributes_cache
+      # Alias for `changed_attributes`
+      def attributes_in_database
+        changes_to_save.transform_values(&:first)
       end
 
-      def clear_changed_attributes_cache
-        remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
+      def attribute_was(*)
+        emit_warning_if_needed("attribute_was", "attribute_before_last_save")
+        super
       end
+
+      def attribute_change(*)
+        emit_warning_if_needed("attribute_change", "saved_change_to_attribute")
+        super
+      end
+
+      def attribute_changed?(*)
+        emit_warning_if_needed("attribute_changed?", "saved_change_to_attribute?")
+        super
+      end
+
+      def changed?(*)
+        emit_warning_if_needed("changed?", "saved_changes?")
+        super
+      end
+
+      def changed(*)
+        emit_warning_if_needed("changed", "saved_changes.keys")
+        super
+      end
+
+      private
+
+        def mutation_tracker
+          unless defined?(@mutation_tracker)
+            @mutation_tracker = nil
+          end
+          @mutation_tracker ||= AttributeMutationTracker.new(@attributes)
+        end
+
+        def emit_warning_if_needed(method_name, new_method_name)
+          unless mutation_tracker.equal?(mutations_from_database)
+            ActiveSupport::Deprecation.warn(<<-EOW.squish)
+              The behavior of `#{method_name}` inside of after callbacks will
+              be changing in the next version of Rails. The new return value will reflect the
+              behavior of calling the method after `save` returned (e.g. the opposite of what
+              it returns now). To maintain the current behavior, use `#{new_method_name}`
+              instead.
+            EOW
+          end
+        end
+
+        def mutations_from_database
+          unless defined?(@mutations_from_database)
+            @mutations_from_database = nil
+          end
+          @mutations_from_database ||= mutation_tracker
+        end
+
+        def changes_include?(attr_name)
+          super || mutation_tracker.changed?(attr_name)
+        end
+
+        def clear_attribute_change(attr_name)
+          mutation_tracker.forget_change(attr_name)
+          mutations_from_database.forget_change(attr_name)
+        end
+
+        def attribute_will_change!(attr_name)
+          super
+          if self.class.has_attribute?(attr_name)
+            mutations_from_database.force_change(attr_name)
+          else
+            ActiveSupport::Deprecation.warn(<<-EOW.squish)
+              #{attr_name} is not an attribute known to Active Record.
+              This behavior is deprecated and will be removed in the next
+              version of Rails. If you'd like #{attr_name} to be managed
+              by Active Record, add `attribute :#{attr_name} to your class.
+            EOW
+            mutations_from_database.deprecated_force_change(attr_name)
+          end
+        end
+
+        def _update_record(*)
+          partial_writes? ? super(keys_for_partial_write) : super
+        end
+
+        def _create_record(*)
+          partial_writes? ? super(keys_for_partial_write) : super
+        end
+
+        def keys_for_partial_write
+          changed_attribute_names_to_save & self.class.column_names
+        end
+
+        def forget_attribute_assignments
+          @attributes = @attributes.map(&:forgetting_assignment)
+        end
+
+        def clear_mutation_trackers
+          @mutation_tracker = nil
+          @mutations_from_database = nil
+          @mutations_before_last_save = nil
+        end
+
+        def previous_mutation_tracker
+          @previous_mutation_tracker ||= NullMutationTracker.instance
+        end
+
+        def mutations_before_last_save
+          @mutations_before_last_save ||= previous_mutation_tracker
+        end
+
+        def cache_changed_attributes
+          @cached_changed_attributes = changed_attributes
+          yield
+        ensure
+          clear_changed_attributes_cache
+        end
+
+        def clear_changed_attributes_cache
+          remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
+        end
     end
   end
 end