activerecord_where_assoc 1.1.0 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f470695cdbb7503ff9def8cbe5caca7f229fe2fa133227e78f44a6c6da6156bb
-  data.tar.gz: bcf122af66d2338d345f3e151e060e44a5365b0976bf790e7c066cd9ff05912f
+  metadata.gz: fd0fae20ed7a2ae8fac19fda0df7f70b9b6a842a6519684c66c571dbf2f57732
+  data.tar.gz: f570a564494a52517dde7aad62c79b571ab3d1e49d651f32ac2bb86b301fa4f6
 SHA512:
-  metadata.gz: 666127fc2b91da590c71a8f8e95a612ad03597e5e0ee599239752ed83645e93c67de6fcedfbe70a4a9d23f2cf884ff0c6fc091036d752e40f3fffa186ef1e65f
-  data.tar.gz: 582bae5889078d7b259d20ca1e38cd061ccfced8d96e58b2323dfbccdb7ac896fdac1c37626b7d73da17490d350d63949ba73297fd20fc1b3e49fba4cea4870c
+  metadata.gz: 240832561dd8eb5cc93ff3ebc239a0aedf8f9f79520a6404ffe6ac8f9d1b2cacd5f0057d85066ed889b62f16b5e85125acb8b943c91fa72ab0450a366d7d7569
+  data.tar.gz: 060f842df0bd69b72ac0e6f0a64ef222b347047d693046abe83a9bfdd6797109e202bcccc32f75a3e7bc4349f1b5a50c94982102571a699b113e65331ebca459

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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.
+
 # 1.1.0 - 2020-02-24
 
 * Added methods which return the SQL used by this gem: `assoc_exists_sql`, `assoc_not_exists_sql`, `compare_assoc_count_sql`, `only_assoc_count_sql`  

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

@@ -1,19 +1,17 @@
 # ActiveRecord Where Assoc
 
