Pull define_virtual_{include,arel} out of define_virtual_attribute

instead of defining arel and includes at runtime, we're defining them up front.

Introducing the arel and includes up front simplifies the virtual attribute definition
to just registering with the attributes api.

If you note, the code only uses half of the attribute call, specifically `attribute_type`.
This is causing problems in 7.2.

We simplified it to here so it will be easier in the transition to 7.2

Author: kbrock

lib/active_record/virtual_attributes.rb

@@ -56,12 +56,15 @@ def virtual_column(name, type:, **options)
         virtual_attribute(name, type, **options)
       end
 
-      def virtual_attribute(name, type, **options)
+      def virtual_attribute(name, type, uses: nil, arel: nil, **options)
         name = name.to_s
         reload_schema_from_cache
 
         self.virtual_attributes_to_define =
           virtual_attributes_to_define.merge(name => [type, options])
+
+        define_virtual_include(name, uses)
+        define_virtual_arel(name, arel)
       end
 
       #
@@ -91,20 +94,18 @@ def load_schema!
 
         virtual_attributes_to_define.each do |name, (type, options)|
           type = type.call if type.respond_to?(:call)
-          type = ActiveRecord::Type.lookup(type, **options.except(:uses, :arel)) if type.kind_of?(Symbol)
+          type = ActiveRecord::Type.lookup(type, **options) if type.kind_of?(Symbol)
 
-          define_virtual_attribute(name, type, **options.slice(:uses, :arel))
+          define_virtual_attribute(name, type)
         end
 
         virtual_delegates_to_define.each do |method_name, (method, options)|
           define_virtual_delegate(method_name, method, options)
         end
       end
 
-      def define_virtual_attribute(name, cast_type, uses: nil, arel: nil)
+      def define_virtual_attribute(name, cast_type)
         attribute_types[name.to_s] = cast_type
-        define_virtual_include(name, uses)
-        define_virtual_arel(name, arel)
       end
     end
   end

lib/active_record/virtual_attributes/virtual_delegates.rb

@@ -18,7 +18,7 @@ module ClassMethods
         # Definition
         #
 
-        def virtual_delegate(*methods, to:, type:, prefix: nil, allow_nil: nil, default: nil, **options) # rubocop:disable Naming/MethodParameterName
+        def virtual_delegate(*methods, to:, type:, prefix: nil, allow_nil: nil, default: nil, uses: nil, **options) # rubocop:disable Naming/MethodParameterName
           to = to.to_s
           if to.include?(".") && (methods.size > 1 || prefix)
             raise ArgumentError, 'Delegation only supports specifying a target method name when defining a single virtual method with no prefix'
@@ -32,8 +32,13 @@ def virtual_delegate(*methods, to:, type:, prefix: nil, allow_nil: nil, default:
           # This better supports reloading of the class and changing the definitions
           methods.each do |method|
             method_name, to, method = determine_method_names(method, to, prefix)
-            define_delegate(method_name, method, :to => to, :allow_nil => allow_nil, :default => default)
+            unless (to_ref = reflection_with_virtual(to))
+              raise ArgumentError, "Delegation needs an association. Association #{to} does not exist"
+            end
 
+            define_delegate(method_name, method, :to => to, :allow_nil => allow_nil, :default => default)
+            define_virtual_include(method_name, uses || to)
+            define_virtual_arel(method_name, virtual_delegate_arel(method, to_ref))
             self.virtual_delegates_to_define =
               virtual_delegates_to_define.merge(method_name.to_s => [method, options.merge(:to => to, :type => type)])
           end
@@ -52,16 +57,10 @@ def virtual_delegate(*methods, to:, type:, prefix: nil, allow_nil: nil, default:
         # @option options :uses [Array|Symbol|Hash] sql includes hash. (default: to)
         # @option options :type [Symbol|ActiveModel::Type::Value] type for the attribute
         def define_virtual_delegate(method_name, col, options)
-          unless (to = options[:to]) && (to_ref = reflection_with_virtual(to.to_s))
-            raise ArgumentError, 'Delegation needs an association. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter).'
-          end
-
-          col = col.to_s
           type = options[:type]
           type = ActiveRecord::Type.lookup(type) if type.kind_of?(Symbol)
 
-          arel = virtual_delegate_arel(col, to_ref)
-          define_virtual_attribute(method_name, type, :uses => (options[:uses] || to), :arel => arel)
+          define_virtual_attribute(method_name, type)
         end
 
         # see activesupport module/delegation.rb

spec/virtual_delegates_spec.rb

@@ -241,9 +241,7 @@ def self.connection
     end
 
     it "catches invalid references" do
-      TestOtherClass.virtual_delegate :col4, :to => :others, :type => :integer
-
-      expect { model.new }.to raise_error(NameError)
+      expect { TestOtherClass.virtual_delegate :col4, :to => :others, :type => :integer }.to raise_error(ArgumentError)
     end
 
     it "catches invalid column" do