activerecord 7.0.8.7 → 7.1.5.1

data/lib/active_record/attribute_assignment.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_model/forbidden_attributes_protection"
-
 module ActiveRecord
   module AttributeAssignment
     include ActiveModel::AttributeAssignment

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -52,6 +52,23 @@ module ActiveRecord
         attribute_before_type_cast(name)
       end
 
+      # Returns the value of the attribute identified by +attr_name+ after
+      # serialization.
+      #
+      #   class Book < ActiveRecord::Base
+      #     enum :status, { draft: 1, published: 2 }
+      #   end
+      #
+      #   book = Book.new(status: "published")
+      #   book.read_attribute(:status)              # => "published"
+      #   book.read_attribute_for_database(:status) # => 2
+      def read_attribute_for_database(attr_name)
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
+
+        attribute_for_database(name)
+      end
+
       # Returns a hash of attributes before typecasting and deserialization.
       #
       #   class Task < ActiveRecord::Base

data/lib/active_record/attribute_methods/dirty.rb

@@ -4,6 +4,38 @@ require "active_support/core_ext/module/attribute_accessors"
 
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Dirty
+    #
+    # Provides a way to track changes in your Active Record models. It adds all
+    # methods from ActiveModel::Dirty and adds database-specific methods.
+    #
+    # A newly created +Person+ object is unchanged:
+    #
+    #   class Person < ActiveRecord::Base
+    #   end
+    #
+    #   person = Person.create(name: "Allison")
+    #   person.changed? # => false
+    #
+    # Change the name:
+    #
+    #   person.name = 'Alice'
+    #   person.name_in_database          # => "Allison"
+    #   person.will_save_change_to_name? # => true
+    #   person.name_change_to_be_saved   # => ["Allison", "Alice"]
+    #   person.changes_to_save           # => {"name"=>["Allison", "Alice"]}
+    #
+    # Save the changes:
+    #
+    #   person.save
+    #   person.name_in_database        # => "Alice"
+    #   person.saved_change_to_name?   # => true
+    #   person.saved_change_to_name    # => ["Allison", "Alice"]
+    #   person.name_before_last_save   # => "Allison"
+    #
+    # Similar to ActiveModel::Dirty, methods can be invoked as
+    # +saved_change_to_name?+ or by passing an argument to the generic method
+    # <tt>saved_change_to_attribute?("name")</tt>.
     module Dirty
       extend ActiveSupport::Concern
 
@@ -27,32 +59,6 @@ module ActiveRecord
         attribute_method_suffix("_change_to_be_saved", "_in_database", parameters: false)
       end
 
-      module ClassMethods
-        def partial_writes
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            ActiveRecord::Base.partial_writes is deprecated and will be removed in Rails 7.1.
-            Use `partial_updates` and `partial_inserts` instead.
-          MSG
-          partial_updates && partial_inserts
-        end
-
-        def partial_writes?
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `ActiveRecord::Base.partial_writes?` is deprecated and will be removed in Rails 7.1.
-            Use `partial_updates?` and `partial_inserts?` instead.
-          MSG
-          partial_updates? && partial_inserts?
-        end
-
-        def partial_writes=(value)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `ActiveRecord::Base.partial_writes=` is deprecated and will be removed in Rails 7.1.
-            Use `partial_updates=` and `partial_inserts=` instead.
-          MSG
-          self.partial_updates = self.partial_inserts = value
-        end
-      end
-
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
@@ -70,11 +76,13 @@ module ActiveRecord
       #
       # ==== Options
       #
-      # +from+ When passed, this method will return false unless the original
-      # value is equal to the given option
+      # [+from+]
+      #   When specified, this method will return false unless the original
+      #   value is equal to the given value.
       #
-      # +to+ When passed, this method will return false unless the value was
-      # changed to the given value
+      # [+to+]
+      #   When specified, this method will return false unless the value will be
+      #   changed to the given value.
       def saved_change_to_attribute?(attr_name, **options)
         mutations_before_last_save.changed?(attr_name.to_s, **options)
       end
@@ -120,11 +128,13 @@ module ActiveRecord
       #
       # ==== Options
       #
-      # +from+ When passed, this method will return false unless the original
-      # value is equal to the given option
+      # [+from+]
+      #   When specified, this method will return false unless the original
+      #   value is equal to the given value.
       #
-      # +to+ When passed, this method will return false unless the value will be
-      # changed to the given value
+      # [+to+]
+      #   When specified, 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
@@ -183,6 +193,14 @@ module ActiveRecord
       end
 
       private
