activerecord-virtual_attributes 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90da25c212d7507da2ca2789b1151b2e7cb7cb3936411a7e92823518299141b9
-  data.tar.gz: d2a3cc1662d29fa8625dab40610950a573c0014b9739dbb260184da47afdb2ac
+  metadata.gz: e0b56d15edaf7d124492c47903569158354ff7ca1887735c706fb342c847e0a2
+  data.tar.gz: 4674998a27f163fcb2b387ace6f71d3c9c70adf6dcd64332d59219e8e34dc7d3
 SHA512:
-  metadata.gz: 78c1edd3d1a17f5f4fcd147315e37c788cdfc3add3137a4190d568cc93ab1823d9de0e46a6f57f266d248104823578d5f6a86e076228ae640c52c035922910f4
-  data.tar.gz: 19ec2fafe3553b4ff809c1aae1aa6ccfd6f303216d1c35bc4a09f30e9dda2876a48fd531d9216e0a1a566de0434c90edd58936c12027b62bc9c70eb896235b50
+  metadata.gz: 70dbabafd878355e63957c7511b1c982716b7412da8fe14ae35c24f348fa676463ef7b1894fd33380f64835b89927643e6f4b11f77703138d6d9d5bb0cad5fb5
+  data.tar.gz: 7adae59e71766f84d6ce31dc78ed633d7fb449ebf63453c40b75650eef04fbec263465b96efcf24509faba5e42cd1a8d05ce7286dfbb1235dde771a2cd65d57b

data/.travis.yml

@@ -28,11 +28,3 @@ before_script:
 - sh -c "if [ '$DB' = 'mysql2' ]; then mysql -e 'DROP DATABASE IF EXISTS virtual_attributes; CREATE DATABASE virtual_attributes;'; fi"
 after_script:
 - "./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT"
-jobs:
-  allow_failures:
-  - gemfile: gemfiles/gemfile_52.gemfile
-    env: DB=mysql2
-  - gemfile: gemfiles/gemfile_52.gemfile
-    env: DB=pg
-  - gemfile: gemfiles/gemfile_52.gemfile
-    env: DB=sqlite3

data/CHANGELOG.md

@@ -5,6 +5,12 @@ a nice looking [Changelog](http://keepachangelog.com).
 
 ## Version [Unreleased]
 
+## 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.
@@ -54,7 +60,8 @@ a nice looking [Changelog](http://keepachangelog.com).
 * Initial Release
 * Extracted from ManageIQ/manageiq
 
-[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.5.0...HEAD
+[Unreleased]: https://github.com/ManageIQ/activerecord-virtual_attributes/compare/v1.6.0...HEAD
+[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

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

@@ -1,5 +1,5 @@
 module ActiveRecord
   module VirtualAttributes
-    VERSION = "1.5.0".freeze
+    VERSION = "1.6.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_fields.rb

@@ -102,6 +102,9 @@ module ActiveRecord
     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
@@ -112,11 +115,43 @@ module ActiveRecord
               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"
+            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:
-          # since grouped_records can return a hash/array, we need to handle those 2 new cases
+          # 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|
@@ -133,7 +168,7 @@ module ActiveRecord
 
           # preloader.rb active record 6.0
           # changed:
-          # since grouped_records can return a hash/array, we need to handle those 2 new cases
+          # 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|
@@ -143,9 +178,11 @@ module ActiveRecord
 
           # 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.each do |record|
+            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:
@@ -153,8 +190,10 @@ module ActiveRecord
 
               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)
-                next if polymorphic_parent && !reflection || !record.association(association).klass
+                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
@@ -165,6 +204,21 @@ module ActiveRecord
             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)
@@ -194,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)
@@ -210,51 +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) }
-          column_aliases += if ActiveRecord.version.to_s >= "6.0"
-                              additional_attributes.map { |k| Aliases::Column.new(k, k) }
-                            else
-                              additional_attributes.map { |k| [k, k] }
-                            end
-        end
+        column_aliases += select_values_from_references(column_aliases, result_set) if result_set.present?
         # End of New Code
 
         message_bus = ActiveSupport::Notifications.instrumenter
@@ -279,7 +289,53 @@ module ActiveRecord
         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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-virtual_attributes
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Keenan Brock
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-04 00:00:00.000000000 Z
+date: 2020-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord