Merge pull request #50594 from Shopify/ar-marshal-define-attribute-me…

…thods

Define missing attribute methods from `method_missing`

activerecord/lib/active_record/attribute_methods.rb

@@ -63,24 +63,6 @@ def eagerly_generate_alias_attribute_methods(_new_name, _old_name) # :nodoc:
         # alias attributes in Active Record are lazily generated
       end
 
-      def generate_alias_attributes # :nodoc:
-        superclass.generate_alias_attributes unless superclass == Base
-        return if @alias_attributes_mass_generated
-
-        GeneratedAttributeMethods::LOCK.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
-      end
-
       def alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
         method_name = pattern.method_name(new_name).to_s
         target_name = pattern.method_name(old_name).to_s
@@ -120,6 +102,10 @@ def alias_attribute_method_definition(code_generator, pattern, new_name, old_nam
         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:
@@ -128,11 +114,29 @@ def define_attribute_methods # :nodoc:
         # attribute methods.
         GeneratedAttributeMethods::LOCK.synchronize do
           return false if @attribute_methods_generated
-          superclass.define_attribute_methods unless base_class?
-          super(attribute_names)
-          alias_attribute(:id_value, :id) if attribute_names.include?("id")
+
+          superclass.define_attribute_methods unless superclass == Base
+
+          unless abstract_class?
+            load_schema
+            super(attribute_names)
+            if _has_attribute?("id")
+              alias_attribute(:id_value, :id)
+            end
+          end
+
+          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
+
           @attribute_methods_generated = true
+          @alias_attributes_mass_generated = true
         end
+        true
       end
 
       def undefine_attribute_methods # :nodoc:
@@ -457,6 +461,36 @@ def accessed_fields
     end
 
     private
+      def respond_to_missing?(name, include_private = false)
+        if self.class.define_attribute_methods
+          # Some methods weren't defined yet.
+          return true if self.class.method_defined?(name)
+          return true if include_private && self.class.private_method_defined?(name)
+        end
+
+        super
+      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
+            # Some attribute methods weren't generated yet, we retry the call
+            return public_send(name, ...)
+          end
+        end
+
+        super
+      end
+
       def attribute_method?(attr_name)
         @attributes&.key?(attr_name)
       end

activerecord/lib/active_record/core.rb

@@ -769,7 +769,6 @@ def init_internals
         @strict_loading_mode = :all
 
         klass.define_attribute_methods
-        klass.generate_alias_attributes
       end
 
       def initialize_internals_callback

activerecord/lib/active_record/model_schema.rb

@@ -421,12 +421,12 @@ def attributes_builder # :nodoc:
       end
 
       def columns_hash # :nodoc:
-        load_schema
+        load_schema unless @columns_hash
         @columns_hash
       end
 
       def columns
-        load_schema
+        load_schema unless @columns
         @columns ||= columns_hash.values.freeze
       end
 
@@ -525,7 +525,7 @@ def reset_column_information
       def load_schema # :nodoc:
         return if schema_loaded?
         @load_schema_monitor.synchronize do
-          return if @columns_hash
+          return if schema_loaded?
 
           load_schema!
 

activerecord/test/cases/attribute_methods/read_test.rb

@@ -14,13 +14,19 @@ def setup
         @klass = Class.new(Class.new { def self.initialize_generated_modules; end }) do
           def self.superclass; Base; end
           def self.base_class?; true; end
+          def self.abstract_class?; false; end
+          def self.load_schema; end
 
           include ActiveRecord::AttributeMethods
 
           def self.attribute_names
             %w{ one two three }
           end
 
+          def self.attribute_types
+            {}
+          end
+
           def self.primary_key
           end
 

activerecord/test/cases/attribute_methods_test.rb

@@ -1034,11 +1034,16 @@ def name
 
     topic = topic_class.new(title: "New topic")
     assert_equal("New topic", topic.subject_to_be_undefined)
+    assert_equal true, topic_class.method_defined?(:subject_to_be_undefined)
     topic_class.undefine_attribute_methods
+    assert_equal false, topic_class.method_defined?(:subject_to_be_undefined)
 
-    assert_raises(NoMethodError, match: /undefined method `subject_to_be_undefined'/) do
-      topic.subject_to_be_undefined
-    end
+    topic.subject_to_be_undefined
+    assert_equal true, topic_class.method_defined?(:subject_to_be_undefined)
+
+    topic_class.undefine_attribute_methods
+    assert_equal true, topic.respond_to?(:subject_to_be_undefined)
+    assert_equal true, topic_class.method_defined?(:subject_to_be_undefined)
   end
 
   test "#define_attribute_methods brings back undefined aliases" do
@@ -1052,11 +1057,11 @@ def name
     assert_equal("New topic", topic.title_alias_to_be_undefined)
     topic_class.undefine_attribute_methods
 
-    assert_not_respond_to topic, :title_alias_to_be_undefined
+    assert_equal false, topic_class.method_defined?(:title_alias_to_be_undefined)
 
     topic_class.define_attribute_methods
 
-    assert_respond_to topic, :title_alias_to_be_undefined
+    assert_equal true, topic_class.method_defined?(:title_alias_to_be_undefined)
     assert_equal "New topic", topic.title_alias_to_be_undefined
   end