activerecord-virtual_attributes 3.0.0 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f205435ff8ec8ecda2020356916188e8c145dedfd57e9e9a89c7c3c743afa57a
-  data.tar.gz: 3485ee96f78567ef4fd98eec35dc6350313c543c6e5606c1ad4191812a25d534
+  metadata.gz: eb60079c2b76281f9ace2d7f4a25c9956d9c439c408b6d0df615cb8c4512a31f
+  data.tar.gz: 6eb95ac5ea930cd875c73e8fcfaca826e3f69370417489f9c074c2c90795e71e
 SHA512:
-  metadata.gz: 700653df253780ef026120bdaa639e14adc4ed2c5ee735575d6a42a8335833791ab8dff596de8195b3c07f9da68d55e535a70cd20edc7b3ed2d973cf23aab177
-  data.tar.gz: e4ae06737ca3973621e673b18388f0bc9a0012efbe2e569857de4b718a7a89ae3324f27ff3cbac91d0d7c8da6456bd36cee1161dec771b6af3f8bde0ced8f65b
+  metadata.gz: e0d8221e8ee5ce87f5082c7e3e7b821375e0da1c6109bd772c1ee01fb396de12169c3f6ac53cdddd267d7974785b81ca0047ccf4b0ed43278b79bdb84c2cd557
+  data.tar.gz: 0b980f5df648db206618fd304ac54fd69f84ed53e004226629ddcc389775686934291baaf106cf196b0fe5204107046bf437f6db12b41a632a62dba88c71b0a0

data/.codeclimate.yml

@@ -1,11 +1,14 @@
----
 version: '2'
 prepare:
   fetch:
-  - url: https://raw.githubusercontent.com/ManageIQ/guides/master/.rubocop_base.yml
+  - url: https://raw.githubusercontent.com/ManageIQ/manageiq-style/master/.rubocop_base.yml
     path: ".rubocop_base.yml"
-  - url: https://raw.githubusercontent.com/ManageIQ/guides/master/.rubocop_cc_base.yml
+  - url: https://raw.githubusercontent.com/ManageIQ/manageiq-style/master/.rubocop_cc_base.yml
     path: ".rubocop_cc_base.yml"
+  - url: https://raw.githubusercontent.com/ManageIQ/manageiq-style/master/styles/base.yml
+    path: styles/base.yml
+  - url: https://raw.githubusercontent.com/ManageIQ/manageiq-style/master/styles/cc_base.yml
+    path: styles/cc_base.yml
 checks:
   argument-count:
     enabled: false
@@ -27,6 +30,5 @@ checks:
 plugins:
   rubocop:
     enabled: true
-    channel: "rubocop-0-67"
-    config:
-      file: ".rubocop_cc.yml"
+    config: ".rubocop_cc.yml"
+    channel: rubocop-0-82

data/.github/workflows/ci.yaml

@@ -0,0 +1,74 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version:
+        - '2.7'
+    services:
+      postgres:
+        image: postgres:13
+        env:
+          POSTGRES_PASSWORD: password
+          POSTGRES_DB: virtual_attributes
+        ports:
+        - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 2s
+          --health-timeout 5s
+          --health-retries 5
+      mysql:
+        image: mysql:8.0
+        env:
+          MYSQL_ROOT_PASSWORD: password
+          MYSQL_DATABASE: virtual_attributes
+        ports:
+        - 3306:3306
+        options: >-
+          --health-cmd="mysqladmin ping -h 127.0.0.1 -P 3306 --silent"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 3
+    env:
+      # for the pg cli (psql, pg_isready) and possibly rails
+      PGHOST: localhost
+      PGPORT: 5432
+      PGUSER: postgres
+      PGPASSWORD: password
+      # for the mysql cli (mysql, mysqladmin)
+      MYSQL_HOST: 127.0.0.1
+      MYSQL_PWD: password
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - name: Run SQLite tests
+        env:
+          DB: sqlite3
+          CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+        run: bundle exec rake
+      - name: Run Postgres tests
+        env:
+          DB: pg
+          COLLATE_SYMBOLS: false
+          CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+        run: bundle exec rake
+      - name: Run MySQL tests
+        env:
+          DB: mysql2
+          CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+        run: bundle exec rake
+      - if: ${{ github.ref == 'refs/heads/master' && matrix.ruby-version == '2.7' }}
+        name: Report code coverage
+        continue-on-error: true
+        uses: paambaati/codeclimate-action@v3.0.0
+        env:
+          CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}

