activerecord 4.2.11.1 → 6.0.3.5

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,8 +1,10 @@
-require 'active_support/core_ext/module/attribute_accessors'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
 
 module ActiveRecord
   module AttributeMethods
-    module Dirty # :nodoc:
+    module Dirty
       extend ActiveSupport::Concern
 
       include ActiveModel::Dirty
@@ -12,180 +14,208 @@ module ActiveRecord
           raise "You cannot include Dirty after Timestamp"
         end
 
-        class_attribute :partial_writes, instance_writer: false
-        self.partial_writes = true
-      end
+        class_attribute :partial_writes, instance_writer: false, default: true
 
-      # Attempts to +save+ the record and clears changed attributes if successful.
-      def save(*)
-        if status = super
-          changes_applied
-        end
-        status
-      end
+        # 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")
 
-      # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
-      def save!(*)
-        super.tap do
-          changes_applied
-        end
+        # 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
 
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          clear_changes_information
+          @mutations_before_last_save = nil
+          @mutations_from_database = nil
         end
       end
 
-      def initialize_dup(other) # :nodoc:
-        super
-        @original_raw_attributes = nil
-        calculate_changes_from_defaults
-      end
-
-      def changes_applied
-        super
-        store_original_raw_attributes
+      # Did this attribute change when we last saved?
+      #
+      # This method is useful in after callbacks to determine if an attribute
+      # was changed during the save that triggered the callbacks to run. It can
+      # be invoked as +saved_change_to_name?+ instead of
+      # <tt>saved_change_to_attribute?("name")</tt>.
+      #
+      # ==== 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.to_s, **options)
+      end
+
+      # 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.
+      #
+      # This method is useful in after callbacks, to see the change in an
+      # attribute during the save that triggered the callbacks to run. It can be
+      # invoked as +saved_change_to_name+ instead of
+      # <tt>saved_change_to_attribute("name")</tt>.
+      def saved_change_to_attribute(attr_name)
+        mutations_before_last_save.change_to_attribute(attr_name.to_s)
+      end
+
+      # Returns the original value of an attribute before the last save.
+      #
+      # This method is useful in after callbacks to get the original value of an
+      # attribute before the save that triggered the callbacks to run. It can be
+      # invoked as +name_before_last_save+ instead of
+      # <tt>attribute_before_last_save("name")</tt>.
+      def attribute_before_last_save(attr_name)
+        mutations_before_last_save.original_value(attr_name.to_s)
+      end
+
+      # Did the last call to +save+ have any changes to change?
+      def saved_changes?
+        mutations_before_last_save.any_changes?
+      end
+
+      # Returns a hash containing all the changes that were just saved.
+      def saved_changes
+        mutations_before_last_save.changes
+      end
+
+      # Will this attribute change the next time we save?
+      #
+      # This method is useful in validations and before callbacks to determine
+      # if the next call to +save+ will change a particular attribute. It can be
+      # invoked as +will_save_change_to_name?+ instead of
+      # <tt>will_save_change_to_attribute("name")</tt>.
+      #
+      # ==== 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 will be
+      # changed to the given value
+      def will_save_change_to_attribute?(attr_name, **options)
+        mutations_from_database.changed?(attr_name.to_s, **options)
+      end
+
+      # Returns the change to an attribute that will be persisted during the
+      # next save.
+      #
+      # This method is useful in validations and before callbacks, to see the
+      # change to an attribute that will occur when the record is saved. It can
+      # be invoked as +name_change_to_be_saved+ instead of
+      # <tt>attribute_change_to_be_saved("name")</tt>.
+      #
+      # If the attribute will change, the result will be an array containing the
+      # original value and the new value about to be saved.
+      def attribute_change_to_be_saved(attr_name)
+        mutations_from_database.change_to_attribute(attr_name.to_s)
+      end
+
+      # Returns the value of an attribute in the database, as opposed to the
+      # in-memory value that will be persisted the next time the record is
+      # saved.
+      #
+      # This method is useful in validations and before callbacks, to see the
+      # original value of an attribute prior to any changes about to be
+      # saved. It can be invoked as +name_in_database+ instead of
+      # <tt>attribute_in_database("name")</tt>.
+      def attribute_in_database(attr_name)
+        mutations_from_database.original_value(attr_name.to_s)
+      end
+
+      # Will the next call to +save+ have any changes to persist?
+      def has_changes_to_save?
+        mutations_from_database.any_changes?
+      end
+
+      # Returns a hash containing all the changes that will be persisted during
+      # the next save.
+      def changes_to_save
+        mutations_from_database.changes
+      end
+
+      # Returns an array of the names of any attributes that will change when
+      # the record is next saved.
+      def changed_attribute_names_to_save
+        mutations_from_database.changed_attribute_names
+      end
+
+      # Returns a hash of the attributes that will change when the record is
+      # next saved.
+      #
+      # The hash keys are the attribute names, and the hash values are the
+      # original attribute values in the database (as opposed to the in-memory
+      # values about to be saved).
+      def attributes_in_database
+        mutations_from_database.changed_values
       end
 
