activerecord_where_assoc 1.1.2 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c33267f5201fd0465cceec484dd0a2c91b3511b47289f500311e0d3a3946b28f
-  data.tar.gz: 0b1ef81c3b3106a0226ed72494523ce3a2ebb005f4b1401d6cca3917a78bfa26
+  metadata.gz: 4d915a4b0f214283acc2a6ba098018b17fc786f2b801eb2703eba31448b127b9
+  data.tar.gz: 614b3c59444a0f6676b63f2499718b16f95ac1d1b010e18e322b10d25be21e1a
 SHA512:
-  metadata.gz: 156df4226e93a9d5a8e900a71b518d42ff984a47a8917d7d807429d3b473a5f8db7d392496c8f4dfda7f0746689b9127547d238b2f875846235c9075e4789f7b
-  data.tar.gz: fbea2c6d875f87c5b04d740fb6878d1f9ece9e11ba0053d38bbe6c8cb6311b194be770ebd402bc59a2baad10c3ecac8ee9f5e2bad8f6147ea152d8e8c2a96518
+  metadata.gz: 1baf41c6ae6094045794f1c5a01c4ff3ab1218d9bc027b51e038667a76d210aa7c8819a1eb61404032fb906233400a9da2f7112a94e0610e5b546c1ef7373934
+  data.tar.gz: a1fbc573c244b8ea12cf8bd96b0de0ab248bc14ef5eeb5f1503715951e746ccae9e103fa98baee2f666c971496732bd4f938ece8d77cea6770ad1614d3feed43

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Unreleased
 
+# 1.1.4 - 2023-10-10
+
+* Add compatibility for Rails 7.1
+
+# 1.1.3 - 2022-08-16
+
+* Add support for associations defined on abstract models
+
+# 1.1.2 - 2020-12-24
+
+* Add compatibility for Rails 6.1
+
 # 1.1.1 - 2020-04-13
 
 * Fix handling for ActiveRecord's NullRelation (MyModel.none) in block and association's conditions.

data/EXAMPLES.md

@@ -1,3 +1,4 @@
+SELECT "users".* FROM "users"
 Here are some example usages of the gem, along with the generated SQL.
 
 Each of those methods can be chained with scoping methods, so they can be used on `Post`, `my_user.posts`, `Post.where('hello')` or inside a scope. Note that for the `*_sql` variants, those should preferably be used on classes only, because otherwise, it could be confusing for a reader.
@@ -107,13 +108,13 @@ User.where_assoc_exists(:posts).or(User.where_assoc_exists(:comments))
 ```
 ```sql
 SELECT "users".* FROM "users"
-WHERE ((EXISTS (
+WHERE (EXISTS (
   SELECT 1 FROM "posts"
   WHERE "posts"."author_id" = "users"."id"
-)) OR (EXISTS (
+) OR EXISTS (
   SELECT 1 FROM "comments"
   WHERE "comments"."author_id" = "users"."id"
-)))
+))
 ```
 
 ---

data/README.md

@@ -37,9 +37,8 @@ These methods have many advantages over the alternative ways of achieving the si
 
 ## Installation
 
-Rails 4.1 to 6.1 are supported with Ruby 2.1 to 2.7.
-Tested against SQLite3, PostgreSQL and MySQL. 
-The gem only depends on the `activerecord` gem.
+Rails 4.1 to 7.0 are supported with Ruby 2.1 to 3.1. Tested against SQLite3, PostgreSQL and MySQL. The gem
+only depends on the `activerecord` gem.
 
 Add this line to your application's Gemfile:
 
@@ -51,7 +50,7 @@ And then execute:
 
     $ bundle install
 
-Or install it yourself as:
+Or install it yourself with:
 
     $ gem install activerecord_where_assoc
 
@@ -235,6 +234,19 @@ It is pretty complicated to support `#limit` and `#offset` of the `has_* :throug
 
 Note that the support of `#limit` and `#offset` for the `:source` and `:through` parts is a feature. I consider `ActiveRecord` wrong for not handling them correctly.
 
+## Another recommended gem
+
+If you feel a need for this gem's feature, you may also be interested in another gem I made: [activerecord_follow_assoc](https://github.com/MaxLap/activerecord_follow_assoc).
+
+It allows you to follow an association of your choice while building a query (a scope). You start querying posts, and then you change to querying the authors of those posts. For simple cases, it's possible that both `where_assoc` and `follow_assoc` can build the query your need, but each can handle different situations. Here is an example:
+
+```ruby
+# Find every posts that have comments by an admin
+Post.where_assoc_exists([:comments, :author], &:admins)
+```
+
+This could be done with `follow_assoc`: `User.admins.follow_assoc(:comments, :post)`. But if you wanted conditions on a second association, then `follow_assoc` wouldn't work. On the other hand, if you received a scope on users and wanted their posts, then `follow_assoc` would be a nicer tool for the job. It all depends on the context where you need to do the query and what starting point you have.
+
 ## Development
 
 After checking out the repo, run `bundle install` to install dependencies.

