activerecord_where_assoc 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f470695cdbb7503ff9def8cbe5caca7f229fe2fa133227e78f44a6c6da6156bb
-  data.tar.gz: bcf122af66d2338d345f3e151e060e44a5365b0976bf790e7c066cd9ff05912f
+  metadata.gz: b4af9bc1903c723220337ad86c96b760972d233e978f4f13c4a48bff4bcaf053
+  data.tar.gz: c3ecf63db878f798fbc3bc8d670b64d6f762fedbc7bc66b736e95c7eb8702341
 SHA512:
-  metadata.gz: 666127fc2b91da590c71a8f8e95a612ad03597e5e0ee599239752ed83645e93c67de6fcedfbe70a4a9d23f2cf884ff0c6fc091036d752e40f3fffa186ef1e65f
-  data.tar.gz: 582bae5889078d7b259d20ca1e38cd061ccfced8d96e58b2323dfbccdb7ac896fdac1c37626b7d73da17490d350d63949ba73297fd20fc1b3e49fba4cea4870c
+  metadata.gz: 144fe868a09d055a6523b99e6548aef6113d17d6e69179da71c9ebaf8fd257197a7b2a39678d8385317f227a72afcc63dd17fb34190e6694c40f3380a00367ff
+  data.tar.gz: 6ff02bae5d25b71be3fdc81b095499cc9a0575cea10eb25372e0d85e541195ba186f7d43cbef5ac342ed81d95b96919e357687ef81f2d100cbdcc9462e03cf32

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Unreleased
 
+# 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/README.md

@@ -10,10 +10,10 @@ This gem makes it easy to do conditions based on the associations of your record
 ```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(...)
 ```
@@ -83,8 +83,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 +120,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

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
 
@@ -323,6 +325,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

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.1".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.1
 platform: ruby
 authors:
 - Maxime Handfield Lapointe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-24 00:00:00.000000000 Z
+date: 2020-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord