activerecord-virtual_attributes 1.3.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d35dc5f3ef872b957e24553488667ea6e1f948e56d741d6f5dbf5a7612dc1208
-  data.tar.gz: 8980c2297bb237b520aafd79177e727c29628b3e807349df8ec153e259f3ccb6
+  metadata.gz: f205435ff8ec8ecda2020356916188e8c145dedfd57e9e9a89c7c3c743afa57a
+  data.tar.gz: 3485ee96f78567ef4fd98eec35dc6350313c543c6e5606c1ad4191812a25d534
 SHA512:
-  metadata.gz: a42caa72fee1075051551c5c12c14b71696be135ed27eaf755936bde51b63a4953a51458ad22dd7fd40808c2aae9c661b93b0aee5e6a3d684acd85a21461f788
-  data.tar.gz: 7ca0eb7fde02046e0921a81d84735be127cd068ee554550fd4dc903da2b105f025064ab3e8a728fb9e26d2586dbd892a569eb8a6cac6557d19770a9fc28945c0
+  metadata.gz: 700653df253780ef026120bdaa639e14adc4ed2c5ee735575d6a42a8335833791ab8dff596de8195b3c07f9da68d55e535a70cd20edc7b3ed2d973cf23aab177
+  data.tar.gz: e4ae06737ca3973621e673b18388f0bc9a0012efbe2e569857de4b718a7a89ae3324f27ff3cbac91d0d7c8da6456bd36cee1161dec771b6af3f8bde0ced8f65b

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:

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

