Merge pull request #191 from kbrock/relation_delegate

Introduce delegation to virtual_has_many

Author: Fryguy

CHANGELOG.md

@@ -4,6 +4,10 @@ The versioning of this gem follows ActiveRecord versioning, and does not follow
 
 ## [Unreleased]
 
+## [7.1.2] - 2025-06-20
+
+* Introduce virtual_has_many :through [#191](https://github.com/ManageIQ/activerecord-virtual_attributes/pull/191)
+
 ## [7.1.1] - 2025-06-18
 
 * Deprecate virtual_delegate without a type [#188](https://github.com/ManageIQ/activerecord-virtual_attributes/pull/188)
@@ -115,7 +119,8 @@ The versioning of this gem follows ActiveRecord versioning, and does not follow
 * Initial Release
 * Extracted from ManageIQ/manageiq
 
-[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v7.1.1...HEAD
+[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v7.1.2...HEAD
+[7.1.2]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v7.1.1...v7.1.2
 [7.1.1]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v7.1.0...v7.1.1
 [7.1.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v7.0.0...v7.1.0
 [7.0.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v6.1.2...v7.0.0

lib/active_record/virtual_attributes.rb

@@ -102,7 +102,7 @@ def load_schema!
       end
 
       def define_virtual_attribute(name, cast_type, uses: nil, arel: nil)
-        attribute_types[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

lib/active_record/virtual_attributes/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module VirtualAttributes
-    VERSION = "7.1.1".freeze
+    VERSION = "7.1.2".freeze
   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 => arel)
+          self._virtual_arel = _virtual_arel.merge(name.to_s => arel)
         end
       end
     end

lib/active_record/virtual_attributes/virtual_delegates.rb

@@ -24,8 +24,8 @@ def virtual_delegate(*methods, to:, type: nil, prefix: nil, allow_nil: nil, defa
           end
 
           to = to.to_s
-          if to.include?(".") && methods.size > 1
-            raise ArgumentError, 'Delegation only supports specifying a method name when defining a single virtual method'
+          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'
           end
 
           if to.count(".") > 1
@@ -35,16 +35,11 @@ def virtual_delegate(*methods, to:, type: nil, prefix: nil, allow_nil: nil, defa
           # put method entry per method name.
           # This better supports reloading of the class and changing the definitions
           methods.each do |method|
-            method_prefix = virtual_delegate_name_prefix(prefix, to)
-            method_name = "#{method_prefix}#{method}"
-            if to.include?(".") # to => "target.method"
-              to, method = to.split(".").map(&:to_sym)
-            end
-
+            method_name, to, method = determine_method_names(method, to, prefix)
             define_delegate(method_name, method, :to => to, :allow_nil => allow_nil, :default => default)
 
             self.virtual_delegates_to_define =
-              virtual_delegates_to_define.merge(method_name => [method, options.merge(:to => to, :type => type)])
+              virtual_delegates_to_define.merge(method_name.to_s => [method, options.merge(:to => to, :type => type)])
           end
         end
 
@@ -122,8 +117,25 @@ def #{method_name}(#{definition})
         end
         # rubocop:enable Style/TernaryParentheses
 
-        def virtual_delegate_name_prefix(prefix, to) # rubocop:disable Naming/MethodParameterName
-          "#{prefix == true ? to : prefix}_" if prefix
+        # Sometimes the `to` contains the column name target.column, split it up to the source method_name and target column
+        # If `to` does specify the column name, `to` becomes the target (i.e.: association)
+        #
+        # @param column [Symbol|String] the name of the column
+        # @param to [Symbol|String]
+        # @param prefix [Boolean|Nil|Symbol]
+        # @return [Symbol, Symbol, Symbol] method_name, relation, relation's column name
+        def determine_method_names(column, to, prefix) # rubocop:disable Naming/MethodParameterName
+          method_name = column = column.to_sym
+
+          tos = to.to_s
+          if tos.include?(".") # to => "target.method"
+            to, column = tos.split(".").map(&:to_sym)
+          end
+
+          method_prefix = "#{prefix == true ? to : prefix}_" if prefix
+          method_name = "#{method_prefix}#{method_name}".to_sym
+
+          [method_name, to.to_sym, column]
         end
 
         # @param col [String] attribute name

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 => uses)
+          self._virtual_includes = _virtual_includes.merge(name.to_s => uses)
         end
       end
     end

lib/active_record/virtual_attributes/virtual_reflections.rb

@@ -9,26 +9,24 @@ module ClassMethods
         # Definition
         #
 
-        def virtual_has_one(name, options = {})
-          uses = options.delete(:uses)
+        def virtual_has_one(name, uses: nil, **options)
           reflection = ActiveRecord::Associations::Builder::HasOne.build(self, name, nil, options)
-          add_virtual_reflection(reflection, name, uses, options)
+          add_virtual_reflection(reflection, name, uses)
         end
 
-        def virtual_has_many(name, options = {})
+        def virtual_has_many(name, uses: nil, source: nil, through: nil, **options)
           define_method(:"#{name.to_s.singularize}_ids") do
             records = send(name)
             records.respond_to?(:ids) ? records.ids : records.collect(&:id)
           end
-          uses = options.delete(:uses)
+          define_delegate(name, source || name, :to => through, :allow_nil => true, :default => []) if through
           reflection = ActiveRecord::Associations::Builder::HasMany.build(self, name, nil, options)
-          add_virtual_reflection(reflection, name, uses, options)
+          add_virtual_reflection(reflection, name, uses)
         end
 
-        def virtual_belongs_to(name, options = {})
-          uses = options.delete(:uses)
+        def virtual_belongs_to(name, uses: nil, **options)
           reflection = ActiveRecord::Associations::Builder::BelongsTo.build(self, name, nil, options)
-          add_virtual_reflection(reflection, name, uses, options)
+          add_virtual_reflection(reflection, name, uses)
         end
 
         def virtual_reflection?(name)
@@ -94,7 +92,7 @@ def collect_reflections_with_virtual(association_names)
 
         private
 
-        def add_virtual_reflection(reflection, name, uses, _options)
+        def add_virtual_reflection(reflection, name, uses)
           raise ArgumentError, "macro must be specified" unless reflection
 
           reset_virtual_reflection_information

spec/db/models.rb

@@ -135,6 +135,10 @@ class Book < VirtualTotalTestBase
   has_many :photos, :as => :imageable, :class_name => "Photo"
   has_one :current_photo, -> { all.merge(Photo.order(:id => :desc)) }, :as => :imageable, :class_name => "Photo"
 
+  virtual_has_many :author_books, :through => :author, :source => :books
+  # sorry. books.books doesn't totally make sense.
+  virtual_has_many :books, :through => :author
+
   scope :ordered,   -> { order(:created_on => :desc) }
   scope :published, -> { where(:published => true)  }
   scope :wip,       -> { where(:published => false) }

spec/virtual_delegates_spec.rb

@@ -299,4 +299,43 @@ def self.connection
       expect(actual).to eq(author)
     end
   end
+
+  describe "virtual_has_many with :through" do
+    it "with :source works" do
+      Author.create_with_books(2)
+      author = Author.create_with_books(3)
+      books = author.books.order(:id)
+
+      expect(books.first.author_books.order(:id)).to eq(books)
+    end
+
+    it "without :source works" do
+      Author.create_with_books(2)
+      author = Author.create_with_books(3)
+      books = author.books.order(:id)
+
+      expect(books.first.books.order(:id)).to eq(books)
+    end
+  end
+
+  describe "#determine_method_names (private)" do
+    it "works with column and to" do
+      expect(determine_method_names("column", "relation", nil)).to eq([:column, :relation, :column])
+      expect(determine_method_names("column", "relation", true)).to eq([:relation_column, :relation, :column])
+      expect(determine_method_names("column", "relation", "pre")).to eq([:pre_column, :relation, :column])
+      expect(determine_method_names("column", "relation.column2", false)).to eq([:column, :relation, :column2])
+      expect(determine_method_names("column", "relation.column2", true)).to eq([:relation_column, :relation, :column2])
+
+      TestClass.virtual_delegate :str, :to => :ref1, :prefix => true, :type => :string
+      expect(TestClass.new.respond_to?(:ref1_str)).to eq(true)
+
+      expect do
+        TestClass.virtual_delegate :my_method, :to => "ref1.str", :prefix => true, :type => :string
+      end.to raise_exception(ArgumentError)
+    end
+  end
+
+  def determine_method_names(*args)
+    TestClass.send(:determine_method_names, *args)
+  end
 end