activerecord 5.0.7 → 5.1.7

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,9 +1,10 @@
-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
-    module Dirty # :nodoc:
+    module Dirty
       extend ActiveSupport::Concern
 
       include ActiveModel::Dirty
@@ -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,9 +48,9 @@ module ActiveRecord
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          @mutation_tracker = nil
           @previous_mutation_tracker = nil
-          @changed_attributes = HashWithIndifferentAccess.new
+          clear_mutation_trackers
+          @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
         end
       end
 
@@ -46,106 +59,276 @@ 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_applied
+      def changes_internally_applied # :nodoc:
+        @mutations_before_last_save = mutations_from_database
+        forget_attribute_assignments
+        @mutations_from_database = AttributeMutationTracker.new(@attributes)
+      end
+
+      def changes_applied # :nodoc:
         @previous_mutation_tracker = mutation_tracker
-        @changed_attributes = HashWithIndifferentAccess.new
-        store_original_attributes
+        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+        @mutation_tracker = nil
+        @mutations_from_database = nil
       end
 
-      def clear_changes_information
+      def clear_changes_information # :nodoc:
         @previous_mutation_tracker = nil
-        @changed_attributes = HashWithIndifferentAccess.new
-        store_original_attributes
+        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+        forget_attribute_assignments
+        clear_mutation_trackers
       end
 
-      def raw_write_attribute(attr_name, *)
+      def raw_write_attribute(attr_name, *) # :nodoc:
         result = super
         clear_attribute_change(attr_name)
         result
       end
 
-      def clear_attribute_changes(attr_names)
+      def clear_attribute_changes(attr_names) # :nodoc:
         super
         attr_names.each do |attr_name|
           clear_attribute_change(attr_name)
         end
       end
 
-      def changed_attributes
+      def changed_attributes # :nodoc:
         # This should only be set by methods which will call changed_attributes
         # multiple times when it is known that the computed value cannot change.
         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
+      def changes # :nodoc:
         cache_changed_attributes do
+          emit_warning_if_needed("changes", "saved_changes")
           super
         end
       end
 
-      def previous_changes
+      def previous_changes # :nodoc:
+        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
 
-      def attribute_changed_in_place?(attr_name)
+      def attribute_changed_in_place?(attr_name) # :nodoc:
         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
 
-      def changes_include?(attr_name)
-        super || mutation_tracker.changed?(attr_name)
+      # 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
 
-      def clear_attribute_change(attr_name)
-        mutation_tracker.forget_change(attr_name)
+      # Did the last call to `save` have any changes to change?
+      def saved_changes?
+        mutations_before_last_save.any_changes?
       end
 
-      def _update_record(*)
-        partial_writes? ? super(keys_for_partial_write) : super
+      # Returns a hash containing all the changes that were just saved.
+      def saved_changes
+        mutations_before_last_save.changes
       end
 
-      def _create_record(*)
-        partial_writes? ? super(keys_for_partial_write) : super
+      # Alias for `attribute_changed?`
+      def will_save_change_to_attribute?(attr_name, **options)
+        mutations_from_database.changed?(attr_name, **options)
       end
 
-      def keys_for_partial_write
-        changed & self.class.column_names
+      # Alias for `attribute_change`
+      def attribute_change_to_be_saved(attr_name)
+        mutations_from_database.change_to_attribute(attr_name)
       end
 
-      def store_original_attributes
-        @attributes = @attributes.map(&:forgetting_assignment)
-        @mutation_tracker = nil
+      # Alias for `attribute_was`
+      def attribute_in_database(attr_name)
+        mutations_from_database.original_value(attr_name)
+      end
+
+      # Alias for `changed?`
+      def has_changes_to_save?
+        mutations_from_database.any_changes?
       end
 
-      def previous_mutation_tracker
-        @previous_mutation_tracker ||= NullMutationTracker.instance
+      # Alias for `changes`
+      def changes_to_save
+        mutations_from_database.changes
       end
 
-      def cache_changed_attributes
-        @cached_changed_attributes = changed_attributes
-        yield
-      ensure
-        clear_changed_attributes_cache
+      # Alias for `changed`
+      def changed_attribute_names_to_save
+        mutations_from_database.changed_attribute_names
       end
 