+        def init_internals
+          super
+          @mutations_before_last_save = nil
+          @mutations_from_database = nil
+          @_touch_attr_names = nil
+          @_skip_dirty_tracking = nil
+        end
+
         def _touch_row(attribute_names, time)
           @_touch_attr_names = Set.new(attribute_names)
 
@@ -233,7 +251,7 @@ module ActiveRecord
             changed_attribute_names_to_save
           else
             attribute_names.reject do |attr_name|
-              if column_for_attribute(attr_name).default_function
+              if column_for_attribute(attr_name).auto_populated?
                 !attribute_changed?(attr_name)
               end
             end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -4,6 +4,7 @@ require "set"
 
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods Primary Key
     module PrimaryKey
       extend ActiveSupport::Concern
 
@@ -11,41 +12,80 @@ module ActiveRecord
       # available.
       def to_key
         key = id
-        [key] if key
+        Array(key) if key
       end
 
-      # Returns the primary key column's value.
+      # Returns the primary key column's value. If the primary key is composite,
+      # returns an array of the primary key column values.
       def id
-        _read_attribute(@primary_key)
+        return _read_attribute(@primary_key) unless @primary_key.is_a?(Array)
+
+        @primary_key.map { |pk| _read_attribute(pk) }
+      end
+
+      def primary_key_values_present? # :nodoc:
+        return id.all? if self.class.composite_primary_key?
+
+        !!id
       end
 
-      # Sets the primary key column's value.
+      # Sets the primary key column's value. If the primary key is composite,
+      # raises TypeError when the set value not enumerable.
       def id=(value)
-        _write_attribute(@primary_key, value)
+        if self.class.composite_primary_key?
+          raise TypeError, "Expected value matching #{self.class.primary_key.inspect}, got #{value.inspect}." unless value.is_a?(Enumerable)
+          @primary_key.zip(value) { |attr, value| _write_attribute(attr, value) }
+        else
+          _write_attribute(@primary_key, value)
+        end
       end
 
-      # Queries the primary key column's value.
+      # Queries the primary key column's value. If the primary key is composite,
+      # all primary key column values must be queryable.
       def id?
-        query_attribute(@primary_key)
+        if self.class.composite_primary_key?
+          @primary_key.all? { |col| _query_attribute(col) }
+        else
+          _query_attribute(@primary_key)
+        end
       end
 
-      # Returns the primary key column's value before type cast.
+      # Returns the primary key column's value before type cast. If the primary key is composite,
+      # returns an array of primary key column values before type cast.
       def id_before_type_cast
-        attribute_before_type_cast(@primary_key)
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_before_type_cast(col) }
+        else
+          attribute_before_type_cast(@primary_key)
+        end
       end
 
-      # Returns the primary key column's previous value.
+      # Returns the primary key column's previous value. If the primary key is composite,
+      # returns an array of primary key column previous values.
       def id_was
-        attribute_was(@primary_key)
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_was(col) }
+        else
+          attribute_was(@primary_key)
+        end
       end
 
-      # Returns the primary key column's value from the database.
+      # Returns the primary key column's value from the database. If the primary key is composite,
+      # returns an array of primary key column values from database.
       def id_in_database
-        attribute_in_database(@primary_key)
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_in_database(col) }
+        else
+          attribute_in_database(@primary_key)
+        end
       end
 
       def id_for_database # :nodoc:
-        @attributes[@primary_key].value_for_database
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| @attributes[col].value_for_database }
+        else
+          @attributes[@primary_key].value_for_database
+        end
       end
 
       private
@@ -55,6 +95,7 @@ module ActiveRecord
 
         module ClassMethods
           ID_ATTRIBUTE_METHODS = %w(id id= id? id_before_type_cast id_was id_in_database id_for_database).to_set
+          PRIMARY_KEY_NOT_SET = BasicObject.new
 
           def instance_method_already_implemented?(method_name)
             super || primary_key && ID_ATTRIBUTE_METHODS.include?(method_name)
@@ -68,10 +109,16 @@ module ActiveRecord
           # 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
+            if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
+              @primary_key = reset_primary_key
+            end
             @primary_key
           end
 
+          def composite_primary_key? # :nodoc:
+            primary_key.is_a?(Array)
+          end
+
           # Returns a quoted version of the primary key name, used to construct
           # SQL statements.
           def quoted_primary_key
@@ -93,8 +140,7 @@ module ActiveRecord
               base_name.foreign_key
             else
               if ActiveRecord::Base != self && table_exists?
-                pk = connection.schema_cache.primary_keys(table_name)
-                suppress_composite_primary_key(pk)
+                connection.schema_cache.primary_keys(table_name)
               else
                 "id"
               end
@@ -117,20 +163,26 @@ module ActiveRecord
           #
           #   Project.primary_key # => "foo_id"
           def primary_key=(value)
