activerecord-virtual_attributes 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12889257087183346e6a2d382f1105adcd42dcf0d56e8cfb3174ad9bc03e93a4
-  data.tar.gz: 422aa8fc3a9115014feca968087c32f52641daaaab04db3308fe7382377b6b7d
+  metadata.gz: 90da25c212d7507da2ca2789b1151b2e7cb7cb3936411a7e92823518299141b9
+  data.tar.gz: d2a3cc1662d29fa8625dab40610950a573c0014b9739dbb260184da47afdb2ac
 SHA512:
-  metadata.gz: 92c23a0d47b390b39c1576e28ae444891dc7c4fda8b4ee493541d760aa7784442b6be95ea5f4dbd7d742feec949defd5640a5b923c755aa8162076a3fdd0700b
-  data.tar.gz: f2ee6541b6b0aaa5dcd6d25e2019bbd97ead4276495f688e71ff614463a1c818f12106a38bfb13c801e91880c8910fecd71878d9aee23f7e4c6d178010e06d91
+  metadata.gz: 78c1edd3d1a17f5f4fcd147315e37c788cdfc3add3137a4190d568cc93ab1823d9de0e46a6f57f266d248104823578d5f6a86e076228ae640c52c035922910f4
+  data.tar.gz: 19ec2fafe3553b4ff809c1aae1aa6ccfd6f303216d1c35bc4a09f30e9dda2876a48fd531d9216e0a1a566de0434c90edd58936c12027b62bc9c70eb896235b50

data/.travis.yml

@@ -1,20 +1,22 @@
 ---
+sudo: false
 language: ruby
 cache: bundler
 rvm:
-- 2.4.1
-- 2.5.3
+- 2.5.6
+- 2.6.4
 services:
-- postgresql
 - mysql
+- postgresql
 env:
-- DB=sqlite3
-- DB=pg
 - DB=mysql2
+- DB=pg
+- DB=sqlite3
 gemfile:
-- gemfiles/virtual_attributes_50.gemfile
-- gemfiles/virtual_attributes_51.gemfile
-#- gemfiles/virtual_attributes_52.gemfile
+- gemfiles/gemfile_50.gemfile
+- gemfiles/gemfile_51.gemfile
+- gemfiles/gemfile_52.gemfile
+- gemfiles/gemfile_60.gemfile
 before_install:
 - 'echo ''gem: --no-ri --no-rdoc --no-document'' > ~/.gemrc'
 before_script:
@@ -26,3 +28,11 @@ before_script:
 - sh -c "if [ '$DB' = 'mysql2' ]; then mysql -e 'DROP DATABASE IF EXISTS virtual_attributes; CREATE DATABASE virtual_attributes;'; fi"
 after_script:
 - "./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT"
+jobs:
+  allow_failures:
+  - gemfile: gemfiles/gemfile_52.gemfile
+    env: DB=mysql2
+  - gemfile: gemfiles/gemfile_52.gemfile
+    env: DB=pg
+  - gemfile: gemfiles/gemfile_52.gemfile
+    env: DB=sqlite3

data/Appraisals

@@ -1,18 +1,23 @@
-%w(5.0.7 5.1.6 5.2.0).each do |ar_version|
-  db_gem = "virtual_attributes"
-  appraise "#{db_gem}-#{ar_version.split('.').first(2).join}" do
+%w(5.0.7 5.1.7 5.2.3 6.0.0).each do |ar_version|
+  appraise "gemfile-#{ar_version.split('.').first(2).join}" do
     gem "activerecord", "~> #{ar_version}"
 
-    gem "pg"
     if ar_version >= "5.0"
       gem "mysql2"
+    elsif ar_version >= "4.2"
+      gem "mysql2", "~> 0.4.0"
+    end
+
+    if ar_version >= "5.0"
+      gem "pg"
     else
-      gem "mysql2", '~> 0.4.0'
+      gem "pg", "0.18.4"
     end
+
     if ar_version >= "5.2"
       gem "sqlite3"
     else
-      gem "sqlite3", "~> 1.3.6"
+      gem "sqlite3", "~> 1.3.13"
     end
   end
 end

data/CHANGELOG.md