-      def clear_changed_attributes_cache
-        remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
+      # Alias for `changed_attributes`
+      def attributes_in_database
+        mutations_from_database.changed_values
       end
+
+      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

data/lib/active_record/attribute_methods/primary_key.rb

@@ -1,4 +1,4 @@
-require 'set'
+require "set"
 
 module ActiveRecord
   module AttributeMethods
@@ -9,7 +9,7 @@ module ActiveRecord
       # available.
       def to_key
         sync_with_transaction_state
-        key = self.id
+        key = id
         [key] if key
       end
 
@@ -45,97 +45,98 @@ module ActiveRecord
         attribute_was(self.class.primary_key)
       end
 
-      protected
-
-      def attribute_method?(attr_name)
-        attr_name == 'id' || super
+      def id_in_database
+        sync_with_transaction_state
+        attribute_in_database(self.class.primary_key)
       end
 
-      module ClassMethods
-        def define_method_attribute(attr_name)
-          super
+      private
 
-          if attr_name == primary_key && attr_name != 'id'
-            generated_attribute_methods.send(:alias_method, :id, primary_key)
-          end
+        def attribute_method?(attr_name)
+          attr_name == "id" || super
         end
 
-        ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was).to_set
+        module ClassMethods
+          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database).to_set
 
-        def dangerous_attribute_method?(method_name)
-          super && !ID_ATTRIBUTE_METHODS.include?(method_name)
-        end
+          def instance_method_already_implemented?(method_name)
+            super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)
+          end
 
-        # Defines the primary key field -- can be overridden in subclasses.
-        # Overwriting will negate any effect of the +primary_key_prefix_type+
-        # setting, though.
-        def primary_key
-          @primary_key = reset_primary_key unless defined? @primary_key
-          @primary_key
-        end
+          def dangerous_attribute_method?(method_name)
+            super && !ID_ATTRIBUTE_METHODS.include?(method_name)
+          end
 
-        # Returns a quoted version of the primary key name, used to construct
-        # SQL statements.
-        def quoted_primary_key
-          @quoted_primary_key ||= connection.quote_column_name(primary_key)
-        end
+          # Defines the primary key field -- can be overridden in subclasses.
+          # Overwriting will negate any effect of the +primary_key_prefix_type+
+          # setting, though.
+          def primary_key
+            @primary_key = reset_primary_key unless defined? @primary_key
+            @primary_key
+          end
 
-        def reset_primary_key #:nodoc:
-          if self == base_class
-            self.primary_key = get_primary_key(base_class.name)
-          else
-            self.primary_key = base_class.primary_key
+          # Returns a quoted version of the primary key name, used to construct
+          # SQL statements.
+          def quoted_primary_key
+            @quoted_primary_key ||= connection.quote_column_name(primary_key)
           end
-        end
 
-        def get_primary_key(base_name) #:nodoc:
-          if base_name && primary_key_prefix_type == :table_name
-            base_name.foreign_key(false)
-          elsif base_name && primary_key_prefix_type == :table_name_with_underscore
-            base_name.foreign_key
-          else
-            if ActiveRecord::Base != self && table_exists?
-              pk = connection.schema_cache.primary_keys(table_name)
-              suppress_composite_primary_key(pk)
+          def reset_primary_key #:nodoc:
+            if self == base_class
+              self.primary_key = get_primary_key(base_class.name)
             else
-              'id'
+              self.primary_key = base_class.primary_key
             end
           end
-        end
 
-        # Sets the name of the primary key column.
-        #
-        #   class Project < ActiveRecord::Base
-        #     self.primary_key = 'sysid'
-        #   end
-        #
-        # You can also define the #primary_key method yourself:
-        #
-        #   class Project < ActiveRecord::Base
-        #     def self.primary_key
-        #       'foo_' + super
-        #     end
-        #   end
-        #
-        #   Project.primary_key # => "foo_id"
-        def primary_key=(value)
-          @primary_key        = value && value.to_s
-          @quoted_primary_key = nil
-          @attributes_builder = nil
-        end
+          def get_primary_key(base_name) #:nodoc:
+            if base_name && primary_key_prefix_type == :table_name
+              base_name.foreign_key(false)
+            elsif base_name && primary_key_prefix_type == :table_name_with_underscore
+              base_name.foreign_key
+            else
+              if ActiveRecord::Base != self && table_exists?
+                pk = connection.schema_cache.primary_keys(table_name)
+                suppress_composite_primary_key(pk)
+              else
+                "id"
+              end
+            end
+          end
 