data/lib/active_record_where_assoc/active_record_compat.rb

@@ -91,5 +91,15 @@ module ActiveRecordWhereAssoc
         reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
       end
     end
+
+    if ActiveRecord.gem_version >= Gem::Version.new("7.1.0.alpha")
+      def self.null_relation?(reflection)
+        reflection.null_relation?
+      end
+    else
+      def self.null_relation?(reflection)
+        reflection.is_a?(ActiveRecord::NullRelation)
+      end
+    end
   end
 end

data/lib/active_record_where_assoc/core_logic.rb

@@ -13,7 +13,7 @@ module ActiveRecordWhereAssoc
     # => "EXISTS (SELECT... *relation1*) OR EXISTS (SELECT... *relation2*)"
     def self.sql_for_any_exists(relations)
       relations = [relations] unless relations.is_a?(Array)
-      relations = relations.reject { |rel| rel.is_a?(ActiveRecord::NullRelation) }
+      relations = relations.reject { |rel| ActiveRecordCompat.null_relation?(rel) }
       sqls = relations.map { |rel| "EXISTS (#{rel.select('1').to_sql})" }
       if sqls.size > 1
         "(#{sqls.join(" OR ")})" # Parens needed when embedding the sql in a `where`, because the OR could make things wrong
@@ -33,7 +33,7 @@ module ActiveRecordWhereAssoc
     # => "SUM((SELECT... *relation1*)) + SUM((SELECT... *relation2*))"
     def self.sql_for_sum_of_counts(relations)
       relations = [relations] unless relations.is_a?(Array)
-      relations = relations.reject { |rel| rel.is_a?(ActiveRecord::NullRelation) }
+      relations = relations.reject { |rel| ActiveRecordCompat.null_relation?(rel) }
       # Need the double parentheses
       relations.map { |rel| "SUM((#{rel.to_sql}))" }.join(" + ").presence || "0"
     end
@@ -85,7 +85,7 @@ module ActiveRecordWhereAssoc
       end
 
       nested_relations = relations_on_association(record_class, association_names, given_conditions, options, deepest_scope_mod, NestWithSumBlock)
-      nested_relations = nested_relations.reject { |rel| rel.is_a?(ActiveRecord::NullRelation) }
+      nested_relations = nested_relations.reject { |rel| ActiveRecordCompat.null_relation?(rel) }
       nested_relations.map { |nr| "COALESCE((#{nr.to_sql}), 0)" }.join(" + ").presence || "0"
     end
 
@@ -141,7 +141,7 @@ module ActiveRecordWhereAssoc
       # Each step, we get all of the scoping lambdas that were defined on associations that apply for
       # the reflection's target
       # Basically, we start from the deepest part of the query and wrap it up
-      reflection_chain, constaints_chain = ActiveRecordCompat.chained_reflection_and_chained_constraints(final_reflection)
+      reflection_chain, constraints_chain = ActiveRecordCompat.chained_reflection_and_chained_constraints(final_reflection)
       skip_next = false
 
       reflection_chain.each_with_index do |reflection, i|
@@ -153,7 +153,7 @@ module ActiveRecordWhereAssoc
         # the 2nd part of has_and_belongs_to_many is handled at the same time as the first.
         skip_next = true if actually_has_and_belongs_to_many?(reflection)
 
-        init_scopes = initial_scopes_from_reflection(reflection_chain[i..-1], constaints_chain[i], options)
+        init_scopes = initial_scopes_from_reflection(record_class, reflection_chain[i..-1], constraints_chain[i], options)
         current_scopes = init_scopes.map do |alias_scope, current_scope, klass_scope|
           current_scope = process_association_step_limits(current_scope, reflection, record_class, options)
 
@@ -197,13 +197,13 @@ module ActiveRecordWhereAssoc
     end
 
     # Can return multiple pairs for polymorphic belongs_to, one per table to look into
-    def self.initial_scopes_from_reflection(reflection_chain, assoc_scopes, options)
+    def self.initial_scopes_from_reflection(record_class, reflection_chain, assoc_scopes, options)
       reflection = reflection_chain.first
       actual_source_reflection = user_defined_actual_source_reflection(reflection)
 
       on_poly_belongs_to = option_value(options, :poly_belongs_to) if poly_belongs_to?(actual_source_reflection)
 
-      classes_with_scope = classes_with_scope_for_reflection(reflection, options)
+      classes_with_scope = classes_with_scope_for_reflection(record_class, reflection, options)
 
       assoc_scope_allowed_lim_off = assoc_scope_to_keep_lim_off_from(reflection)
 