@@ -5,6 +5,15 @@ a nice looking [Changelog](http://keepachangelog.com).
 
 ## Version [Unreleased]
 
+## Version [1.5.0] <small>2019-12-02</small>
+
+* `select()` no longer modifies `select_values`. It understands virtual attributes at a lower level.
+* `includes()` can now handle all proper values presented.
+* `virtual_total` added support for `has_many` `:through`
+* `virtual_total` with a nil attribute value no longer executes an extra query
+* rails 6.0 support, (rails 5.2 only fails `habtm` preloading)
+* ruby 2.6.x support (no longer testing ruby 2.4)
+
 ## Version [1.4.0] <small>2019-07-13</small>
 
 * fix includes to include all associations
@@ -45,7 +54,8 @@ a nice looking [Changelog](http://keepachangelog.com).
 * Initial Release
 * Extracted from ManageIQ/manageiq
 
-[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.4.0...HEAD
+[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.5.0...HEAD
+[1.5.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.4.0...v1.5.0
 [1.4.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.3.1...v1.4.0
 [1.3.1]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.3.0...v1.3.1
 [1.3.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.2.0...v1.3.0

data/gemfiles/{virtual_attributes_50.gemfile → gemfile_50.gemfile}

@@ -5,6 +5,6 @@ source "https://rubygems.org"
 gem "activerecord", "~> 5.0.7"
 gem "mysql2"
 gem "pg"
-gem "sqlite3", "~> 1.3.6"
+gem "sqlite3", "~> 1.3.13"
 
 gemspec path: "../"

data/gemfiles/gemfile_51.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.1.7"
+gem "mysql2"
+gem "pg"
+gem "sqlite3", "~> 1.3.13"
+
+gemspec path: "../"

data/gemfiles/{virtual_attributes_52.gemfile → gemfile_52.gemfile}

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 5.2.0"
+gem "activerecord", "~> 5.2.3"
 gem "mysql2"
 gem "pg"
 gem "sqlite3"

data/gemfiles/{virtual_attributes_51.gemfile → gemfile_60.gemfile}

@@ -2,9 +2,9 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 5.1.6"
+gem "activerecord", "~> 6.0.0"
 gem "mysql2"
 gem "pg"
-gem "sqlite3", "~> 1.3.6"
+gem "sqlite3"
 
 gemspec path: "../"

data/lib/active_record/virtual_attributes.rb

@@ -93,7 +93,11 @@ module ActiveRecord
           # change necessary for rails 5.0 and 5.1 - (changed/introduced in https://github.com/rails/rails/pull/31894)
           defaults = defaults.except(*virtual_attribute_names)
           # end change
-          @attributes_builder = ActiveRecord::AttributeSet::Builder.new(attribute_types, defaults)
+          @attributes_builder = if ActiveRecord.version.to_s >= "5.2"
+                                  ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
+                                else
+                                  ActiveRecord::AttributeSet::Builder.new(attribute_types, defaults)
+                                end
         end
         @attributes_builder
       end

data/lib/active_record/virtual_attributes/rspec/have_virtual_attribute.rb

@@ -2,7 +2,7 @@ RSpec::Matchers.define :have_virtual_attribute do |name, type|
   match do |klass|
     expect(klass.has_attribute?(name)).to be_truthy
     expect(klass.virtual_attribute?(name)).to be_truthy
-    expect(klass.type_for_attribute(name).type).to eq(type)
+    expect(klass.type_for_attribute(name.to_s).type).to(eq(type)) if type
     klass.instance_methods.include?(name.to_sym)
   end
 
@@ -13,10 +13,6 @@ RSpec::Matchers.define :have_virtual_attribute do |name, type|
   failure_message_when_negated do |klass|
     "expected #{klass.name} to not have virtual column #{name.inspect} with type #{type.inspect}"
   end
-
-  description do
-    "expect the object to have the virtual column"
-  end
 end
 
 RSpec::Matchers.alias_matcher(:have_virtual_column, :have_virtual_attribute)

data/lib/active_record/virtual_attributes/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module VirtualAttributes
-    VERSION = "1.4.0".freeze
+    VERSION = "1.5.0".freeze
   end
 end

data/lib/active_record/virtual_attributes/virtual_fields.rb

@@ -48,18 +48,16 @@ module ActiveRecord
         def replace_virtual_field_hash(associations)
           associations.each_with_object({}) do |(parent, child), h|
             if virtual_field?(parent) # form virtual_attribute => {}
-              case (new_includes = replace_virtual_fields(virtual_includes(parent)))
-              when String, Symbol
-                merge_includes(h, new_includes)
-              when Array
-                merge_includes(h, new_includes)
-              when Hash
-                merge_includes(h, new_includes)
-              end
+              merge_includes(h, replace_virtual_fields(virtual_includes(parent)))
             else
               reflection = reflect_on_association(parent.to_sym)
-              new_child = reflection.nil? || reflection.options[:polymorphic] ? {} : reflection.klass.replace_virtual_fields(child) || {}
-              merge_includes(h, parent => new_child)
+              if reflection.nil?
+                merge_includes(h, parent)
+              elsif reflection.options[:polymorphic]
+                merge_includes(h, parent => child)
+              else
+                merge_includes(h, parent => reflection.klass.replace_virtual_fields(child) || {})
+              end
             end
           end
         end
@@ -103,20 +101,88 @@ module ActiveRecord
   module Associations
     class Preloader
       prepend(Module.new {
-        def preloaders_for_one(association, records, scope)
-          klass_map = records.compact.group_by(&:class)
+        if ActiveRecord.version.to_s >= "6.0"
+          def preloaders_for_reflection(reflection, records, scope, polymorphic_parent)
+            case reflection
+            when Array
+              reflection.flat_map { |ref| preloaders_on(ref, records, scope, polymorphic_parent) }
+            when Hash
+              preloaders_on(reflection, records, scope, polymorphic_parent)
+            else
+              super(reflection, records, scope)
+            end
+          end
 
-          loaders = klass_map.keys.group_by { |klass| klass.virtual_includes(association) }.flat_map do |virtuals, klasses|
-            subset = klasses.flat_map { |klass| klass_map[klass] }
-            preload(subset, virtuals)
+          # rubocop:disable Style/BlockDelimiters, Lint/AmbiguousBlockAssociation, Style/MethodCallWithArgsParentheses
+          # preloader.rb active record 6.0
+          # changed:
+          # since grouped_records can return a hash/array, we need to handle those 2 new cases
+          def preloaders_for_hash(association, records, scope, polymorphic_parent)
+            association.flat_map { |parent, child|
+              grouped_records(parent, records, polymorphic_parent).flat_map do |reflection, reflection_records|
+                loaders = preloaders_for_reflection(reflection, reflection_records, scope, polymorphic_parent)
+                recs = loaders.flat_map(&:preloaded_records).uniq
+                child_polymorphic_parent = reflection && reflection.respond_to?(:options) && reflection.options[:polymorphic]
+                loaders.concat Array.wrap(child).flat_map { |assoc|
+                  preloaders_on assoc, recs, scope, child_polymorphic_parent
+                }
+                loaders
+              end
+            }
           end
 
-          records_with_association = klass_map.select { |k, _rs| k.reflect_on_association(association) }.flat_map { |_k, rs| rs }
-          if records_with_association.any?
-            loaders.concat(super(association, records_with_association, scope))
+          # preloader.rb active record 6.0
+          # changed:
+          # since grouped_records can return a hash/array, we need to handle those 2 new cases
+          def preloaders_for_one(association, records, scope, polymorphic_parent)
+            grouped_records(association, records, polymorphic_parent)
+              .flat_map do |reflection, reflection_records|
+                preloaders_for_reflection(reflection, reflection_records, scope, polymorphic_parent)
+              end
+          end
+
+          # preloader.rb active record 6.0
+          # changed:
+          def grouped_records(orig_association, records, polymorphic_parent)
+            h = {}
+            records.each do |record|
+              # each class can resolve virtual_{attributes,includes} differently
+              association = record.class.replace_virtual_fields(orig_association)
+              # 1 line optimization for single element array:
+              association = association.first if association.kind_of?(Array) && association.size == 1
+
+              case association
+              when Symbol, String
+                reflection = record.class._reflect_on_association(association)
+                next if polymorphic_parent && !reflection || !record.association(association).klass
+              when nil
+                next
+              else # need parent (preloaders_for_{hash,one}) to handle this Array/Hash
+                reflection = association
+              end
+              (h[reflection] ||= []) << record
+            end
+            h
           end
+          # rubocop:enable Style/BlockDelimiters, Lint/AmbiguousBlockAssociation, Style/MethodCallWithArgsParentheses
+        else
+          def preloaders_for_one(association, records, scope)
+            klass_map = records.compact.group_by(&:class)
+
+            # new logic: preload virtual fields / virtual includes
+            loaders = klass_map.keys.group_by { |klass| klass.virtual_includes(association) }.flat_map do |virtuals, klasses|
+              subset = klasses.flat_map { |klass| klass_map[klass] }
+              preload(subset, virtuals)
+            end
+            # /new logic
 
-          loaders
+            records_with_association = klass_map.select { |k, _rs| k.reflect_on_association(association) }.flat_map { |_k, rs| rs }
+            if records_with_association.any?
+              loaders.concat(super(association, records_with_association, scope))
+            end
+
+            loaders
+          end
         end
       })
     end
@@ -152,7 +218,7 @@ module ActiveRecord
         # This can be seen with the following:
         #
         #   Vm.select(Vm.arel_table[Arel.star]).select(:some_vm_virtual_col)
-        #     .includes(:tags => {}).references(:tags => {})
+        #     .includes(:tags => {}).references(:tags)
         #
         # Which will produce a SQL SELECT statement kind of like this:
         #
@@ -183,8 +249,11 @@ module ActiveRecord
           additional_attributes = result_set.first.keys
                                             .reject { |k| join_dep_keys.include?(k) }
                                             .reject { |k| join_root_aliases.include?(k) }
-                                            .map    { |k| [k, k] }
-          column_aliases += additional_attributes
+          column_aliases += if ActiveRecord.version.to_s >= "6.0"
+                              additional_attributes.map { |k| Aliases::Column.new(k, k) }
+                            else
+                              additional_attributes.map { |k| [k, k] }
+                            end
         end
         # End of New Code
 
@@ -199,7 +268,11 @@ module ActiveRecord
           result_set.each { |row_hash|
             parent_key = primary_key ? row_hash[primary_key] : row_hash
             parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
-            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+            if ActiveRecord.version.to_s < "6.0"
+              construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+            else
+              construct(parent, join_root, row_hash, seen, model_cache)
+            end
           }
         end
 
@@ -222,30 +295,83 @@ module ActiveRecord
 
     include(Module.new {
       # From ActiveRecord::FinderMethods
-      def find_with_associations(&block)
-        real = without_virtual_includes
-        if real.equal?(self)
-          super
+      if ActiveRecord.version.to_s >= "5.2"
+        def apply_join_dependency(*args, &block)
+          real = without_virtual_includes
+          if real.equal?(self)
+            super
+          else
+            real.apply_join_dependency(*args, &block)
+          end
+        end
+      else
+        def find_with_associations(&block)
+          real = without_virtual_includes
+          if real.equal?(self)
+            super
+          else
+            real.find_with_associations(&block)
+          end
+        end
+      end
+
+      # From ActiveRecord::QueryMethods (rails 5.2 - 6.0)
+      def build_select(arel)
+        if select_values.any?
+          arel.project(*arel_columns(select_values.uniq, true))
+        elsif klass.ignored_columns.any?
+          arel.project(*klass.column_names.map { |field| arel_attribute(field) })
         else
-          real.find_with_associations(&block)
+          arel.project(table[Arel.star])
         end
       end
 
-      # From ActiveRecord::QueryMethods
-      def select(*fields)
-        return super if block_given? || fields.empty?
-        # support virtual attributes by adding an alias to the sql phrase for the column
-        # it does not add an as() if the column already has an as
-        # this code is based upon _select()
-        fields = fields.flatten.map! do |field|
-          if virtual_attribute?(field) && (arel = klass.arel_attribute(field)) && arel.respond_to?(:as)
-            arel.as(connection.quote_column_name(field.to_s))
+      # from ActiveRecord::QueryMethods (rails 5.2 - 6.0)
+      def arel_columns(columns, allow_alias = false)
+        columns.flat_map do |field|
+          case field
+          when Symbol
+            arel_column(field.to_s, allow_alias) do |attr_name|
+              connection.quote_table_name(attr_name)
+            end
+          when String
+            arel_column(field, allow_alias, &:itself)
+          when Proc
+            field.call
           else
             field
           end
         end
-        # end support virtual attributes
-        super
+      end
+
+      # from ActiveRecord::QueryMethods (rails 5.2 - 6.0)
+      def arel_column(field, allow_alias = false, &block)
+        field = klass.attribute_aliases[field] || field
+        from = from_clause.name || from_clause.value
+
+        if klass.columns_hash.key?(field) && (!from || table_name_matches?(from))
+          arel_attribute(field)
+        elsif virtual_attribute?(field)
+          virtual_attribute_arel_column(field, allow_alias, &block)
+        else
+          yield field
+        end
+      end
+
+      def virtual_attribute_arel_column(field, allow_alias)
+        arel = arel_attribute(field)
+        if arel.nil?
+          yield field
+        elsif allow_alias && arel && arel.respond_to?(:as) && !arel.kind_of?(Arel::Nodes::As) && !arel.try(:alias)
+          arel.as(connection.quote_column_name(field.to_s))
+        else
+          arel
+        end
+      end
+
+      # From ActiveRecord::QueryMethods
+      def table_name_matches?(from)
+        /(?:\A|(?<!FROM)\s)(?:\b#{table.name}\b|#{connection.quote_table_name(table.name)})(?!\.)/i.match?(from.to_s)
       end
 
       # From ActiveRecord::QueryMethods
@@ -256,14 +382,13 @@ module ActiveRecord
 
       # From ActiveRecord::Calculations
       def calculate(operation, attribute_name)
-        # work around 1 until https://github.com/rails/rails/pull/25304 gets merged
-        # This allows attribute_name to be a virtual_attribute
-        if (arel = klass.arel_attribute(attribute_name)) && virtual_attribute?(attribute_name)
-          attribute_name = arel
+        if ActiveRecord.version.to_s < "5.1"
+          if (arel = klass.arel_attribute(attribute_name)) && virtual_attribute?(attribute_name)
+            attribute_name = arel
+          end
         end
-        # end work around 1
 
-        # allow calculate to work when including a virtual attribute
+        # allow calculate to work with includes and a virtual attribute
         real = without_virtual_includes
         return super if real.equal?(self)
 

data/lib/active_record/virtual_attributes/virtual_total.rb

@@ -5,14 +5,9 @@ module VirtualAttributes
     module ClassMethods
       private
 
-      # define an attribute to calculating the total of a child
-      def virtual_total(name, relation, options = {})
-        virtual_aggregate(name, relation, :size, nil, options)
-      end
-
-      # define an attribute to calculating the total of a child
+      # define an attribute to calculating the total of a has many relationship
       #
-      #  example 1:
+      #  example:
       #
       #    class ExtManagementSystem
       #      has_many :vms
@@ -29,7 +24,14 @@ module VirtualAttributes
       #
       #   # arel == (SELECT COUNT(*) FROM vms where ems.id = vms.ems_id)
       #
-      #  example 2:
+      def virtual_total(name, relation, options = {})
+        define_virtual_size_method(name, relation)
+        define_virtual_aggregate_attribute(name, relation, :count, Arel.star, options)
+      end
+
+      # define an attribute to calculate the sum of a has may relationship
+      #
+      #  example:
       #
       #    class Hardware
       #      has_many :disks
@@ -40,7 +42,7 @@ module VirtualAttributes
       #
       #    def allocated_disk_storage
       #      if disks.loaded?
-      #        disks.blank? ? nil : disks.map { |t| t.size.to_i }.sum
+      #        disks.blank? ? nil : disks.map(&:size).compact.sum
       #      else
       #        disks.sum(:size) || 0
       #      end
@@ -51,7 +53,13 @@ module VirtualAttributes
       #    # arel => (SELECT sum("disks"."size") where "hardware"."id" = "disks"."hardware_id")
 
       def virtual_aggregate(name, relation, method_name = :sum, column = nil, options = {})
+        return define_virtual_total(name, relation, options) if method_name == :size
+
         define_virtual_aggregate_method(name, relation, method_name, column)
+        define_virtual_aggregate_attribute(name, relation, method_name, column, options)
+      end
+
+      def define_virtual_aggregate_attribute(name, relation, method_name, column, options)
         reflection = reflect_on_association(relation)
 
         if options.key?(:arel)
@@ -69,54 +77,58 @@ module VirtualAttributes
         end
       end
 
+      def define_virtual_size_method(name, relation)
+        define_method(name) do
+          (has_attribute?(name) ? self[name] : send(relation).try(:size)) || 0
+        end
+      end
+
       def define_virtual_aggregate_method(name, relation, method_name, column)
-        if method_name == :size
-          define_method(name) do
-            (attribute_present?(name) ? self[name] : nil) || send(relation).try(:size) || 0
-          end
-        else
-          define_method(name) do
-            (attribute_present?(name) ? self[name] : nil) ||
-              begin
-                rel = send(relation)
-                if rel.loaded?
-                  rel.blank? ? nil : (rel.map { |t| t.send(column).to_i } || 0).send(method_name)
-                else
-                  # aggregates are not smart enough to handle virtual attributes
-                  arel_column = rel.klass.arel_attribute(column)
-                  rel.try(method_name, arel_column) || 0
-                end
-              end
+        define_method(name) do
+          if attribute_present?(name)
+            self[name]
+          elsif (rel = send(relation)).loaded?
+            rel.blank? ? nil : rel.map { |t| t.send(column) }.compact.send(method_name)
+          else
+            rel.try(method_name, column) || 0
           end
         end
       end
 
       def virtual_aggregate_arel(reflection, method_name, column)
-        return unless reflection && reflection.macro == :has_many && !reflection.options[:through]
+        return unless reflection && reflection.macro == :has_many
+
+        # need db access for the reflection join_keys, so delaying all this key lookup until call time
         lambda do |t|
-          query = if reflection.scope
-                    reflection.klass.instance_exec(nil, &reflection.scope)
-                  else
-                    reflection.klass.all
-                  end
-
-          foreign_table = reflection.klass.arel_table
-          # need db access for the keys, so delaying all this lookup until call time
-          if ActiveRecord.version.to_s >= "5.1"
-            join_keys = reflection.join_keys
-          else
-            join_keys = reflection.join_keys(reflection.klass)
-          end
-          query       = query.except(:order).where(t[join_keys.foreign_key].eq(foreign_table[join_keys.key]))
+          # strings and symbols are converted across, arel objects are not
+          column = reflection.klass.arel_attribute(column) unless column.respond_to?(:count)
+
+          # query: SELECT COUNT(*) FROM main_table JOIN foreign_table ON main_table.id = foreign_table.id JOIN ...
+          relation_query   = joins(reflection.name).select(column.send(method_name))
+          query            = relation_query.arel
+
+          # algorithm:
+          # - remove main_table from this sub query. (it is already in the primary query)
+          # - move the foreign_table from the JOIN to the FROM clause
+          # - move the main_table.id = foreign_table.id from the ON clause to the WHERE clause
+
+          # query: SELECT COUNT(*) FROM main_table [ ] JOIN ...
+          join = query.source.right.shift
+          # query: SELECT COUNT(*) FROM [foreign_table] JOIN ...
+          query.source.left = join.left
+          # query: SELECT COUNT(*) FROM foreign_table JOIN ... [WHERE main_table.id = foreign_table.id]
+          query.where(join.right.expr)
 
-          arel_column = if method_name == :size
-                          Arel.star.count
-                        else
-                          reflection.klass.arel_attribute(column).send(method_name)
-                        end
-          query       = query.select(arel_column)
+          # convert bind variables from ? to actual values. otherwise, sql is incomplete
+          conn = connection
+          sql  = if ActiveRecord.version.to_s >= "5.2"
+                   conn.unprepared_statement { conn.to_sql(query) }
+                 else
+                   conn.unprepared_statement { conn.to_sql(query, relation_query.bound_attributes) }
+                 end
 
-          t.grouping(Arel::Nodes::SqlLiteral.new(query.to_sql))
+          # add () around query
+          t.grouping(Arel::Nodes::SqlLiteral.new(sql))
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-virtual_attributes
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Keenan Brock
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-12 00:00:00.000000000 Z
+date: 2019-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -118,9 +118,10 @@ files:
 - activerecord-virtual_attributes.gemspec
 - bin/console
 - bin/setup
-- gemfiles/virtual_attributes_50.gemfile
-- gemfiles/virtual_attributes_51.gemfile
-- gemfiles/virtual_attributes_52.gemfile
+- gemfiles/gemfile_50.gemfile
+- gemfiles/gemfile_51.gemfile
+- gemfiles/gemfile_52.gemfile
+- gemfiles/gemfile_60.gemfile
 - init.rb
 - lib/active_record-virtual_attributes.rb
 - lib/active_record/virtual_attributes.rb