@@ -3,7 +3,41 @@
 Doing our best at supporting [SemVer](http://semver.org/) with
 a nice looking [Changelog](http://keepachangelog.com).
 
-## Version [Unreleased]
+## Version [Unreleased] <small>tbd</small>
+
+## Version [3.0.0] <small>2020-09-28</small>
+
+* fix virtual_aggregate to return a consistent 0 when calculating a sum of no records
+* fix virtual delegate to include the type column when fetching associated models for polymorphism
+* add virtual_average, virtual_minimum, and virtual_maximum
+
+## Version [2.0.0] <small>2020-05-22</small>
+
+* This is a trivial release, but because it modifies a public interface, the jump makes it look significant.
+* removed legacy virtual_column parameter support. (it is not ruby 2.7 compatible)
+* fixed warnings in ruby 2.7
+
+## Version [1.6.0] <small>2019-12-02</small>
+
+* rails 5.2 support
+* fix Arel#name error
+* Display deprecation notices for invalid associations (rather than throw an error)
+
+## 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
+* fix bin/console to now actually run
+* select no longer munges field attribute
+* support virtual attributes in left_outer_joins
 
 ## Version [1.3.1] <small>2019-06-06</small>
 
@@ -38,7 +72,12 @@ a nice looking [Changelog](http://keepachangelog.com).
 * Initial Release
 * Extracted from ManageIQ/manageiq
 
-[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.3.1...HEAD
+[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v3.0.0...HEAD
+[3.0.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v2.0.0...v3.0.0
+[2.0.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.6.0...v2.0.0
+[1.6.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.5.0...v1.6.0
+[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
 [1.2.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.1.0...v1.2.0

data/README.md

@@ -42,6 +42,11 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+
+To test with different versions of ruby, use `wwtd` gem or
+
+DB=pg BUNDLE_GEMFILE=gemfiles/gemfile_${version-52}.gemfile beer "$@"
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ManageIQ/activerecord-virtual_attributes .

data/activerecord-virtual_attributes.gemspec

@@ -28,6 +28,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "activerecord", ">= 5.0"
 
   spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "db-query-matchers", "~>0.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "simplecov"

data/bin/console

@@ -1,14 +1,11 @@
 #!/usr/bin/env ruby
 
 require "bundler/setup"
-require "virtual_attributes"
+require "active_record-virtual_attributes"
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
+# models for local testing
+require "rspec"
+Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
 
 require "irb"
 IRB.start(__FILE__)

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/init.rb

@@ -1 +1 @@
-require 'virtual_attributes'
+require 'active_record-virtual_attributes'

data/lib/active_record/virtual_attributes.rb

@@ -48,13 +48,9 @@ module ActiveRecord
       #
 
       # Compatibility method: `virtual_attribute` is a more accurate name
-      def virtual_column(name, type_or_options, **options)
-        if type_or_options.kind_of?(Hash)
-          options = options.merge(type_or_options)
-          type = options.delete(:type)
-        else
-          type = type_or_options
-        end
+      def virtual_column(name, **options)
+        type = options.delete(:type)
+        raise ArgumentError, "missing :type attribute" unless type
 
         virtual_attribute(name, type, **options)
       end
@@ -93,7 +89,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/arel_groups.rb

@@ -1,6 +1,7 @@
 # this is from https://github.com/rails/arel/pull/435
 # this allows sorting and where clauses to work with virtual_attribute columns
-if defined?(Arel::Nodes::Grouping)
+# no longer needed for rails 6.0 and up (change was merged)
+if ActiveRecord.version.to_s < "6.0" && defined?(Arel::Nodes::Grouping)
   module Arel
     module Nodes
       class Grouping

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.3.1"
+    VERSION = "3.0.0".freeze
   end
 end

data/lib/active_record/virtual_attributes/virtual_arel.rb

@@ -2,13 +2,17 @@ module ActiveRecord
   module VirtualAttributes
     # VirtualArel associates arel with an attribute
     #
-    # Model.virtual_attribute :field, :string, :arel => -> (t) { t.grouping(t[:field2]) } }
+    # Model.virtual_attribute :field, :string, :arel => ->(t) { t.grouping(t[:field2]) } }
     # Model.select(:field)
     #
     # is equivalent to:
     #
     # Model.select(Model.arel_table.grouping(Model.arel_table[:field2]).as(:field))
     # Model.attribute_supported_by_sql?(:field) # => true
+    class Arel::Nodes::Grouping
+      attr_accessor :name
+    end
+
     module VirtualArel
       extend ActiveSupport::Concern
 
@@ -21,8 +25,11 @@ module ActiveRecord
         def arel_attribute(column_name, arel_table = self.arel_table)
           load_schema
           if virtual_attribute?(column_name) && !attribute_alias?(column_name)
-            col = _virtual_arel[column_name.to_s]
-            col.call(arel_table) if col
+            if (col = _virtual_arel[column_name.to_s])
+              arel = col.call(arel_table)
+              arel.name = column_name if arel.kind_of?(Arel::Nodes::Grouping)
+              arel
+            end
           else
             super
           end

data/lib/active_record/virtual_attributes/virtual_delegates.rb

@@ -240,6 +240,7 @@ module ActiveRecord
       #     (SELECT "vms_sub"."name" FROM "vms" AS "vms_ss" WHERE "vms_ss"."id" = "vms"."src_template_id")
       #
 
+      # Based upon ActiveRecord AssociationScope.scope
       def self.select_from_alias(to_ref, col, to_model_col_name, src_model_id)
         query = if to_ref.scope
                   to_ref.klass.instance_exec(nil, &to_ref.scope)
@@ -247,6 +248,7 @@ module ActiveRecord
                   to_ref.klass.all
                 end
 
+        src_model   = to_ref.active_record
         to_table    = select_from_alias_table(to_ref.klass, src_model_id.relation)
         to_model_id = to_ref.klass.arel_attribute(to_model_col_name, to_table)
         to_column   = to_ref.klass.arel_attribute(col, to_table)
@@ -254,6 +256,13 @@ module ActiveRecord
                            .from(to_table)
                            .where(to_model_id.eq(src_model_id))
 
+        # :type is in the reflection definition (meaning it is polymorphic)
+        if to_ref.type
+          # get the class name (e.g. "Host")
+          polymorphic_type = src_model.base_class.name
+          arel = arel.where(to_ref.klass.arel_attribute(to_ref.type).eq(polymorphic_type))
+        end
+
         yield arel if block_given?
 
         Arel.sql("(#{arel.to_sql})")

data/lib/active_record/virtual_attributes/virtual_fields.rb

@@ -48,20 +48,46 @@ 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
-                h[new_includes] = {}
-              when Array
-                new_includes.each { |association| h[association] = {} }
-              when Hash
-                h.deep_merge!(new_includes)
-              end
+              merge_includes(h, replace_virtual_fields(virtual_includes(parent)))
             else
               reflection = reflect_on_association(parent.to_sym)
-              h[parent] = reflection.nil? || reflection.options[:polymorphic] ? {} : reflection.klass.replace_virtual_fields(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
+
+        # @param [Hash, Array, String, Symbol] value
+        # @return [Hash]
+        def include_to_hash(value)
+          case value
+          when String, Symbol
+            {value => {}}
+          when Array
+            value.flatten.each_with_object({}) { |k, h| h[k] = {} }
+          when nil
+            {}
+          else
+            value
+          end
+        end
+
+        # @param [Hash] hash1
+        # @param [Hash] hash2
+        def merge_includes(hash1, hash2)
+          return hash1 if hash2.blank?
+
+          hash1 = include_to_hash(hash1)
+          hash2 = include_to_hash(hash2)
+          hash1.deep_merge!(hash2) do |_k, v1, v2|
+            merge_includes(v1, v2)
+          end
+        end
       end
     end
   end
@@ -75,20 +101,142 @@ 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"
+          # 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_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
+        elsif ActiveRecord.version.to_s >= "5.2" # < 6.0
+          # preloader.rb active record 6.0
+          # else block changed to reflect how 5.2 preloaders_for_one works
+          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
+              records.group_by { |record| record.association(reflection.name).klass }.map do |rhs_klass, rs|
+                loader = preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope)
+                loader.run(self)
+                loader
+              end
+            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)
+          # preloader.rb active record 6.0
+          # since this deals with polymorphic_parent, it makes everything easier to just define it
+          def preloaders_on(association, records, scope, polymorphic_parent = false)
+            case association
+            when Hash
+              preloaders_for_hash(association, records, scope, polymorphic_parent)
+            when Symbol, String
+              preloaders_for_one(association.to_sym, records, scope, polymorphic_parent)
+            else
+              raise ArgumentError, "#{association.inspect} was not recognized for preload"
+            end
+          end
+        end
+
+        if ActiveRecord.version.to_s >= "5.2"
+          # rubocop:disable Style/BlockDelimiters, Lint/AmbiguousBlockAssociation, Style/MethodCallWithArgsParentheses
+          # preloader.rb active record 6.0
+          # changed:
+          # passing polymorphic around (and makes 5.2 more similar to 6.0)
+          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:
+          # passing polymorphic_parent to preloaders_for_reflection
+          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
 
-          loaders
+          # preloader.rb active record 6.0
+          # changed:
+          # different from 5.2. But not called outside these redefined methods here, so it works fine
+          # did add compact to fix a 5.2 double preload nil bug
+          def grouped_records(orig_association, records, polymorphic_parent)
+            h = {}
+            records.compact.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
+                # 4/24/20 we want to revert #67 once we handle all these error cases in our codebase.
+                reflection = record.class._reflect_on_association(association)
+                display_virtual_attribute_deprecation("#{record.class.name}.#{association} does not exist") if !reflection && !polymorphic_parent
+                next if !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
+
+          def display_virtual_attribute_deprecation(str)
+            short_caller = caller
+            # if debugging is turned on, don't prune the backtrace.
+            # if debugging is off, prune down to the line where the sql is executed
+            # this defaults to false and only displays 1 line number.
+            unless ActiveSupport::Deprecation.debug
+              bc = ActiveSupport::BacktraceCleaner.new
+              bc.add_silencer { |line| line =~ /virtual_fields/ }
+              bc.add_silencer { |line| line =~ /active_record/ }
+              short_caller = bc.clean(caller)
+            end
+
+            ActiveSupport::Deprecation.warn(str, short_caller)
+          end
+        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
+
+            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
@@ -100,7 +248,7 @@ module ActiveRecord
     # syntax from the original codebase.
     #
     # rubocop:disable Style/BlockDelimiters, Layout/SpaceAfterComma, Style/HashSyntax
-    # rubocop:disable Layout/AlignHash, Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:disable Layout/AlignHash
     class JoinDependency
       def instantiate(result_set, *_, &block)
         primary_key = aliases.column_alias(join_root, join_root.primary_key)
@@ -116,48 +264,7 @@ module ActiveRecord
         column_aliases = aliases.column_aliases(join_root)
 
         # New Code
-        #
-        # This monkey patches the ActiveRecord::Associations::JoinDependency to
-        # include columns into the main record that might have been added
-        # through a `select` clause.
-        #
-        # This can be seen with the following:
-        #
-        #   Vm.select(Vm.arel_table[Arel.star]).select(:some_vm_virtual_col)
-        #     .includes(:tags => {}).references(:tags => {})
-        #
-        # Which will produce a SQL SELECT statement kind of like this:
-        #
-        #   SELECT "vms".*,
-        #          (<virtual_attribute_arel>) AS some_vm_virtual_col,
-        #          "vms"."id"      AS t0_r0
-        #          "vms"."vendor"  AS t0_r1
-        #          "vms"."format"  AS t0_r1
-        #          "vms"."version" AS t0_r1
-        #          ...
-        #          "tags"."id"     AS t1_r0
-        #          "tags"."name"   AS t1_r1
-        #
-        # This is because rails is trying to reduce the number of queries
-        # needed to fetch all of the records in the include, so it grabs the
-        # columns for both of the tables together to do it.  Unfortuantely (or
-        # fortunately... depending on how you look at it), it does not remove
-        # any `.select` columns from the query that is run in the process, so
-        # that is brought along for the ride, but never used when this method
-        # instanciates the objects.
-        #
-        # The "New Code" here simply also instanciates any extra rows that
-        # might have been included in the select (virtual_columns) as well and
-        # brought back with the result set.
-        unless result_set.empty?
-          join_dep_keys         = aliases.columns.map(&:right)
-          join_root_aliases     = column_aliases.map(&:first)
-          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
-        end
+        column_aliases += select_values_from_references(column_aliases, result_set) if result_set.present?
         # End of New Code
 
         message_bus = ActiveSupport::Notifications.instrumenter
@@ -171,14 +278,64 @@ 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
 
         parents.values
       end
       # rubocop:enable Style/BlockDelimiters, Layout/SpaceAfterComma, Style/HashSyntax
-      # rubocop:enable Layout/AlignHash, Metrics/AbcSize, Metrics/MethodLength
+      # rubocop:enable Layout/AlignHash
+
+      #
+      # This monkey patches the ActiveRecord::Associations::JoinDependency to
+      # include columns into the main record that might have been added
+      # through a `select` clause.
+      #
+      # This can be seen with the following:
+      #
+      #   Vm.select(Vm.arel_table[Arel.star]).select(:some_vm_virtual_col)
+      #     .includes(:tags => {}).references(:tags)
+      #
+      # Which will produce a SQL SELECT statement kind of like this:
+      #
+      #   SELECT "vms".*,
+      #          (<virtual_attribute_arel>) AS some_vm_virtual_col,
+      #          "vms"."id"      AS t0_r0
+      #          "vms"."vendor"  AS t0_r1
+      #          "vms"."format"  AS t0_r1
+      #          "vms"."version" AS t0_r1
+      #          ...
+      #          "tags"."id"     AS t1_r0
+      #          "tags"."name"   AS t1_r1
+      #
+      # This is because rails is trying to reduce the number of queries
+      # needed to fetch all of the records in the include, so it grabs the
+      # columns for both of the tables together to do it.  Unfortunately (or
+      # fortunately... depending on how you look at it), it does not remove
+      # any `.select` columns from the query that is run in the process, so
+      # that is brought along for the ride, but never used when this method
+      # instanciates the objects.
+      #
+      # The "New Code" here simply also instanciates any extra rows that
+      # might have been included in the select (virtual_columns) as well and
+      # brought back with the result set.
+      def select_values_from_references(column_aliases, result_set)
+        join_dep_keys         = aliases.columns.map(&:right)
+        join_root_aliases     = column_aliases.map(&:first)
+        additional_attributes = result_set.first.keys
+                                          .reject { |k| join_dep_keys.include?(k) }
+                                          .reject { |k| join_root_aliases.include?(k) }
+        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
   end
 
@@ -194,43 +351,100 @@ 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.flatten!
-        fields.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
+      def build_left_outer_joins(manager, outer_joins, *rest)
+        outer_joins = klass.replace_virtual_fields(outer_joins)
+        super if outer_joins.present?
       end
 
       # 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 calculate the total of a has many relationship
       #
-      #  example 1:
+      #  example:
       #
       #    class ExtManagementSystem
       #      has_many :vms
@@ -29,18 +24,46 @@ module VirtualAttributes
       #
       #   # arel == (SELECT COUNT(*) FROM vms where ems.id = vms.ems_id)
       #
-      #  example 2:
+      def virtual_total(name, relation, options = {})
+        define_virtual_aggregate_attribute(name, relation, :count, Arel.star, options)
+        define_method(name) { (has_attribute?(name) ? self[name] : send(relation).try(:size)) || 0 }
+      end
+
+      def virtual_sum(name, relation, column, options = {})
+        define_virtual_aggregate_attribute(name, relation, :sum, column, options)
+        define_virtual_aggregate_method(name, relation, column, :sum)
+      end
+
+      def virtual_minimum(name, relation, column, options = {})
+        define_virtual_aggregate_attribute(name, relation, :minimum, column, options)
+        define_virtual_aggregate_method(name, relation, column, :min, :minimum)
+      end
+
+      def virtual_maximum(name, relation, column, options = {})
+        define_virtual_aggregate_attribute(name, relation, :maximum, column, options)
+        define_virtual_aggregate_method(name, relation, column, :max, :maximum)
+      end
+
+      def virtual_average(name, relation, column, options = {})
+        define_virtual_aggregate_attribute(name, relation, :average, column, options)
+        define_virtual_aggregate_method(name, relation, column, :average) { |values| values.count == 0 ? 0 : values.sum / values.count }
+      end
+
+      #  @param method_name
+      #    :count :average :minimum :maximum :sum
+      #
+      #  example:
       #
       #    class Hardware
       #      has_many :disks
-      #      virtual_aggregate :allocated_disk_storage, :disks, :sum, :size
+      #      virtual_sum :allocated_disk_storage, :disks, :size
       #    end
       #
       #    generates:
       #
       #    def allocated_disk_storage
       #      if disks.loaded?
-      #        disks.blank? ? nil : disks.map { |t| t.size.to_i }.sum
+      #        disks.map(&:size).compact.sum
       #      else
       #        disks.sum(:size) || 0
       #      end
@@ -51,7 +74,11 @@ module VirtualAttributes
       #    # arel => (SELECT sum("disks"."size") where "hardware"."id" = "disks"."hardware_id")
 
       def virtual_aggregate(name, relation, method_name = :sum, column = nil, options = {})
-        define_virtual_aggregate_method(name, relation, method_name, column)
+        return virtual_total(name, relation, options) if method_name == :size
+        return virtual_sum(name, relation, column, options) if method_name == :sum
+      end
+
+      def define_virtual_aggregate_attribute(name, relation, method_name, column, options)
         reflection = reflect_on_association(relation)
 
         if options.key?(:arel)
@@ -69,54 +96,59 @@ module VirtualAttributes
         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
+      def define_virtual_aggregate_method(name, relation, column, ruby_method_name, arel_method_name = ruby_method_name)
+        define_method(name) do
+          if has_attribute?(name)
+            self[name] || 0
+          elsif (rel = send(relation)).loaded?
+            values = rel.map { |t| t.send(column) }.compact
+            if block_given?
+              yield values
+            else
+              values.blank? ? nil : values.send(ruby_method_name)
+            end
+          else
+            rel.try(arel_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
+          query = t.grouping(Arel::Nodes::SqlLiteral.new(sql))
+          # add coalesce to ensure correct value comes out
+          t.grouping(Arel::Nodes::NamedFunction.new('COALESCE', [query, Arel::Nodes::SqlLiteral.new("0")]))
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-virtual_attributes
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Keenan Brock
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-06-06 00:00:00.000000000 Z
+date: 2020-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -38,6 +38,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: db-query-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -104,9 +132,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
@@ -128,7 +157,7 @@ metadata:
   homepage_uri: https://github.com/ManageIQ/activerecord-virtual_attributes
   source_code_uri: https://github.com/ManageIQ/activerecord-virtual_attributes
   changelog_uri: https://github.com/ManageIQ/activerecord-virtual_attributes/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -143,9 +172,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
+rubyforge_project:
 rubygems_version: 2.7.6.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Access non-sql attributes from sql
 test_files: []