Merge pull request #44666 from jonathanhefner/active_record-use-attribute_registration

Use `ActiveModel::AttributeRegistration` in AR

Author: jonathanhefner

activemodel/lib/active_model/attribute_registration.rb

@@ -12,6 +12,7 @@ module ClassMethods # :nodoc:
       def attribute(name, type = nil, default: (no_default = true), **options)
         name = resolve_attribute_name(name)
         type = resolve_type_name(type, **options) if type.is_a?(Symbol)
+        type = hook_attribute_type(name, type) if type
 
         pending_attribute_modifications << PendingType.new(name, type) if type || no_default
         pending_attribute_modifications << PendingDefault.new(name, default) unless no_default
@@ -76,9 +77,13 @@ def apply_pending_attribute_modifications(attribute_set)
         end
 
         def reset_default_attributes
+          reset_default_attributes!
+          subclasses.each { |subclass| subclass.send(__method__) }
+        end
+
+        def reset_default_attributes!
           @default_attributes = nil
           @attribute_types = nil
-          subclasses.each { |subclass| subclass.send(__method__) }
         end
 
         def resolve_attribute_name(name)
@@ -88,6 +93,13 @@ def resolve_attribute_name(name)
         def resolve_type_name(name, **options)
           Type.lookup(name, **options)
         end
+
+        # Hook for other modules to override. The attribute type is passed
+        # through this method immediately after it is resolved, before any type
+        # decorations are applied.
+        def hook_attribute_type(attribute, type)
+          type
+        end
     end
   end
 end

activerecord/lib/active_record/attribute_methods/serialization.rb

@@ -214,7 +214,9 @@ def serialize(attr_name, class_name_or_coder = nil, coder: nil, type: Object, ya
 
           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

activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -69,14 +69,14 @@ def map_avoiding_infinite_recursion(value)
       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)

activerecord/lib/active_record/attributes.rb

@@ -6,12 +6,13 @@ module ActiveRecord
   # See ActiveRecord::Attributes::ClassMethods for documentation
   module Attributes
     extend ActiveSupport::Concern
+    include ActiveModel::AttributeRegistration
 
-    included do
-      class_attribute :attributes_to_define_after_schema_loads, instance_accessor: false, default: {} # :internal:
-    end
     # = Active Record \Attributes
     module ClassMethods
+      # :method: attribute
+      # :call-seq: attribute(name, cast_type = nil, **options)
+      #
       # Defines an attribute with a type on this model. It will override the
       # type of existing attributes if needed. This allows control over how
       # values are converted to and from SQL when assigned to a model. It also
@@ -205,37 +206,13 @@ module ClassMethods
       # tracking is performed. The methods +changed?+ and +changed_in_place?+
       # will be called from ActiveModel::Dirty. See the documentation for those
       # methods in ActiveModel::Type::Value for more details.
-      def attribute(name, cast_type = nil, default: NO_DEFAULT_PROVIDED, **options)
-        name = name.to_s
-        name = attribute_aliases[name] || name
-
-        reload_schema_from_cache
-
-        case cast_type
-        when Symbol
-          cast_type = Type.lookup(cast_type, **options, adapter: Type.adapter_name_from(self))
-        when nil
-          if (prev_cast_type, prev_default = attributes_to_define_after_schema_loads[name])
-            default = prev_default if default == NO_DEFAULT_PROVIDED
-          else
-            prev_cast_type = -> subtype { subtype }
-          end
-
-          cast_type = if block_given?
-            -> subtype { yield Proc === prev_cast_type ? prev_cast_type[subtype] : prev_cast_type }
-          else
-            prev_cast_type
-          end
-        end
-
-        self.attributes_to_define_after_schema_loads =
-          attributes_to_define_after_schema_loads.merge(name => [cast_type, default])
-      end
+      #
+      #--
+      # Implemented by ActiveModel::AttributeRegistration#attribute.
 
       # This is the low level API which sits beneath +attribute+. It only
       # accepts type objects, and will do its work immediately instead of
