activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,111 +1,150 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/blank'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
 
 module ActiveRecord
   module AttributeMethods
     module Dirty
       extend ActiveSupport::Concern
+
       include ActiveModel::Dirty
-      include AttributeMethods::Write
 
       included do
         if self < ::ActiveRecord::Timestamp
           raise "You cannot include Dirty after Timestamp"
         end
 
-        class_attribute :partial_updates
-        self.partial_updates = true
-      end
+        class_attribute :partial_writes, instance_writer: false, default: true
 
-      # Attempts to +save+ the record and clears changed attributes if successful.
-      def save(*) #:nodoc:
-        if status = super
-          @previously_changed = changes
-          @changed_attributes.clear
-        elsif IdentityMap.enabled?
-          IdentityMap.remove(self)
-        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!(*) #:nodoc:
-        super.tap do
-          @previously_changed = changes
-          @changed_attributes.clear
-        end
-      rescue
-        IdentityMap.remove(self) if IdentityMap.enabled?
-        raise
+        # 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(*) #:nodoc:
+      def reload(*)
         super.tap do
-          @previously_changed.clear
-          @changed_attributes.clear
+          @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+          @mutations_before_last_save = nil
+          @attributes_changed_by_setter = ActiveSupport::HashWithIndifferentAccess.new
+          @mutations_from_database = nil
         end
       end
 
-    private
-      # Wrap write_attribute to remember original attribute value.
-      def write_attribute(attr, value)
-        attr = attr.to_s
-
-        # 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)
-        else
-          old = clone_attribute_value(:read_attribute, attr)
-          # Save Time objects as TimeWithZone if time_zone_aware_attributes == true
-          old = old.in_time_zone if clone_with_time_zone_conversion_attribute?(attr, old)
-          @changed_attributes[attr] = old if _field_changed?(attr, old, value)
-        end
+      # Did this attribute change when we last saved? This method can be invoked
+      # as +saved_change_to_name?+ instead of <tt>saved_change_to_attribute?("name")</tt>.
+      # 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
 
-        # Carry on.
-        super(attr, value)
+      # 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
+      # <tt>saved_change_to_attribute("name")</tt>
+      def saved_change_to_attribute(attr_name)
+        mutations_before_last_save.change_to_attribute(attr_name)
       end
 
-      def update(*)
-        if partial_updates?
-          # Serialized attributes should always be written in case they've been
-          # changed in place.
-          super(changed | (attributes.keys & self.class.serialized_attributes.keys))
-        else
-          super
-        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
 
-      def _field_changed?(attr, old, value)
-        if column = column_for_attribute(attr)
-          if column.number? && (changes_from_nil_to_empty_string?(column, old, value) ||
-                                changes_from_zero_to_string?(old, value))
-            value = nil
-          else
-            value = column.type_cast(value)
-          end
-        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
 
-        old != value
+      # Alias for +attribute_changed?+
+      def will_save_change_to_attribute?(attr_name, **options)
+        mutations_from_database.changed?(attr_name, **options)
       end
 
-      def clone_with_time_zone_conversion_attribute?(attr, old)
-        old.class.name == "Time" && time_zone_aware_attributes && !self.skip_time_zone_conversion_for_attributes.include?(attr.to_sym)
+      # Alias for +attribute_change+
+      def attribute_change_to_be_saved(attr_name)
+        mutations_from_database.change_to_attribute(attr_name)
       end
 
-      def changes_from_nil_to_empty_string?(column, old, value)
-        # For nullable numeric columns, NULL gets stored in database for blank (i.e. '') values.
-        # Hence we don't record it as a change if the value changes from nil to ''.
-        # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
-        # be typecast back to 0 (''.to_i => 0)
-        column.null && (old.nil? || old == 0) && value.blank?
+      # Alias for +attribute_was+
+      def attribute_in_database(attr_name)
+        mutations_from_database.original_value(attr_name)
       end
 
-      def changes_from_zero_to_string?(old, value)
-        # For columns with old 0 and value non-empty string
-        old == 0 && value.is_a?(String) && value.present? && value != '0'
+      # Alias for +changed?+
+      def has_changes_to_save?
+        mutations_from_database.any_changes?
       end
