activerecord 7.1.5.1 → 8.0.2

data/lib/active_record/attribute_methods/composite_primary_key.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module AttributeMethods
+    module CompositePrimaryKey # :nodoc:
+      # Returns the primary key column's value. If the primary key is composite,
+      # returns an array of the primary key column values.
+      def id
+        if self.class.composite_primary_key?
+          @primary_key.map { |pk| _read_attribute(pk) }
+        else
+          super
+        end
+      end
+
+      def primary_key_values_present? # :nodoc:
+        if self.class.composite_primary_key?
+          id.all?
+        else
+          super
+        end
+      end
+
+      # Sets the primary key column's value. If the primary key is composite,
+      # raises TypeError when the set value not enumerable.
+      def id=(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
+          super
+        end
+      end
+
+      # Queries the primary key column's value. If the primary key is composite,
+      # all primary key column values must be queryable.
+      def id?
+        if self.class.composite_primary_key?
+          @primary_key.all? { |col| _query_attribute(col) }
+        else
+          super
+        end
+      end
+
+      # 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
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_before_type_cast(col) }
+        else
+          super
+        end
+      end
+
+      # 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
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_was(col) }
+        else
+          super
+        end
+      end
+
+      # 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
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| attribute_in_database(col) }
+        else
+          super
+        end
+      end
+
+      def id_for_database # :nodoc:
+        if self.class.composite_primary_key?
+          @primary_key.map { |col| @attributes[col].value_for_database }
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module ActiveRecord
   module AttributeMethods
     # = Active Record Attribute Methods Primary Key
@@ -18,74 +16,45 @@ module ActiveRecord
       # Returns the primary key column's value. If the primary key is composite,
       # returns an array of the primary key column values.
       def id