-      def clear_changes_information
-        super
-        original_raw_attributes.clear
-      end
-
-      def changed_attributes
-        # 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
-          super.reverse_merge(attributes_changed_in_place).freeze
+      private
+        def mutations_from_database
+          sync_with_transaction_state if @transaction_state&.finalized?
+          super
         end
-      end
 
-      def changes
-        cache_changed_attributes do
+        def mutations_before_last_save
+          sync_with_transaction_state if @transaction_state&.finalized?
           super
         end
-      end
-
-      def attribute_changed_in_place?(attr_name)
-        old_value = original_raw_attribute(attr_name)
-        @attributes[attr_name].changed_in_place_from?(old_value)
-      end
 
-      private
-
-      def changes_include?(attr_name)
-        super || attribute_changed_in_place?(attr_name)
-      end
-
-      def calculate_changes_from_defaults
-        @changed_attributes = nil
-        self.class.column_defaults.each do |attr, orig_value|
-          set_attribute_was(attr, orig_value) if _field_changed?(attr, orig_value)
+        def write_attribute_without_type_cast(attr_name, value)
+          result = super
+          clear_attribute_change(attr_name)
+          result
         end
-      end
 
-      # Wrap write_attribute to remember original attribute value.
-      def write_attribute(attr, value)
-        attr = attr.to_s
+        def _touch_row(attribute_names, time)
+          @_touch_attr_names = Set.new(attribute_names)
 
-        old_value = old_attribute_value(attr)
+          affected_rows = super
 
-        result = super
-        store_original_raw_attribute(attr)
-        save_changed_attribute(attr, old_value)
-        result
-      end
+          if @_skip_dirty_tracking ||= false
+            clear_attribute_changes(@_touch_attr_names)
+            return affected_rows
+          end
 
-      def raw_write_attribute(attr, value)
-        attr = attr.to_s
+          changes = {}
+          @attributes.keys.each do |attr_name|
+            next if @_touch_attr_names.include?(attr_name)
 
-        result = super
-        original_raw_attributes[attr] = value
-        result
-      end
+            if attribute_changed?(attr_name)
+              changes[attr_name] = _read_attribute(attr_name)
+              _write_attribute(attr_name, attribute_was(attr_name))
+              clear_attribute_change(attr_name)
+            end
+          end
 
-      def save_changed_attribute(attr, old_value)
-        clear_changed_attributes_cache
-        if attribute_changed_by_setter?(attr)
-          clear_attribute_changes(attr) unless _field_changed?(attr, old_value)
-        else
-          set_attribute_was(attr, old_value) if _field_changed?(attr, old_value)
-        end
-      end
-
-      def old_attribute_value(attr)
-        if attribute_changed?(attr)
-          changed_attributes[attr]
-        else
-          clone_attribute_value(:_read_attribute, attr)
-        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
-
-      # Serialized attributes should always be written in case they've been
-      # changed in place.
-      def keys_for_partial_write
-        changed & persistable_attribute_names
-      end
-
-      def _field_changed?(attr, old_value)
-        @attributes[attr].changed_from?(old_value)
-      end
+          changes_applied
+          changes.each { |attr_name, value| _write_attribute(attr_name, value) }
 
-      def attributes_changed_in_place
-        changed_in_place.each_with_object({}) do |attr_name, h|
-          orig = @attributes[attr_name].original_value
-          h[attr_name] = orig
+          affected_rows
+        ensure
+          @_touch_attr_names, @_skip_dirty_tracking = nil, nil
         end
-      end
 
-      def changed_in_place
-        self.class.attribute_names.select do |attr_name|
-          attribute_changed_in_place?(attr_name)
+        def _update_record(attribute_names = attribute_names_for_partial_writes)
+          affected_rows = super
+          changes_applied
+          affected_rows
         end
