Merge pull request #186 from kbrock/early_definition

Early includes and arel definition

Author: jrafanie

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,14 @@ 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)
-
-          define_virtual_attribute(name, type, **options.slice(:uses, :arel))
-        end
+          type = ActiveRecord::Type.lookup(type, **options) if type.kind_of?(Symbol)
 
-        virtual_delegates_to_define.each do |method_name, (method, options)|
-          define_virtual_delegate(method_name, method, options)
+          define_virtual_attribute(name, type)
         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) if uses
-        define_virtual_arel(name, arel) if arel
       end
     end
   end

lib/active_record/virtual_attributes/virtual_arel.rb

@@ -111,7 +111,7 @@ def arel_for_virtual_attribute(column_name, table) # :nodoc:
         private
 
         def define_virtual_arel(name, arel) # :nodoc:
-          self._virtual_arel = _virtual_arel.merge(name.to_s => arel)
+          self._virtual_arel = _virtual_arel.merge(name.to_s => arel) unless arel.nil?
         end
       end
     end

lib/active_record/virtual_attributes/virtual_delegates.rb

@@ -9,16 +9,12 @@ module VirtualAttributes
     module VirtualDelegates
       extend ActiveSupport::Concern
 
-      included do
-        class_attribute :virtual_delegates_to_define, :instance_accessor => false, :default => {}
-      end
-
       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,38 +28,17 @@ 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
 
-            self.virtual_delegates_to_define =
-              virtual_delegates_to_define.merge(method_name.to_s => [method, options.merge(:to => to, :type => type)])
+            define_delegate(method_name, method, :to => to, :allow_nil => allow_nil, :default => default)
+            virtual_attribute(method_name, type, :uses => (uses || to), :arel => virtual_delegate_arel(method, to_ref), **options)
           end
         end
 
         private
 
-        # define virtual_attribute for delegates
-        #
-        # this is called at schema load time (and not at class definition time)
-        #
-        # @param  method_name [Symbol] name of the attribute on the source class to be defined
-        # @param  col [Symbol] name of the attribute on the associated class to be referenced
-        # @option options :to [Symbol] name of the association from the source class to be referenced
-        # @option options :arel [Proc] (optional and not common)
-        # @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)
-        end
-
         # see activesupport module/delegation.rb
         # rubocop:disable Style/TernaryParentheses
         def define_delegate(method_name, method, to: nil, allow_nil: nil, default: nil) # rubocop:disable Naming/MethodParameterName

lib/active_record/virtual_attributes/virtual_includes.rb

@@ -25,7 +25,7 @@ def virtual_includes(name)
         private
 
         def define_virtual_include(name, uses)
-          self._virtual_includes = _virtual_includes.merge(name.to_s => uses)
+          self._virtual_includes = _virtual_includes.merge(name.to_s => uses) unless uses.nil?
         end
       end
     end

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