+
+      # Alias for +changes+
+      def changes_to_save
+        mutations_from_database.changes
+      end
+
+      # Alias for +changed+
+      def changed_attribute_names_to_save
+        mutations_from_database.changed_attribute_names
+      end
+
+      # Alias for +changed_attributes+
+      def attributes_in_database
+        mutations_from_database.changed_values
+      end
+
+      private
+        def write_attribute_without_type_cast(attr_name, value)
+          name = attr_name.to_s
+          if self.class.attribute_alias?(name)
+            name = self.class.attribute_alias(name)
+          end
+          result = super(name, value)
+          clear_attribute_change(name)
+          result
+        end
+
+        def _update_record(*)
+          affected_rows = partial_writes? ? super(keys_for_partial_write) : super
+          changes_applied
+          affected_rows
+        end
+
+        def _create_record(*)
+          id = partial_writes? ? super(keys_for_partial_write) : super
+          changes_applied
+          id
+        end
+
+        def keys_for_partial_write
+          changed_attribute_names_to_save & self.class.column_names
+        end
     end
   end
 end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -1,114 +1,143 @@
+# 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 available
+      # Returns this record's primary key value wrapped in an array if one is
+      # available.
       def to_key
-        key = self.id
+        key = id
         [key] if key
       end
 
-      # Returns the primary key value
+      # Returns the primary key value.
       def id
-        read_attribute(self.class.primary_key)
+        sync_with_transaction_state
+        primary_key = self.class.primary_key
+        _read_attribute(primary_key) if primary_key
       end
 
-      # Sets the primary key value
+      # Sets the primary key value.
       def id=(value)
-        write_attribute(self.class.primary_key, value)
+        sync_with_transaction_state
+        primary_key = self.class.primary_key
+        _write_attribute(primary_key, value) if primary_key
       end
 
-      # Queries the primary key value
+      # Queries the primary key value.
       def id?
+        sync_with_transaction_state
         query_attribute(self.class.primary_key)
       end
 
-      module ClassMethods
-        def define_method_attribute(attr_name)
-          super
+      # Returns the primary key value before type cast.
+      def id_before_type_cast
+        sync_with_transaction_state
+        read_attribute_before_type_cast(self.class.primary_key)
+      end
 
-          if attr_name == primary_key && attr_name != 'id'
-            generated_attribute_methods.send(:alias_method, :id, primary_key)
-            generated_external_attribute_methods.module_eval <<-CODE, __FILE__, __LINE__
-              def id(v, attributes, attributes_cache, attr_name)
-                attr_name = '#{primary_key}'
-                send(attr_name, attributes[attr_name], attributes, attributes_cache, attr_name)
-              end
-            CODE
-          end
-        end
+      # Returns the primary key previous value.
+      def id_was
+        sync_with_transaction_state
+        attribute_was(self.class.primary_key)
+      end
 
-        def dangerous_attribute_method?(method_name)
-          super && !['id', 'id=', 'id?'].include?(method_name)
-        end
+      def id_in_database
+        sync_with_transaction_state
+        attribute_in_database(self.class.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
+      private
 
-        # 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)
+        def attribute_method?(attr_name)
+          attr_name == "id" || super
         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
+        module ClassMethods
+          ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database).to_set
+
+          def instance_method_already_implemented?(method_name)
+            super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)
+          end
+
+          def dangerous_attribute_method?(method_name)
+            super && !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
-        end
 
-        def get_primary_key(base_name) #:nodoc:
-          return 'id' unless base_name && !base_name.blank?
-
-          case primary_key_prefix_type
-          when :table_name
-            base_name.foreign_key(false)
-          when :table_name_with_underscore
-            base_name.foreign_key
-          else
-            if ActiveRecord::Base != self && table_exists?
-              connection.schema_cache.primary_keys[table_name]
+          # 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
+
+          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
 
-        def original_primary_key #:nodoc:
-          deprecated_original_property_getter :primary_key
-        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
 
-        # 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)
-          @original_primary_key = @primary_key if defined?(@primary_key)
-          @primary_key          = value && value.to_s
-          @quoted_primary_key   = nil
-        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
+
+          private
+
+            def suppress_composite_primary_key(pk)
+              return pk unless pk.is_a?(Array)
 
-        def set_primary_key(value = nil, &block) #:nodoc:
-          deprecated_property_setter :primary_key, value, block
-          @quoted_primary_key = nil
+              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
+            end
         end
-      end
     end
   end
 end

data/lib/active_record/attribute_methods/query.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/object/blank'
+# frozen_string_literal: true
 
 module ActiveRecord
   module AttributeMethods
@@ -10,18 +10,21 @@ module ActiveRecord
       end
 
       def query_attribute(attr_name)
-        unless value = read_attribute(attr_name)
-          false
+        value = self[attr_name]
+
+        case value
+        when true        then true
+        when false, nil  then false
         else
           column = self.class.columns_hash[attr_name]
           if column.nil?
             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?