-      # waiting for the schema to load. Automatic schema detection and
-      # ClassMethods#attribute both call this under the hood. While this method
+      # waiting for the schema to load. While this method
       # is provided so it can be used by plugin authors, application code
       # should probably use ClassMethods#attribute.
       #
@@ -260,14 +237,25 @@ def define_attribute(
         define_default_attribute(name, default, cast_type, from_user: user_provided_default)
       end
 
-      def load_schema! # :nodoc:
-        super
-        attributes_to_define_after_schema_loads.each do |name, (cast_type, default)|
-          cast_type = cast_type[type_for_attribute(name)] if Proc === cast_type
-          define_attribute(name, cast_type, default: default)
+      def _default_attributes # :nodoc:
+        @default_attributes ||= begin
+          attributes_hash = columns_hash.transform_values do |column|
+            ActiveModel::Attribute.from_database(column.name, column.default, type_for_column(column))
+          end
+
+          attribute_set = ActiveModel::AttributeSet.new(attributes_hash)
+          apply_pending_attribute_modifications(attribute_set)
+          attribute_set
         end
       end
 
+      def reload_schema_from_cache(*)
+        reset_default_attributes!
+        super
+      end
+
+      alias :reset_default_attributes :reload_schema_from_cache
+
       private
         NO_DEFAULT_PROVIDED = Object.new # :nodoc:
         private_constant :NO_DEFAULT_PROVIDED
@@ -287,6 +275,14 @@ def define_default_attribute(name, value, type, from_user:)
           end
           _default_attributes[name] = default_attribute
         end
+
+        def resolve_type_name(name, **options)
+          Type.lookup(name, **options, adapter: Type.adapter_name_from(self))
+        end
+
+        def type_for_column(column)
+          hook_attribute_type(column.name, super)
+        end
     end
   end
 end

activerecord/lib/active_record/encryption/encryptable_record.rb

@@ -84,7 +84,7 @@ def global_previous_schemes_for(scheme)
           def encrypt_attribute(name, key_provider: nil, key: nil, deterministic: false, support_unencrypted_data: nil, downcase: false, ignore_case: false, previous: [], **context_properties)
             encrypted_attributes << name.to_sym
 
-            attribute name do |cast_type|
+            decorate_attributes([name]) do |name, cast_type|
               scheme = scheme_for key_provider: key_provider, key: key, deterministic: deterministic, support_unencrypted_data: support_unencrypted_data, \
                 downcase: downcase, ignore_case: ignore_case, previous: previous, **context_properties
 

activerecord/lib/active_record/enum.rb

@@ -168,10 +168,9 @@ def self.extended(base) # :nodoc:
     end
 
     def load_schema! # :nodoc:
-      attributes_to_define_after_schema_loads.each do |name, (cast_type, _default)|
-        unless columns_hash.key?(name)
-          cast_type = cast_type[type_for_attribute(name)] if Proc === cast_type
-          raise "Unknown enum attribute '#{name}' for #{self.name}" if Enum::EnumType === cast_type
+      defined_enums.each_key do |name|
+        unless columns_hash.key?(resolve_attribute_name(name))
+          raise "Unknown enum attribute '#{name}' for #{self.name}"
         end
       end
     end
@@ -254,7 +253,9 @@ def _enum(name, values, prefix: nil, suffix: nil, scopes: true, instance_methods
         detect_enum_conflict!(name, name)
         detect_enum_conflict!(name, "#{name}=")
 
-        attribute(name, **options) do |subtype|
+        attribute(name, **options)
+
+        decorate_attributes([name]) do |name, subtype|
           subtype = subtype.subtype if EnumType === subtype
           EnumType.new(name, enum_values, subtype, raise_on_invalid_values: !validate)
         end

activerecord/lib/active_record/locking/optimistic.rb

@@ -182,14 +182,14 @@ def update_counters(id, counters)
             super
           end
 
-          def define_attribute(name, cast_type, **) # :nodoc:
-            if lock_optimistically && name == locking_column
-              cast_type = LockingType.new(cast_type)
+          private
+            def hook_attribute_type(name, cast_type)
+              if lock_optimistically && name == locking_column
+                cast_type = LockingType.new(cast_type)
+              end
+              super
             end
-            super
-          end
 
-          private
             def inherited(base)
               super
               base.class_eval do

activerecord/lib/active_record/model_schema.rb

@@ -435,11 +435,6 @@ def _returning_columns_for_insert # :nodoc:
         end
       end
 
-      def attribute_types # :nodoc:
-        load_schema
-        @attribute_types ||= Hash.new(Type.default_value)
-      end
-
       def yaml_encoder # :nodoc:
         @yaml_encoder ||= ActiveModel::AttributeSet::YAMLEncoder.new(attribute_types)
       end
@@ -493,11 +488,6 @@ def column_defaults
         @column_defaults ||= _default_attributes.deep_dup.to_hash.freeze
       end
 
-      def _default_attributes # :nodoc:
-        load_schema
-        @default_attributes ||= ActiveModel::AttributeSet.new({})
-      end
-
       # Returns an array of column names as strings.
       def column_names
         @column_names ||= columns.map(&:name).freeze
@@ -577,9 +567,7 @@ def reload_schema_from_cache(recursive = true)
           @arel_table = nil
           @column_names = nil
           @symbol_column_to_string_name_hash = nil
-          @attribute_types = nil
           @content_columns = nil
-          @default_attributes = nil
           @column_defaults = nil
           @attributes_builder = nil
           @columns = nil
@@ -616,17 +604,7 @@ def load_schema!
           columns_hash = connection.schema_cache.columns_hash(table_name)
           columns_hash = columns_hash.except(*ignored_columns) unless ignored_columns.empty?
           @columns_hash = columns_hash.freeze
-          @columns_hash.each do |name, column|
-            type = connection.lookup_cast_type_from_column(column)
-            type = _convert_type_from_options(type)
-            define_attribute(
-              name,
-              type,
-              default: column.default,
-              user_provided_default: false
-            )
-            alias_attribute :id_value, :id if name == "id"
-          end
+          alias_attribute :id_value, :id if @columns_hash.key?("id")
 
           super
         end
@@ -654,12 +632,12 @@ def compute_table_name
           end
         end
 
-        def _convert_type_from_options(type)
+        def type_for_column(column)
+          type = connection.lookup_cast_type_from_column(column)
           if immutable_strings_by_default && type.respond_to?(:to_immutable_string)
-            type.to_immutable_string
-          else
-            type
+            type = type.to_immutable_string
           end
+          type
         end
     end
   end

activerecord/lib/active_record/normalization.rb

@@ -78,10 +78,8 @@ module ClassMethods
       #
       #   User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
       def normalizes(*names, with:, apply_to_nil: false)
-        names.each do |name|
-          attribute(name) do |cast_type|
-            NormalizedValueType.new(cast_type: cast_type, normalizer: with, normalize_nil: apply_to_nil)
-          end
+        decorate_attributes(names) do |name, cast_type|
+          NormalizedValueType.new(cast_type: cast_type, normalizer: with, normalize_nil: apply_to_nil)
         end
 
         self.normalized_attributes += names.map(&:to_sym)

activerecord/test/cases/base_test.rb

@@ -128,7 +128,7 @@ def test_incomplete_schema_loading
 
     Topic.reset_column_information
 
-    Topic.connection.stub(:lookup_cast_type_from_column, ->(_) { raise "Some Error" }) do
+    Topic.connection.stub(:schema_cache, -> { raise "Some Error" }) do
       assert_raises RuntimeError do
         Topic.columns_hash
       end