data/.rubocop.yml

@@ -1,3 +1,4 @@
 inherit_from:
-- https://raw.githubusercontent.com/ManageIQ/guides/master/.rubocop_base.yml
-- .rubocop_local.yml
+- ".rubocop_local.yml"
+inherit_gem:
+  manageiq-style: ".rubocop_base.yml"

data/.rubocop_cc.yml

@@ -1,4 +1,4 @@
 inherit_from:
-- .rubocop_base.yml
-- .rubocop_cc_base.yml
-- .rubocop_local.yml
+- ".rubocop_base.yml"
+- ".rubocop_cc_base.yml"
+- ".rubocop_local.yml"

data/.whitesource

@@ -0,0 +1,3 @@
+{
+  "settingsInheritedFrom": "ManageIQ/whitesource-config@master"
+}

data/CHANGELOG.md

@@ -1,29 +1,43 @@
-# Virtual Attributes Changelog
+# Change Log
 
-Doing our best at supporting [SemVer](http://semver.org/) with
-a nice looking [Changelog](http://keepachangelog.com).
+Versioning of this gem follows ActiveRecord versioning, and does not follow SemVer.
 
-## Version [Unreleased] <small>tbd</small>
+e.g.: virtual attributes 6.1.x supports all versions of rails 6.1.
 
-## Version [3.0.0] <small>2020-09-28</small>
+Use the latest version of both this gem and rails where the first 2 digits match.
+
+## [Unreleased]
+
+## [6.1.0] - 2022-02-03
+
+* **BREAKING** Dropped support for Rails 5.0, 5.1, 5.2, 6.0
+* **BREAKING** This gem will now no longer follow Semantic Versioning,
+  but instead follow Rails' versioning numbers in order to simplify version
+  matches between them both.
+* Added Rails 6.1 support
+* Ruby 3.0 compatibility: kwargs, regular expression fixes
+* changed extension mechanism from `arel_attribute()` to `arel_table[]`
+* Auto add grouping to virtual attribute arel
+
+## [3.0.0] - 2020-09-28
 
 * 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>
+## [2.0.0] - 2020-05-22
 
 * 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)
+* **BREAKING** 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>
+## [1.6.0] - 2019-12-02
 
 * 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>
+## [1.5.0] - 2019-12-02
 
 * `select()` no longer modifies `select_values`. It understands virtual attributes at a lower level.
 * `includes()` can now handle all proper values presented.
@@ -32,22 +46,22 @@ a nice looking [Changelog](http://keepachangelog.com).
 * 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>
+## [1.4.0] - 2019-07-13
 
 * 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>
+## [1.3.1] - 2019-06-06
 
 * quote column aliases
 
-## Version [1.3.0] <small>2019-05-24</small>
+## [1.3.0] - 2019-05-24
 
 * Rails 5.2 support
 
-## Version [1.2.0] <small>2019-04-23</small>
+## [1.2.0] - 2019-04-23
 
 * Virtual_delegate :type now specified to avoid rare race conditions with attribute discovery
 * Delays interpreting delegate until column is used
@@ -55,24 +69,25 @@ a nice looking [Changelog](http://keepachangelog.com).
 * More flexible includes. e.g.: Arrays of symbols now work
 * Raises errors for invalid `includes()` and `:uses`
 
-## Version [1.1.0] <small>2019-04-23</small>
+## [1.1.0] - 2019-04-23
 
 * Add legacy types for `VirtualAttribute::Types`
 * Fix rails 5.1 bug with `includes()`
 * Remove reference to `MiqPreloader`
 
-## Version [1.0.0] <small>2019-03-05</small>
+## [1.0.0] - 2019-03-05
 
 * Renamed to activerecord-virtual_attributes
 * Moved from ManageIQ to own repo
 * Added support for Rails 5.1
 
-## Version 0.1.0 <small>2019-01-17</small>
+## 0.1.0 - 2019-01-17
 
 * Initial Release
 * Extracted from ManageIQ/manageiq
 
-[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v3.0.0...HEAD
+[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v6.1.0...HEAD
+[6.1.0]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v3.0.0...v6.1.0
 [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

data/Gemfile

@@ -2,9 +2,9 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 5.0.7"
-gem "mysql2", '~> 0.4.0'
+gem "activerecord", "~> 6.1.4"
+gem "mysql2"
 gem "pg"
-gem "sqlite3", "~> 1.3.6"
+gem "sqlite3"
 
 gemspec

data/README.md

@@ -1,20 +1,16 @@
 # VirtualAttributes
 
-[![Build Status](https://travis-ci.org/ManageIQ/activerecord-virtual_attributes.svg?branch=master)](https://travis-ci.org/ManageIQ/activerecord-virtual_attributes)
+[![CI](https://github.com/ManageIQ/activerecord-virtual_attributes/actions/workflows/ci.yaml/badge.svg)](https://github.com/ManageIQ/activerecord-virtual_attributes/actions/workflows/ci.yaml)
 [![Maintainability](https://api.codeclimate.com/v1/badges/e1a0c26941c00f4edb55/maintainability)](https://codeclimate.com/github/ManageIQ/activerecord-virtual_attributes/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/e1a0c26941c00f4edb55/test_coverage)](https://codeclimate.com/github/ManageIQ/activerecord-virtual_attributes/test_coverage)
-[![Security](https://hakiri.io/github/ManageIQ/activerecord-virtual_attributes/master.svg)](https://hakiri.io/github/ManageIQ/activerecord-virtual_attributes/master)
 
-This allows you to define a ruby method that acts like an attribute or relation.
+VirtualAttributes allows you to define a ruby method that acts like an attribute or relation.
 
-Sometimes you have a model with an attribute defined in ruby, but you want to sort by it or filter by it.
-Well, to filter by that attribute, you need to fetch all the rows from the database and filter it in ruby.
-For large tables, this is slow and takes up a lot of memory
+Sometimes you have a model with an attribute defined in ruby but you want to sort or filter by it. Filtering by that attribute necessitates fetching all the rows from the database and filtering in ruby. For large tables, this is slow and takes up a lot of memory.
 
-This gem allows you to represent these attribute in sql so `ORDER BY` `WHERE` clauses will work.
+This gem allows you to represent these attributes in sql so `ORDER BY` `WHERE` clauses will work.
 
-This gem also allows you to calculate counts, and treat those counts as a field accessible with `select(:child_count)`
-to get rid of the N+1 problem of running a `count(*)` on a subcollection for each row.
+This also allows you to calculate counts and treat those as a field accessible with `select(:child_count)` to get rid of the N+1 problem of running a `count(*)` on a subcollection for each row.
 
 ## Installation
 
@@ -45,7 +41,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 To test with different versions of ruby, use `wwtd` gem or
 
-DB=pg BUNDLE_GEMFILE=gemfiles/gemfile_${version-52}.gemfile beer "$@"
+DB=pg BUNDLE_GEMFILE=gemfiles/gemfile_${version-52}.gemfile bundle exec rake
 
 ## Contributing
 

data/activerecord-virtual_attributes.gemspec

@@ -25,12 +25,12 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "activerecord", ">= 5.0"
+  spec.add_runtime_dependency "activerecord", "~> 6.1.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 "db-query-matchers"
+  spec.add_development_dependency "manageiq-style"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov", ">= 0.21.2"
 end

data/lib/active_record/virtual_attributes/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module VirtualAttributes
-    VERSION = "3.0.0".freeze
+    VERSION = "6.1.0".freeze
   end
 end

data/lib/active_record/virtual_attributes/virtual_arel.rb

@@ -9,11 +9,39 @@ module ActiveRecord
     #
     # Model.select(Model.arel_table.grouping(Model.arel_table[:field2]).as(:field))
     # Model.attribute_supported_by_sql?(:field) # => true
+
+    # in essence, this is our Arel::Nodes::VirtualAttribute
     class Arel::Nodes::Grouping
       attr_accessor :name
     end
 
     module VirtualArel
+      # This arel table proxy is our shim to get our functionality into rails
+      class ArelTableProxy < Arel::Table
+        attr_accessor :klass
+
+        # overrides Arel::Table#[]
+        # adds aliases and virtual attribute arel (aka sql)
+        #
+        # @returns Arel::Attributes::Attribute|Arel::Nodes::Grouping|Nil
+        # for regular database columns:
+        #     returns an Arel::Attribute (just like Arel::Table#[])
+        # for virtual attributes:
+        #     returns the arel for the value
+        # for non sql friendly virtual attributes:
+        #     returns nil
+        def [](name, table = self)
+          if (col_alias = @klass.attribute_alias(name))
+            name = col_alias
+          end
+          if @klass.virtual_attribute?(name)
+            @klass.arel_for_virtual_attribute(name, table)
+          else
+            super
+          end
+        end
+      end
+
       extend ActiveSupport::Concern
 
       included do
@@ -22,20 +50,19 @@ module ActiveRecord
       end
 
       module ClassMethods
-        def arel_attribute(column_name, arel_table = self.arel_table)
-          load_schema
-          if virtual_attribute?(column_name) && !attribute_alias?(column_name)
-            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
+        if ActiveRecord.version.to_s < "6.1"
+          # ActiveRecord::Core 6.0 (every version of active record seems to do this differently)
+          def arel_table
+            @arel_table ||= ArelTableProxy.new(table_name, :type_caster => type_caster).tap { |t| t.klass = self }
+          end
+        else
+          # ActiveRecord::Core 6.1
+          def arel_table
+            @arel_table ||= ArelTableProxy.new(table_name, :klass => self)
           end
         end
 
-        # supported by sql if
+        # supported by sql if any are true:
         # - it is an attribute alias
         # - it is an attribute that is non virtual
         # - it is an attribute that is virtual and has arel defined
@@ -45,9 +72,26 @@ module ActiveRecord
             (has_attribute?(name) && (!virtual_attribute?(name) || !!_virtual_arel[name.to_s]))
         end
 
+        # private api
+        #
+        # @return [Nil|Arel::Nodes::Grouping]
+        #   for virtual attributes:
+        #       returns the arel for the column
+        #   for non sql friendly virtual attributes:
+        #       returns nil
+        def arel_for_virtual_attribute(column_name, table) # :nodoc:
+          arel_lambda = _virtual_arel[column_name.to_s]
+          return unless arel_lambda
+
+          arel = arel_lambda.call(table)
+          arel = Arel::Nodes::Grouping.new(arel) unless arel.kind_of?(Arel::Nodes::Grouping)
+          arel.name = column_name
+          arel
+        end
+
         private
 
-        def define_virtual_arel(name, arel)
+        def define_virtual_arel(name, arel) # :nodoc:
           self._virtual_arel = _virtual_arel.merge(name => arel)
         end
       end

data/lib/active_record/virtual_attributes/virtual_delegates.rb

@@ -151,14 +151,9 @@ module ActiveRecord
           # There is currently no way to propagate sql over a virtual association
           if reflect_on_association(to_ref.name) && (to_ref.macro == :has_one || to_ref.macro == :belongs_to)
             lambda do |t|
-              join_keys = if ActiveRecord.version.to_s >= "5.1"
-                            to_ref.join_keys
-                          else
-                            to_ref.join_keys(to_ref.klass)
-                          end
-              src_model_id = arel_attribute(join_keys.foreign_key, t)
+              src_model_id = arel_table[to_ref.join_foreign_key, t]
               blk = ->(arel) { arel.limit = 1 } if to_ref.macro == :has_one
-              VirtualDelegates.select_from_alias(to_ref, col, join_keys.key, src_model_id, &blk)
+              VirtualDelegates.select_from_alias(to_ref, col, to_ref.join_primary_key, src_model_id, &blk)
             end
           end
         end
@@ -248,24 +243,25 @@ 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)
-        arel        = query.except(:select).select(to_column).arel
-                           .from(to_table)
-                           .where(to_model_id.eq(src_model_id))
+        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_table[to_model_col_name, to_table]
+        to_column   = to_ref.klass.arel_table[col, to_table]
+        arel = query.except(:select).select(to_column).arel
+                    .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))
+          arel = arel.where(to_ref.klass.arel_table[to_ref.type].eq(polymorphic_type))
         end
 
         yield arel if block_given?
 
-        Arel.sql("(#{arel.to_sql})")
+        # convert arel to sql to populate with bind variables
+        ::Arel::Nodes::Grouping.new(Arel.sql(arel.to_sql))
       end
 
       # determine table reference to use for a sub query

data/lib/active_record/virtual_attributes/virtual_fields.rb

@@ -101,242 +101,76 @@ module ActiveRecord
   module Associations
     class Preloader
       prepend(Module.new {
-        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
-
-          # 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"
+        # 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
+
+        # 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
+          }
         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
-
-          # 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
-
-          # 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)
+        # 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
 
-            ActiveSupport::Deprecation.warn(str, short_caller)
-          end
-        else
-          def preloaders_for_one(association, records, scope)
-            klass_map = records.compact.group_by(&:class)
+        # preloader.rb active record 6.0, 6.1
+        def grouped_records(orig_association, records, polymorphic_parent)
+          h = {}
+          records.each do |record|
+            # The virtual_field lookup can return Symbol/Nil/Other (typically a Hash)
+            #   so the case statement and the cases for Nil/Other are new
 
-            # 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
+            # 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
 
-            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))
+            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
-
-            loaders
+            (h[reflection] ||= []) << record
           end
+          h
         end
+        # rubocop:enable Style/BlockDelimiters, Lint/AmbiguousBlockAssociation, Style/MethodCallWithArgsParentheses
       })
     end
-
-    # FIXME: Hopefully we can get this into Rails core so this is no longer
-    # required in our codebase, but the rule that are broken here are mostly
-    # due to the style of the Rails codebase conflicting with our own.
-    # Ignoring them to avoid noise in RuboCop, but allow us to keep the same
-    # syntax from the original codebase.
-    #
-    # rubocop:disable Style/BlockDelimiters, Layout/SpaceAfterComma, Style/HashSyntax
-    # rubocop:disable Layout/AlignHash
-    class JoinDependency
-      def instantiate(result_set, *_, &block)
-        primary_key = aliases.column_alias(join_root, join_root.primary_key)
-
-        seen = Hash.new { |i, object_id|
-          i[object_id] = Hash.new { |j, child_class|
-            j[child_class] = {}
-          }
-        }
-
-        model_cache = Hash.new { |h,klass| h[klass] = {} }
-        parents = model_cache[join_root]
-        column_aliases = aliases.column_aliases(join_root)
-
-        # New Code
-        column_aliases += select_values_from_references(column_aliases, result_set) if result_set.present?
-        # End of New Code
-
-        message_bus = ActiveSupport::Notifications.instrumenter
-
-        payload = {
-          record_count: result_set.length,
-          class_name: join_root.base_klass.name
-        }
-
-        message_bus.instrument('instantiation.active_record', payload) do
-          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)
-            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
-
-      #
-      # 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
 
   class Relation
@@ -351,99 +185,50 @@ module ActiveRecord
 
     include(Module.new {
       # From ActiveRecord::FinderMethods
-      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
+      def apply_join_dependency(*args, **kargs, &block)
+        real = without_virtual_includes
+        if real.equal?(self)
+          super
+        else
+          real.apply_join_dependency(*args, **kargs, &block)
         end
       end
 
-      # From ActiveRecord::QueryMethods (rails 5.2 - 6.0)
+      # From ActiveRecord::QueryMethods (rails 5.2 - 6.1)
       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
-          arel.project(table[Arel.star])
-        end
-      end
-
-      # 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)
+          cols = arel_columns(select_values.uniq).map do |col|
+            # if it is a virtual attribute, then add aliases to those columns
+            if col.kind_of?(Arel::Nodes::Grouping) && col.name
+              col.as(connection.quote_column_name(col.name))
+            else
+              col
             end
-          when String
-            arel_column(field, allow_alias, &:itself)
-          when Proc
-            field.call
-          else
-            field
           end
-        end
-      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)
+          arel.project(*cols)
         else
-          yield field
+          super
         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
+      # from ActiveRecord::QueryMethods (rails 5.2 - 6.0)
+      # TODO: remove from rails 7.0
+      def arel_column(field, &block)
+        if virtual_attribute?(field) && (arel = table[field])
           arel
+        else
+          super
         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?
+      def construct_join_dependency(associations, join_type) # :nodoc:
+        associations = klass.replace_virtual_fields(associations)
+        super
       end
 
       # From ActiveRecord::Calculations
+      # introduces virtual includes support for calculate (we mostly use COUNT(*))
       def calculate(operation, attribute_name)
-        if ActiveRecord.version.to_s < "5.1"
-          if (arel = klass.arel_attribute(attribute_name)) && virtual_attribute?(attribute_name)
-            attribute_name = arel
-          end
-        end
-
         # 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

@@ -119,7 +119,7 @@ module VirtualAttributes
         # need db access for the reflection join_keys, so delaying all this key lookup until call time
         lambda do |t|
           # strings and symbols are converted across, arel objects are not
-          column = reflection.klass.arel_attribute(column) unless column.respond_to?(:count)
+          column = reflection.klass.arel_table[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))
@@ -139,11 +139,7 @@ module VirtualAttributes
 
           # 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
+          sql = conn.unprepared_statement { conn.to_sql(query) }
 
           # add () around query
           query = t.grouping(Arel::Nodes::SqlLiteral.new(sql))
@@ -155,4 +151,4 @@ module VirtualAttributes
   end
 end
 
-ActiveRecord::Base.send(:include, VirtualAttributes::VirtualTotal)
+ActiveRecord::Base.include VirtualAttributes::VirtualTotal

data/lib/active_record/virtual_attributes.rb

@@ -86,14 +86,7 @@ module ActiveRecord
       def attributes_builder # :nodoc:
         unless defined?(@attributes_builder) && @attributes_builder
           defaults = _default_attributes.except(*(column_names - [primary_key]))
-          # 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 = if ActiveRecord.version.to_s >= "5.2"
-                                  ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
-                                else
-                                  ActiveRecord::AttributeSet::Builder.new(attribute_types, defaults)
-                                end
+          @attributes_builder = ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
         end
         @attributes_builder
       end
@@ -130,22 +123,7 @@ require "active_record/virtual_attributes/virtual_fields"
 # Class extensions
 #
 
-# this patch is no longer necessary for 5.2
-if ActiveRecord.version.to_s < "5.2"
-  require "active_record/attribute"
-  module ActiveRecord
-    # This is a bug in rails 5.0 and 5.1, but it is made much worse by virtual attributes
-    class Attribute
-      def with_value_from_database(value)
-        # self.class.from_database(name, value, type)
-        initialized? ? self.class.from_database(name, value, type) : self
-      end
-    end
-  end
-end
-
 require "active_record/virtual_attributes/virtual_total"
-require "active_record/virtual_attributes/arel_groups"
 
 # legacy support for sql types
 module VirtualAttributes

metadata

@@ -1,31 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-virtual_attributes
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 6.1.0
 platform: ruby
 authors:
 - Keenan Brock
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-28 00:00:00.000000000 Z
+date: 2022-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 6.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
-  name: appraisal
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: db-query-matchers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,33 +53,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: db-query-matchers
+  name: manageiq-style
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.21.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.21.2
 description: Define attributes in arel
 email:
 - keenan@thebrocks.net
@@ -116,14 +116,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".codeclimate.yml"
+- ".github/workflows/ci.yaml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_cc.yml"
 - ".rubocop_local.yml"
-- ".travis.yml"
+- ".whitesource"
 - ".yamllint"
-- Appraisals
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -132,14 +132,9 @@ files:
 - activerecord-virtual_attributes.gemspec
 - bin/console
 - bin/setup
-- 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
-- lib/active_record/virtual_attributes/arel_groups.rb
 - lib/active_record/virtual_attributes/rspec.rb
 - lib/active_record/virtual_attributes/rspec/have_virtual_attribute.rb
 - lib/active_record/virtual_attributes/version.rb
@@ -172,8 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.6.2
+rubygems_version: 3.3.5
 signing_key:
 specification_version: 4
 summary: Access non-sql attributes from sql

data/.travis.yml

@@ -1,30 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-- 2.5.6
-- 2.6.4
-services:
-- mysql
-- postgresql
-env:
-- DB=mysql2
-- DB=pg
-- DB=sqlite3
-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:
-- curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64
-  > ./cc-test-reporter
-- chmod +x ./cc-test-reporter
-- "./cc-test-reporter before-build"
-- sh -c "if [ '$DB' = 'pg' ]; then psql -c 'DROP DATABASE IF EXISTS virtual_attributes;' ; psql -c ' CREATE DATABASE virtual_attributes;' ; fi"
-- 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"

data/Appraisals

@@ -1,23 +0,0 @@
-%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}"
-
-    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 "pg", "0.18.4"
-    end
-
-    if ar_version >= "5.2"
-      gem "sqlite3"
-    else
-      gem "sqlite3", "~> 1.3.13"
-    end
-  end
-end

data/gemfiles/gemfile_50.gemfile

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

data/gemfiles/gemfile_51.gemfile

@@ -1,10 +0,0 @@
-# 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/gemfile_52.gemfile

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

data/gemfiles/gemfile_60.gemfile

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

data/lib/active_record/virtual_attributes/arel_groups.rb

@@ -1,15 +0,0 @@
-# this is from https://github.com/rails/arel/pull/435
-# this allows sorting and where clauses to work with virtual_attribute columns
-# 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
-        include Arel::Expressions
-        include Arel::AliasPredication
-        include Arel::OrderPredications
-        include Arel::Math
-      end
-    end
-  end
-end