-            @primary_key        = value && -value.to_s
+            @primary_key        = derive_primary_key(value)
             @quoted_primary_key = nil
             @attributes_builder = nil
           end
 
           private
-            def suppress_composite_primary_key(pk)
-              return pk unless pk.is_a?(Array)
+            def derive_primary_key(value)
+              return unless value
+
+              return -value.to_s unless value.is_a?(Array)
 
-              warn <<~WARNING
-                WARNING: Active Record does not support composite primary key.
+              value.map { |v| -v.to_s }.freeze
+            end
 
-                #{table_name} has composite primary key. Composite primary key is ignored.
-              WARNING
+            def inherited(base)
+              super
+              base.class_eval do
+                @primary_key = PRIMARY_KEY_NOT_SET
+                @quoted_primary_key = nil
+              end
             end
         end
     end

data/lib/active_record/attribute_methods/query.rb

@@ -2,6 +2,7 @@
 
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Query
     module Query
       extend ActiveSupport::Concern
 
@@ -12,27 +13,38 @@ module ActiveRecord
       def query_attribute(attr_name)
         value = self.public_send(attr_name)
 
-        case value
-        when true        then true
-        when false, nil  then false
-        else
-          if !type_for_attribute(attr_name) { false }
-            if Numeric === value || !value.match?(/[^0-9]/)
-              !value.to_i.zero?
+        query_cast_attribute(attr_name, value)
+      end
+
+      def _query_attribute(attr_name) # :nodoc:
+        value = self._read_attribute(attr_name.to_s)
+
+        query_cast_attribute(attr_name, value)
+      end
+
+      alias :attribute? :query_attribute
+      private :attribute?
+
+      private
+        def query_cast_attribute(attr_name, value)
+          case value
+          when true        then true
+          when false, nil  then false
+          else
+            if !type_for_attribute(attr_name) { false }
+              if Numeric === value || !value.match?(/[^0-9]/)
+                !value.to_i.zero?
+              else
+                return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
+                !value.blank?
+              end
+            elsif value.respond_to?(:zero?)
+              !value.zero?
             else
-              return false if ActiveModel::Type::Boolean::FALSE_VALUES.include?(value)
               !value.blank?
             end
-          elsif value.respond_to?(:zero?)
-            !value.zero?
-          else
-            !value.blank?
           end
         end
-      end
-
-      alias :attribute? :query_attribute
-      private :attribute?
     end
   end
 end

data/lib/active_record/attribute_methods/read.rb

@@ -2,16 +2,17 @@
 
 module ActiveRecord
   module AttributeMethods
+    # = Active Record Attribute Methods \Read
     module Read
       extend ActiveSupport::Concern
 
       module ClassMethods # :nodoc:
         private
-          def define_method_attribute(name, owner:)
+          def define_method_attribute(canonical_name, owner:, as: canonical_name)
             ActiveModel::AttributeMethods::AttrNames.define_attribute_accessor_method(
-              owner, name
+              owner, canonical_name
             ) do |temp_method_name, attr_name_expr|
-              owner.define_cached_method(name, as: temp_method_name, namespace: :active_record) do |batch|
+              owner.define_cached_method(temp_method_name, as: as, namespace: :active_record) do |batch|
                 batch <<
                   "def #{temp_method_name}" <<
                   "  _read_attribute(#{attr_name_expr}) { |n| missing_attribute(n, caller) }" <<
@@ -21,15 +22,27 @@ module ActiveRecord
           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 <tt>Date.new(2004, 12, 12)</tt>).
+      # Returns the value of the attribute identified by +attr_name+ after it
+      # has been type cast. For example, a date attribute will cast "2004-12-12"
+      # to <tt>Date.new(2004, 12, 12)</tt>. (For information about specific type
+      # casting behavior, see the types under ActiveModel::Type.)
       def read_attribute(attr_name, &block)
         name = attr_name.to_s
         name = self.class.attribute_aliases[name] || name
 
-        name = @primary_key if name == "id" && @primary_key
-        @attributes.fetch_value(name, &block)
+        return @attributes.fetch_value(name, &block) unless name == "id" && @primary_key
+
+        if self.class.composite_primary_key?
+          @attributes.fetch_value("id", &block)
+        else
+          if @primary_key != "id"
+            ActiveRecord.deprecator.warn(<<-MSG.squish)
+              Using read_attribute(:id) to read the primary key value is deprecated.
+              Use #id instead.
+            MSG
+          end
+          @attributes.fetch_value(@primary_key, &block)
+        end
       end
 
       # This method exists to avoid the expensive primary_key check internally, without