@@ -225,18 +225,18 @@ module ActiveRecordWhereAssoc
           # would be great, except we cannot add a given_conditions afterward because we are on the wrong "base class",
           # and we can't do #merge because of the LEW crap.
           # So we must do the joins ourself!
-          _wrapper, sub_join_contraints = wrapper_and_join_constraints(reflection)
+          _wrapper, sub_join_contraints = wrapper_and_join_constraints(record_class, reflection)
           next_reflection = reflection_chain[1]
 
           current_scope = current_scope.joins(<<-SQL)
               INNER JOIN #{next_reflection.klass.quoted_table_name} ON #{sub_join_contraints.to_sql}
           SQL
 
-          alias_scope, join_constaints = wrapper_and_join_constraints(next_reflection, habtm_other_reflection: reflection)
+          alias_scope, join_constraints = wrapper_and_join_constraints(record_class, next_reflection, habtm_other_reflection: reflection)
         elsif on_poly_belongs_to
-          alias_scope, join_constaints = wrapper_and_join_constraints(reflection, poly_belongs_to_klass: klass)
+          alias_scope, join_constraints = wrapper_and_join_constraints(record_class, reflection, poly_belongs_to_klass: klass)
         else
-          alias_scope, join_constaints = wrapper_and_join_constraints(reflection)
+          alias_scope, join_constraints = wrapper_and_join_constraints(record_class, reflection)
         end
 
         assoc_scopes.each do |callable|
@@ -256,7 +256,7 @@ module ActiveRecordWhereAssoc
           current_scope = current_scope.merge(relation)
         end
 
-        [alias_scope, current_scope.where(join_constaints), klass_scope]
+        [alias_scope, current_scope.where(join_constraints), klass_scope]
       end
     end
 
@@ -272,7 +272,7 @@ module ActiveRecordWhereAssoc
       user_defined_actual_source_reflection(reflection).scope
     end
 
-    def self.classes_with_scope_for_reflection(reflection, options)
+    def self.classes_with_scope_for_reflection(record_class, reflection, options)
       actual_source_reflection = user_defined_actual_source_reflection(reflection)
 
       if poly_belongs_to?(actual_source_reflection)
@@ -283,7 +283,15 @@ module ActiveRecordWhereAssoc
         else
           case on_poly_belongs_to
           when :pluck
-            class_names = actual_source_reflection.active_record.distinct.pluck(actual_source_reflection.foreign_type)
+            model_for_ids = actual_source_reflection.active_record
+
+            if model_for_ids.abstract_class
+              # When the reflection is defined on an abstract model, we fallback to the model
+              # on which this was called
+              model_for_ids = record_class
+            end
+
+            class_names = model_for_ids.distinct.pluck(actual_source_reflection.foreign_type)
             class_names.compact.map!(&:safe_constantize).compact
           when Array, Hash
             array = on_poly_belongs_to.to_a
@@ -326,7 +334,7 @@ module ActiveRecordWhereAssoc
       end
 
       # No need to do transformations if this is already a NullRelation
-      return current_scope if current_scope.is_a?(ActiveRecord::NullRelation)
+      return current_scope if ActiveRecordCompat.null_relation?(current_scope)
 
       current_scope = current_scope.limit(1) if reflection.macro == :has_one
 
@@ -391,7 +399,7 @@ module ActiveRecordWhereAssoc
       alias_scope
     end
 
-    def self.wrapper_and_join_constraints(reflection, options = {})
+    def self.wrapper_and_join_constraints(record_class, reflection, options = {})
       poly_belongs_to_klass = options[:poly_belongs_to_klass]
       join_keys = ActiveRecordCompat.join_keys(reflection, poly_belongs_to_klass)
 
@@ -400,6 +408,12 @@ module ActiveRecordWhereAssoc
 
       table = (poly_belongs_to_klass || reflection.klass).arel_table
       foreign_klass = reflection.send(:actual_source_reflection).active_record
+      if foreign_klass.abstract_class
+        # When the reflection is defined on an abstract model, we fallback to the model
+        # on which this was called
+        foreign_klass = record_class
+      end
+
       foreign_table = foreign_klass.arel_table
 
       habtm_other_reflection = options[:habtm_other_reflection]

data/lib/active_record_where_assoc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordWhereAssoc
-  VERSION = "1.1.2".freeze
+  VERSION = "1.1.4".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_where_assoc
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.4
 platform: ruby
 authors:
 - Maxime Handfield Lapointe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-24 00:00:00.000000000 Z
+date: 2023-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -31,6 +31,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -38,6 +41,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.6'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -190,7 +196,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: Make ActiveRecord do conditions on your associations