activerecord_where_assoc 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c33267f5201fd0465cceec484dd0a2c91b3511b47289f500311e0d3a3946b28f
-  data.tar.gz: 0b1ef81c3b3106a0226ed72494523ce3a2ebb005f4b1401d6cca3917a78bfa26
+  metadata.gz: fd0fae20ed7a2ae8fac19fda0df7f70b9b6a842a6519684c66c571dbf2f57732
+  data.tar.gz: f570a564494a52517dde7aad62c79b571ab3d1e49d651f32ac2bb86b301fa4f6
 SHA512:
-  metadata.gz: 156df4226e93a9d5a8e900a71b518d42ff984a47a8917d7d807429d3b473a5f8db7d392496c8f4dfda7f0746689b9127547d238b2f875846235c9075e4789f7b
-  data.tar.gz: fbea2c6d875f87c5b04d740fb6878d1f9ece9e11ba0053d38bbe6c8cb6311b194be770ebd402bc59a2baad10c3ecac8ee9f5e2bad8f6147ea152d8e8c2a96518
+  metadata.gz: 240832561dd8eb5cc93ff3ebc239a0aedf8f9f79520a6404ffe6ac8f9d1b2cacd5f0057d85066ed889b62f16b5e85125acb8b943c91fa72ab0450a366d7d7569
+  data.tar.gz: 060f842df0bd69b72ac0e6f0a64ef222b347047d693046abe83a9bfdd6797109e202bcccc32f75a3e7bc4349f1b5a50c94982102571a699b113e65331ebca459

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Unreleased
 
+# 1.1.3 - 2022-08-16
+
+* Add support for associations defined on abstract models
+
+# 1.1.2 - 2020-12-24
+
+* Add compatiblity 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/core_logic.rb

@@ -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
@@ -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.3".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.3
 platform: ruby
 authors:
 - Maxime Handfield Lapointe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-24 00:00:00.000000000 Z
+date: 2022-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -190,7 +190,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Make ActiveRecord do conditions on your associations