-[![Build Status](https://travis-ci.org/MaxLap/activerecord_where_assoc.svg?branch=master)](https://travis-ci.org/MaxLap/activerecord_where_assoc)
-[![Coverage Status](https://coveralls.io/repos/github/MaxLap/activerecord_where_assoc/badge.svg)](https://coveralls.io/github/MaxLap/activerecord_where_assoc)
+![Test supported versions](https://github.com/MaxLap/activerecord_where_assoc/workflows/Test%20supported%20versions/badge.svg)
 [![Code Climate](https://codeclimate.com/github/MaxLap/activerecord_where_assoc/badges/gpa.svg)](https://codeclimate.com/github/MaxLap/activerecord_where_assoc)
-[![Issue Count](https://codeclimate.com/github/MaxLap/activerecord_where_assoc/badges/issue_count.svg)](https://codeclimate.com/github/MaxLap/activerecord_where_assoc)
 
 This gem makes it easy to do conditions based on the associations of your records in ActiveRecord (Rails). (Using SQL's `EXISTS` operator)
 
 ```ruby
 # Find my_post's comments that were not made by an admin
 my_post.comments.where_assoc_not_exists(:author, is_admin: true).where(...)
- 
+
 # Find every posts that have comments by an admin
 Post.where_assoc_exists([:comments, :author], &:admins).where(...)
- 
+
 # Find my_user's posts that have at least 5 non-spam comments (not_spam is a scope on comments)
 my_user.posts.where_assoc_count(5, :>=, :comments) { |comments| comments.not_spam }.where(...)
 ```
@@ -39,9 +37,8 @@ These methods have many advantages over the alternative ways of achieving the si
 
 ## Installation
 
-Rails 4.1 to 6.0 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:
 
@@ -53,7 +50,7 @@ And then execute:
 
     $ bundle install
 
-Or install it yourself as:
+Or install it yourself with:
 
     $ gem install activerecord_where_assoc
 
@@ -83,8 +80,8 @@ where_assoc_not_exists(association_name, conditions, options, &block)
 where_assoc_count(left_operand, operator, association_name, conditions, options, &block)
 ```
 
-* These methods add a condition (a `#where`) to the relation that checks if the association exists (or not)  
-* You can specify condition on the association, so you could check only comments that are made by an admin.  
+* These methods add a condition (a `#where`) that checks if the association exists (or not)  
+* You can specify condition on the association, so you could check only for comments that are made by an admin.  
 * Each method returns a new relation, meaning you can chain `#where`, `#order`, `limit`, etc.  
 * common arguments:
   * association_name: the association we are doing the condition on.
@@ -120,6 +117,21 @@ where_assoc_count(left_operand, operator, association_name, conditions, options,
         supports infinite ranges and exclusive end
   * operator: one of `:<`, `:<=`, `:==`, `:!=`, `:>=`, `:>`
 
+## Intuition
+
+Here is the basic intuition for the methods:
+
+`#where_assoc_exists` filters the models, returning those *where* a record for the *association* matching a condition (by default any record in the association) *exists*.
+
+`#where_assoc_not_exists` is the exact opposite of `#where_assoc_exists`. Filters the models, returning those *where* a record for the *association* matching a condition (by default any record in the association) do *not exists*
+
+`#where_assoc_count` the more specific version of `#where_assoc_exists`. Filters the models, returning those *where* a record for the *association* matching a condition (by default any record in the association) do *not exists*
+
+The condition that you may need on the record can be quite complicated. For this reason, you can pass a block to these methods.  
+The block will receive a relation on records of the association. Your job is then to call `where` and scopes to specify what you want to exist (or to not exist if using `#where_assoc_not_exists`). 
+
+So if you have `User.where_assoc_exists(:comments) {|rel| rel.where("content ilike '%github.com%'") }`, `rel` is a relation is on `Comment`, and you are specifying what you want to exist. So now we are looking for users that made a comment containing 'github.com'.
+
 ## Usage tips
 
 ### Nested associations
@@ -222,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

@@ -2,7 +2,17 @@
 
 module ActiveRecordWhereAssoc
   module ActiveRecordCompat
-    if ActiveRecord.gem_version >= Gem::Version.new("5.1")
+    if ActiveRecord.gem_version >= Gem::Version.new("6.1.0.rc1")
+      JoinKeys = Struct.new(:key, :foreign_key)
+      def self.join_keys(reflection, poly_belongs_to_klass)
+        if poly_belongs_to_klass
+          JoinKeys.new(reflection.join_primary_key(poly_belongs_to_klass), reflection.join_foreign_key)
+        else
+          JoinKeys.new(reflection.join_primary_key, reflection.join_foreign_key)
+        end
+      end
+
+    elsif ActiveRecord.gem_version >= Gem::Version.new("5.1")
       def self.join_keys(reflection, poly_belongs_to_klass)
         if poly_belongs_to_klass
           reflection.get_join_keys(poly_belongs_to_klass)

data/lib/active_record_where_assoc/core_logic.rb

@@ -13,11 +13,12 @@ module ActiveRecordWhereAssoc
     # => "EXISTS (SELECT... *relation1*) OR EXISTS (SELECT... *relation2*)"
     def self.sql_for_any_exists(relations)
       relations = [relations] unless relations.is_a?(Array)
-      sql = relations.map { |ns| "EXISTS (#{ns.select('1').to_sql})" }.join(" OR ")
-      if relations.size > 1
-        "(#{sql})" # Needed when embedding the sql in a `where`, because the OR could make things wrong
-      elsif relations.size == 1
-        sql
+      relations = relations.reject { |rel| rel.is_a?(ActiveRecord::NullRelation) }
+      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
+      elsif sqls.size == 1
+        sqls.first
       else
         "0=1"
       end
@@ -30,10 +31,11 @@ module ActiveRecordWhereAssoc
 
     # Returns the SQL for getting the sum of of the received relations
     # => "SUM((SELECT... *relation1*)) + SUM((SELECT... *relation2*))"
-    def self.sql_for_sum_of_counts(nested_scopes)
-      nested_scopes = [nested_scopes] unless nested_scopes.is_a?(Array)
+    def self.sql_for_sum_of_counts(relations)
+      relations = [relations] unless relations.is_a?(Array)
+      relations = relations.reject { |rel| rel.is_a?(ActiveRecord::NullRelation) }
       # Need the double parentheses
-      nested_scopes.map { |ns| "SUM((#{ns.to_sql}))" }.join(" + ").presence || "0"
+      relations.map { |rel| "SUM((#{rel.to_sql}))" }.join(" + ").presence || "0"
     end
 
     # Block used when nesting associations for a where_assoc_count
@@ -83,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.map { |nr| "COALESCE((#{nr.to_sql}), 0)" }.join(" + ").presence || "0"
     end
 
@@ -139,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|
@@ -151,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)
 
@@ -195,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)
 
@@ -223,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|
@@ -254,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
 
@@ -270,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)
@@ -281,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
@@ -323,6 +333,9 @@ module ActiveRecordWhereAssoc
         return current_scope.unscope(:limit, :offset, :order)
       end
 
+      # No need to do transformations if this is already a NullRelation
+      return current_scope if current_scope.is_a?(ActiveRecord::NullRelation)
+
       current_scope = current_scope.limit(1) if reflection.macro == :has_one
 
       # Order is useless without either limit or offset
@@ -386,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)
 
@@ -395,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/relation_returning_methods.rb

@@ -58,8 +58,12 @@ module ActiveRecordWhereAssoc
   #   Post.where_assoc_exists([:comments, :replies])
   #
   # === Condition
-  # After the +association_name+ argument, you can pass additional conditions the associated
-  # record must also match to be considered as existing.
+  # After the +association_name+ argument, you can pass conditions on your association to
+  # specify which of its records you care about. For example, you could only want Posts that
+  # have a comment marked as spam, so all you care about are comments marked as spam.
+  #
+  # Another way to look at this is that you are filtering your association (using a +#where+)
+  # and checking if a record of that association is still found, and you do this for each of you records.
   #
   # This +condition+ argument is passed directly to +#where+, so you can pass in the following:
   #
@@ -91,13 +95,13 @@ module ActiveRecordWhereAssoc
   #
   # === Block
   # The block is used to add more complex conditions. The effect is the same as the condition
-  # parameter, in that these conditions must be matched for the association to be considered
-  # to exist, but lets you use any scoping methods, such as +#where+, +#joins+, nested
+  # parameter. You are specifying which records in the association you care about, but using
+  # a block lets you use any scoping methods, such as +#where+, +#joins+, nested
   # +#where_assoc_*+, scopes on the model, etc.
   #
   # Note that using +#joins+ might lead to unexpected results when using #where_assoc_count,
   # since if the joins adds rows, it will change the resulting count. It probably makes more
-  # sense to, again, use one of the +where_assoc_*+ methods.
+  # sense to, again, use one of the +where_assoc_*+ methods (they can be nested).
   #
   # There are 2 ways of using the block for adding conditions to the association.
   #

data/lib/active_record_where_assoc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordWhereAssoc
-  VERSION = "1.1.0".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.0
+  version: 1.1.3
 platform: ruby
 authors:
 - Maxime Handfield Lapointe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-24 00:00:00.000000000 Z
+date: 2022-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -80,20 +80,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  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: deep-cover
   requirement: !ruby/object:Gem::Requirement
@@ -204,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