-        private
+          # Sets the name of the primary key column.
+          #
+          #   class Project < ActiveRecord::Base
+          #     self.primary_key = 'sysid'
+          #   end
+          #
+          # You can also define the #primary_key method yourself:
+          #
+          #   class Project < ActiveRecord::Base
+          #     def self.primary_key
+          #       'foo_' + super
+          #     end
+          #   end
+          #
+          #   Project.primary_key # => "foo_id"
+          def primary_key=(value)
+            @primary_key        = value && value.to_s
+            @quoted_primary_key = nil
+            @attributes_builder = nil
+          end
+
+          private
 
-        def suppress_composite_primary_key(pk)
-          return pk unless pk.is_a?(Array)
+            def suppress_composite_primary_key(pk)
+              return pk unless pk.is_a?(Array)
 
-          warn <<-WARNING.strip_heredoc
-            WARNING: Active Record does not support composite primary key.
+              warn <<-WARNING.strip_heredoc
+                WARNING: Active Record does not support composite primary key.
 
-            #{table_name} has composite primary key. Composite primary key is ignored.
-          WARNING
+                #{table_name} has composite primary key. Composite primary key is ignored.
+              WARNING
+            end
         end
-      end
     end
   end
 end

data/lib/active_record/attribute_methods/read.rb

@@ -4,51 +4,56 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       module ClassMethods
-        protected
+        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 in read_attribute.
-        def define_method_attribute(name)
-          safe_name = name.unpack('h*'.freeze).first
-          temp_method = "__temp__#{safe_name}"
+          # 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 in read_attribute.
+          def define_method_attribute(name)
+            safe_name = name.unpack("h*".freeze).first
+            temp_method = "__temp__#{safe_name}"
 
-          ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, 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 <<-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
+            generated_attribute_methods.module_eval do
+              alias_method name, temp_method
+              undef_method temp_method
+            end
           end
-        end
       end
 
       # Returns the value of the attribute identified by <tt>attr_name</tt> after
       # it has been typecast (for example, "2004-12-12" in a date column is cast
       # to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name, &block)
-        name = attr_name.to_s
+        name = if self.class.attribute_alias?(attr_name)
+          self.class.attribute_alias(attr_name).to_s
+        else
+          attr_name.to_s
+        end
+
         name = self.class.primary_key if name == "id".freeze && self.class.primary_key
         _read_attribute(name, &block)
       end
@@ -69,7 +74,6 @@ module ActiveRecord
 
       alias :attribute :_read_attribute
       private :attribute
-
     end
   end
 end

data/lib/active_record/attribute_methods/serialization.rb

@@ -26,7 +26,7 @@ module ActiveRecord
         # ==== Parameters
         #
         # * +attr_name+ - The field name that should be serialized.
-        # * +class_name_or_coder+ - Optional, a coder object, which responds to `.load` / `.dump`
+        # * +class_name_or_coder+ - Optional, a coder object, which responds to +.load+ and +.dump+
         #   or a class name that the object type should be equal to.
         #
         # ==== Example
@@ -50,12 +50,12 @@ module ActiveRecord
           # to ensure special objects (e.g. Active Record models) are dumped correctly
           # using the #as_json hook.
           coder = if class_name_or_coder == ::JSON
-                    Coders::JSON
-                  elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
-                    class_name_or_coder
-                  else
-                    Coders::YAMLColumn.new(class_name_or_coder)
-                  end
+            Coders::JSON
+          elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+            class_name_or_coder
+          else
+            Coders::YAMLColumn.new(attr_name, class_name_or_coder)
+          end
 
           decorate_attribute_type(attr_name, :serialize) do |type|
             Type::Serialized.new(type, coder)