-        return _read_attribute(@primary_key) unless @primary_key.is_a?(Array)
-
-        @primary_key.map { |pk| _read_attribute(pk) }
+        _read_attribute(@primary_key)
       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. If the primary key is composite,
       # raises TypeError when the set value not enumerable.
       def id=(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
+        _write_attribute(@primary_key, value)
       end
 
       # Queries the primary key column's value. If the primary key is composite,
       # all primary key column values must be queryable.
       def id?
-        if self.class.composite_primary_key?
-          @primary_key.all? { |col| _query_attribute(col) }
-        else
-          _query_attribute(@primary_key)
-        end
+        _query_attribute(@primary_key)
       end
 
       # 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
-        if self.class.composite_primary_key?
-          @primary_key.map { |col| attribute_before_type_cast(col) }
-        else
-          attribute_before_type_cast(@primary_key)
-        end
+        attribute_before_type_cast(@primary_key)
       end
 
       # 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
-        if self.class.composite_primary_key?
-          @primary_key.map { |col| attribute_was(col) }
-        else
-          attribute_was(@primary_key)
-        end
+        attribute_was(@primary_key)
       end
 
       # 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
-        if self.class.composite_primary_key?
-          @primary_key.map { |col| attribute_in_database(col) }
-        else
-          attribute_in_database(@primary_key)
-        end
+        attribute_in_database(@primary_key)
       end
 
       def id_for_database # :nodoc:
-        if self.class.composite_primary_key?
-          @primary_key.map { |col| @attributes[col].value_for_database }
-        else
-          @attributes[@primary_key].value_for_database
-        end
+        @attributes[@primary_key].value_for_database
       end
 
       private
@@ -109,20 +78,18 @@ module ActiveRecord
           # Overwriting will negate any effect of the +primary_key_prefix_type+
           # setting, though.
           def primary_key
-            if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
-              @primary_key = reset_primary_key
-            end
+            reset_primary_key if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
             @primary_key
           end
 
           def composite_primary_key? # :nodoc:
-            primary_key.is_a?(Array)
+            reset_primary_key if PRIMARY_KEY_NOT_SET.equal?(@primary_key)
+            @composite_primary_key
           end
 
-          # Returns a quoted version of the primary key name, used to construct
-          # SQL statements.
+          # Returns a quoted version of the primary key name.
           def quoted_primary_key
-            @quoted_primary_key ||= connection.quote_column_name(primary_key)
+            adapter_class.quote_column_name(primary_key)
           end
 
           def reset_primary_key # :nodoc:
@@ -138,12 +105,10 @@ module ActiveRecord
               base_name.foreign_key(false)
             elsif base_name && primary_key_prefix_type == :table_name_with_underscore
               base_name.foreign_key
+            elsif ActiveRecord::Base != self && table_exists?
+              schema_cache.primary_keys(table_name)
             else
-              if ActiveRecord::Base != self && table_exists?
-                connection.schema_cache.primary_keys(table_name)
-              else
-                "id"
-              end
+              "id"
             end
           end
 
@@ -163,25 +128,24 @@ module ActiveRecord
           #
           #   Project.primary_key # => "foo_id"
           def primary_key=(value)
-            @primary_key        = derive_primary_key(value)
-            @quoted_primary_key = nil
+            @primary_key = if value.is_a?(Array)
+              include CompositePrimaryKey
+              @primary_key = value.map { |v| -v.to_s }.freeze
+            elsif value
+              -value.to_s
+            end
+
+            @composite_primary_key = value.is_a?(Array)
             @attributes_builder = nil
           end
 
           private
-            def derive_primary_key(value)
-              return unless value
-
-              return -value.to_s unless value.is_a?(Array)
-
-              value.map { |v| -v.to_s }.freeze
-            end
-
             def inherited(base)
               super
               base.class_eval do
                 @primary_key = PRIMARY_KEY_NOT_SET
-                @quoted_primary_key = nil
+                @composite_primary_key = false
+                @attributes_builder = nil
               end
             end
         end

data/lib/active_record/attribute_methods/read.rb

@@ -30,19 +30,7 @@ module ActiveRecord
         name = attr_name.to_s
         name = self.class.attribute_aliases[name] || name
 
-        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
+        @attributes.fetch_value(name, &block)
       end
 
       # This method exists to avoid the expensive primary_key check internally, without

data/lib/active_record/attribute_methods/serialization.rb

@@ -180,29 +180,7 @@ module ActiveRecord
         #     serialize :preferences, coder: Rot13JSON
         #   end
         #
-        def serialize(attr_name, class_name_or_coder = nil, coder: nil, type: Object, yaml: {}, **options)
-          unless class_name_or_coder.nil?
-            if class_name_or_coder == ::JSON || [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
-              ActiveRecord.deprecator.warn(<<~MSG)
-                Passing the coder as positional argument is deprecated and will be removed in Rails 7.2.
-
-                Please pass the coder as a keyword argument:
-
-                  serialize #{attr_name.inspect}, coder: #{class_name_or_coder}
-              MSG
-              coder = class_name_or_coder
-            else
-              ActiveRecord.deprecator.warn(<<~MSG)
-                Passing the class as positional argument is deprecated and will be removed in Rails 7.2.
-
-                Please pass the class as a keyword argument:
-
-                  serialize #{attr_name.inspect}, type: #{class_name_or_coder.name}
-              MSG
-              type = class_name_or_coder
-            end
-          end
-
+        def serialize(attr_name, coder: nil, type: Object, yaml: {}, **options)
           coder ||= default_column_serializer
           unless coder
             raise ArgumentError, <<~MSG.squish
@@ -214,7 +192,9 @@ module ActiveRecord
 
           column_serializer = build_column_serializer(attr_name, coder, type, yaml)
 
-          attribute(attr_name, **options) do |cast_type|
+          attribute(attr_name, **options)
+
+          decorate_attributes([attr_name]) do |attr_name, cast_type|
             if type_incompatible_with_serialize?(cast_type, coder, type)
               raise ColumnNotSerializableError.new(attr_name, cast_type)
             end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -28,7 +28,7 @@ module ActiveRecord
           elsif value.respond_to?(:infinite?) && value.infinite?
             value
           else
-            map_avoiding_infinite_recursion(super) { |v| cast(v) }
+            map(super) { |v| cast(v) }
           end
         end
 
@@ -45,23 +45,13 @@ module ActiveRecord
             elsif value.respond_to?(:infinite?) && value.infinite?
               value
             else
-              map_avoiding_infinite_recursion(value) { |v| convert_time_to_time_zone(v) }
+              map(value) { |v| convert_time_to_time_zone(v) }
             end
           end
 
           def set_time_zone_without_conversion(value)
             ::Time.zone.local_to_utc(value).try(:in_time_zone) if value
           end
-
-          def map_avoiding_infinite_recursion(value)
-            map(value) do |v|
-              if value.equal?(v)
-                nil
-              else
-                yield(v)
-              end
-            end
-          end
       end
 
       extend ActiveSupport::Concern
@@ -73,14 +63,15 @@ module ActiveRecord
       end
 
       module ClassMethods # :nodoc:
-        def define_attribute(name, cast_type, **)
-          if create_time_zone_conversion_attribute?(name, cast_type)
-            cast_type = TimeZoneConverter.new(cast_type)
+        private
+          def hook_attribute_type(name, cast_type)
+            if create_time_zone_conversion_attribute?(name, cast_type)
+              cast_type = TimeZoneConverter.new(cast_type)
+            end
+
+            super
           end
-          super
-        end
 
-        private
           def create_time_zone_conversion_attribute?(name, cast_type)
             enabled_for_column = time_zone_aware_attributes &&
               !skip_time_zone_conversion_for_attributes.include?(name.to_sym)

data/lib/active_record/attribute_methods.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "mutex_m"
 require "active_support/core_ext/enumerable"
 
 module ActiveRecord
@@ -21,10 +20,10 @@ module ActiveRecord
       include Serialization
     end
 
-    RESTRICTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
+    RESTRICTED_CLASS_METHODS = %w(private public protected allocate new name superclass)
 
     class GeneratedAttributeMethods < Module # :nodoc:
-      include Mutex_m
+      LOCK = Monitor.new
     end
 
     class << self
@@ -50,6 +49,20 @@ module ActiveRecord
         super
       end
 
+      # Allows you to make aliases for attributes.
+      #
+      #   class Person < ActiveRecord::Base
+      #     alias_attribute :nickname, :name
+      #   end
+      #
+      #   person = Person.create(name: 'Bob')
+      #   person.name     # => "Bob"
+      #   person.nickname # => "Bob"
+      #
+      # The alias can also be used for querying:
+      #
+      #   Person.where(nickname: "Bob")
+      #   # SELECT "people".* FROM "people" WHERE "people"."name" = "Bob"
       def alias_attribute(new_name, old_name)
         super
 
@@ -64,25 +77,6 @@ module ActiveRecord
         # alias attributes in Active Record are lazily generated
       end
 
-      def generate_alias_attributes # :nodoc:
-        superclass.generate_alias_attributes unless superclass == Base
-        return false if @alias_attributes_mass_generated
-
-        generated_attribute_methods.synchronize do
-          return if @alias_attributes_mass_generated
-          ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |code_generator|
-            aliases_by_attribute_name.each do |old_name, new_names|
-              new_names.each do |new_name|
-                generate_alias_attribute_methods(code_generator, new_name, old_name)
-              end
-            end
-          end
-
-          @alias_attributes_mass_generated = true
-        end
-        true
-      end
-
       def generate_alias_attribute_methods(code_generator, new_name, old_name) # :nodoc:
         attribute_method_patterns.each do |pattern|
           alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
@@ -91,63 +85,64 @@ module ActiveRecord
       end
 
       def alias_attribute_method_definition(code_generator, pattern, new_name, old_name) # :nodoc:
-        method_name = pattern.method_name(new_name).to_s
-        target_name = pattern.method_name(old_name).to_s
         old_name = old_name.to_s
 
-        method_defined = method_defined?(target_name) || private_method_defined?(target_name)
-        manually_defined = method_defined &&
-          !self.instance_method(target_name).owner.is_a?(GeneratedAttributeMethods)
-        reserved_method_name = ::ActiveRecord::AttributeMethods.dangerous_attribute_methods.include?(target_name)
-
         if !abstract_class? && !has_attribute?(old_name)
-          # We only need to issue this deprecation warning once, so we issue it when defining the original reader method.
-          should_warn = target_name == old_name
-          if should_warn
-            ActiveRecord.deprecator.warn(
-              "#{self} model aliases `#{old_name}`, but `#{old_name}` is not an attribute. " \
-              "Starting in Rails 7.2, alias_attribute with non-attribute targets will raise. " \
-              "Use `alias_method :#{new_name}, :#{old_name}` or define the method manually."
-            )
-          end
-          super
-        elsif manually_defined && !reserved_method_name
-          aliased_method_redefined_as_well = method_defined_within?(method_name, self)
-          return if aliased_method_redefined_as_well
-
-          ActiveRecord.deprecator.warn(
-            "#{self} model aliases `#{old_name}` and has a method called `#{target_name}` defined. " \
-            "Starting in Rails 7.2 `#{method_name}` will not be calling `#{target_name}` anymore. " \
-            "You may want to additionally define `#{method_name}` to preserve the current behavior."
-          )
-          super
+          raise ArgumentError, "#{self.name} model aliases `#{old_name}`, but `#{old_name}` is not an attribute. " \
+            "Use `alias_method :#{new_name}, :#{old_name}` or define the method manually."
         else
           define_attribute_method_pattern(pattern, old_name, owner: code_generator, as: new_name, override: true)
         end
       end
 
+      def attribute_methods_generated? # :nodoc:
+        @attribute_methods_generated
+      end
+
       # Generates all the attribute related methods for columns in the database
       # accessors, mutators and query methods.
       def define_attribute_methods # :nodoc:
         return false if @attribute_methods_generated
         # Use a mutex; we don't want two threads simultaneously trying to define
         # attribute methods.
-        generated_attribute_methods.synchronize do
+        GeneratedAttributeMethods::LOCK.synchronize do
           return false if @attribute_methods_generated
+
           superclass.define_attribute_methods unless base_class?
-          super(attribute_names)
+
+          unless abstract_class?
+            load_schema
+            super(attribute_names)
+            alias_attribute :id_value, :id if _has_attribute?("id")
+          end
+
+          generate_alias_attributes
+
           @attribute_methods_generated = true
         end
+
         true
       end
 
-      def attribute_methods_generated? # :nodoc:
-        @attribute_methods_generated && @alias_attributes_mass_generated
+      def generate_alias_attributes # :nodoc:
+        superclass.generate_alias_attributes unless superclass == Base
+
+        return if @alias_attributes_mass_generated
+
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |code_generator|
+          aliases_by_attribute_name.each do |old_name, new_names|
+            new_names.each do |new_name|
+              generate_alias_attribute_methods(code_generator, new_name, old_name)
+            end
+          end
+        end
+
+        @alias_attributes_mass_generated = true
       end
 
       def undefine_attribute_methods # :nodoc:
-        generated_attribute_methods.synchronize do
-          super if defined?(@attribute_methods_generated) && @attribute_methods_generated
+        GeneratedAttributeMethods::LOCK.synchronize do
+          super if @attribute_methods_generated
           @attribute_methods_generated = false
           @alias_attributes_mass_generated = false
         end
@@ -298,9 +293,7 @@ module ActiveRecord
 
       # If the result is true then check for the select case.
       # For queries selecting a subset of columns, return false for unselected columns.
-      # We check defined?(@attributes) not to issue warnings if called on objects that
-      # have been allocated but not yet initialized.
-      if defined?(@attributes)
+      if @attributes
         if name = self.class.symbol_column_to_string(name.to_sym)
           return _has_attribute?(name)
         end
@@ -480,28 +473,31 @@ module ActiveRecord
       end
 
       def method_missing(name, ...)
-        unless self.class.attribute_methods_generated?
-          if self.class.method_defined?(name)
-            # The method is explicitly defined in the model, but calls a generated
-            # method with super. So we must resume the call chain at the right setp.
-            last_method = method(name)
-            last_method = last_method.super_method while last_method.super_method
-            self.class.define_attribute_methods
-            if last_method.super_method
-              return last_method.super_method.call(...)
-            end
-          elsif self.class.define_attribute_methods | self.class.generate_alias_attributes
-            # Some attribute methods weren't generated yet, we retry the call
-            return public_send(name, ...)
-          end
+        # We can't know whether some method was defined or not because
+        # multiple thread might be concurrently be in this code path.
+        # So the first one would define the methods and the others would
+        # appear to already have them.
+        self.class.define_attribute_methods
+
+        # So in all cases we must behave as if the method was just defined.
+        method = begin
+          self.class.public_instance_method(name)
+        rescue NameError
+          nil
         end
 
-        super
+        # The method might be explicitly defined in the model, but call a generated
+        # method with super. So we must resume the call chain at the right step.
+        method = method.super_method while method && !method.owner.is_a?(GeneratedAttributeMethods)
+        if method
+          method.bind_call(self, ...)
+        else
+          super
+        end
       end
 
       def attribute_method?(attr_name)
-        # We check defined? because Syck calls respond_to? before actually calling initialize.
-        defined?(@attributes) && @attributes.key?(attr_name)
+        @attributes&.key?(attr_name)
       end
 
       def attributes_with_values(attribute_names)