-      end
 
-      def original_raw_attribute(attr_name)
-        original_raw_attributes.fetch(attr_name) do
-          read_attribute_before_type_cast(attr_name)
+        def _create_record(attribute_names = attribute_names_for_partial_writes)
+          id = super
+          changes_applied
+          id
         end
-      end
 
-      def original_raw_attributes
-        @original_raw_attributes ||= {}
-      end
-
-      def store_original_raw_attribute(attr_name)
-        original_raw_attributes[attr_name] = @attributes[attr_name].value_for_database rescue nil
-      end
-
-      def store_original_raw_attributes
-        attribute_names.each do |attr|
-          store_original_raw_attribute(attr)
+        def attribute_names_for_partial_writes
+          partial_writes? ? changed_attribute_names_to_save : attribute_names
         end
-      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,128 +1,134 @@
-require 'set'
+# frozen_string_literal: true
+
+require "set"
 
 module ActiveRecord
   module AttributeMethods
     module PrimaryKey
       extend ActiveSupport::Concern
 
-      # Returns this record's primary key value wrapped in an Array if one is
+      # Returns this record's primary key value wrapped in an array if one is
       # available.
       def to_key
-        sync_with_transaction_state
-        key = self.id
+        key = id
         [key] if key
       end
 
-      # Returns the primary key value.
+      # Returns the primary key column's value.
       def id
-        if pk = self.class.primary_key
-          sync_with_transaction_state
-          _read_attribute(pk)
-        end
+        _read_attribute(@primary_key)
       end
 
-      # Sets the primary key value.
+      # Sets the primary key column's value.
       def id=(value)
-        sync_with_transaction_state
-        write_attribute(self.class.primary_key, value) if self.class.primary_key
+        _write_attribute(@primary_key, value)
       end
 
-      # Queries the primary key value.
+      # Queries the primary key column's value.
       def id?
-        sync_with_transaction_state
-        query_attribute(self.class.primary_key)
+        query_attribute(@primary_key)
       end
 
-      # Returns the primary key value before type cast.
+      # Returns the primary key column's value before type cast.
       def id_before_type_cast
-        sync_with_transaction_state
-        read_attribute_before_type_cast(self.class.primary_key)
+        read_attribute_before_type_cast(@primary_key)
       end
 
-      # Returns the primary key previous value.
+      # Returns the primary key column's previous value.
       def id_was
-        sync_with_transaction_state
-        attribute_was(self.class.primary_key)
+        attribute_was(@primary_key)
       end
 
-      protected
-
-      def attribute_method?(attr_name)
-        attr_name == 'id' || super
+      # Returns the primary key column's value from the database.
+      def id_in_database
+        attribute_in_database(@primary_key)
       end
 
-      module ClassMethods
-        def define_method_attribute(attr_name)
-          super
-
-          if attr_name == primary_key && attr_name != 'id'
-            generated_attribute_methods.send(:alias_method, :id, primary_key)
-          end
+      private
+        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?
-              connection.schema_cache.primary_keys(table_name)
+          def reset_primary_key #:nodoc:
+            if base_class?
+              self.primary_key = get_primary_key(base_class.name)
             else
-              'id'
+              self.primary_key = base_class.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)
+              else
+                "id"
+              end
             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
+          # 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)
+
+              warn <<~WARNING
+                WARNING: Active Record does not support composite primary key.
+
+                #{table_name} has composite primary key. Composite primary key is ignored.
+              WARNING
+            end
         end
-      end
     end
   end
 end

data/lib/active_record/attribute_methods/query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module AttributeMethods
     module Query
@@ -14,15 +16,14 @@ module ActiveRecord
         when true        then true
         when false, nil  then false
         else
-          column = self.class.columns_hash[attr_name]
-          if column.nil?
+          if !type_for_attribute(attr_name) { false }
             if Numeric === value || value !~ /[^0-9]/
               !value.to_i.zero?
             else
-              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
               !value.blank?
             end
-          elsif column.number?
+          elsif value.respond_to?(:zero?)
             !value.zero?
           else
             !value.blank?
@@ -31,7 +32,7 @@ module ActiveRecord
       end
 
       private
-        # Handle *? for method_missing.
+        # Dispatch target for <tt>*?</tt> attribute methods.
         def attribute?(attribute_name)
           query_attribute(attribute_name)
         end