activerecord_where_assoc 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e248bec95c932b0bd11743e33d38915ebc13c398
-  data.tar.gz: bea0b06ff2f9e3f61a92e4e2f0cab78daaf63b9b
+SHA256:
+  metadata.gz: 78be7fdd6b3da54253f5fe51709c258256dbe013341b69c3f0c9a23a3e2968f3
+  data.tar.gz: 69c40eabe1332c945abef850347d2b39dc4412eedc65cc02aabcd07901ef2de5
 SHA512:
-  metadata.gz: 9551db7bfb1f1219dd1c23fe9255e4ffd495a4bf6777c53619d7037b432e1b13ecafeabee6be8083d8556bca49cf6473f3fbd4ff601723a1380f953a9dee764b
-  data.tar.gz: 5b1d53119ce95d0ab40665330f63c58512818f4af16352e5eb6a7245853ed15c40c2391152aa08bb894703ef853b775c94d3302c5641ae4372d75dfbda2e91fa
+  metadata.gz: f004ca618191fe6b8841d354ef10b3e0209e6721f5d35d5ebc6aff87f13fcbf62a92e0cd42bd77ef4b87b987310a56155bab9f50b59915b361871c3d51cebe4a
+  data.tar.gz: 84da6aaedd53c494913bad518a36ca18dd717c3ac2d3dbed3af5fe78561716ad0c38af67832272ea2b26dddd0319f5ae820a1d636cea5fb14aa27a8814a2f2dc

data/ALTERNATIVES_PROBLEMS.md

@@ -21,18 +21,17 @@ Summary of the problems of the alternatives that `activerecord_where_assoc` solv
 * every alternatives (except raw SQL):
   * treat `has_one` like a `has_many`.
   * can't handle recursive associations. (ex: parent/children)
-  * no simple way of checking for more complex counts. (such as less than 5)
+  * no simple way of checking for more complex counts. (such as `less than 5`)
 * `joins` / `includes`:
   * doing `not exists` with conditions requires a `LEFT JOIN` with the conditions as part of the `ON`, which requires raw SQL.
-  * checking for 2 sets of conditions on different records of the same association won't work. (so your scopes becomes incompatible)
+  * checking for 2 sets of conditions on different records of the same association won't work. (so your scopes can be incompatible)
   * can't be used with Rails 5's `or` unless both sides do the same `joins` / `includes` / `eager_load`.
 * `joins`:
-  * `has_many` may return duplicate rows per record.
+  * `has_many` may return duplicate records.
   * using `uniq` / `distinct` to solve duplicate rows is an unexpected side-effect when this is in a scope.
 * `includes`:
   * triggers eagerloading, which makes your `scope` have unexpected bad performances if it's not necessary.
   * when using a condition, the eagerloaded records are also filtered, which is very bug-prone when in a scope.
-  * can't do `not exists` with conditions.
 * raw SQL:
   * verbose, less clear on the goal of the queries (you don't even name the association the query is about).
   * need to repeat conditions from the association / default_scope.

data/EXAMPLES.md

@@ -1,6 +1,6 @@
 Here are some example usages of the gem, along with the generated SQL. Each of those can be chained with scoping methods.
 
-Models can be found in [examples/models.md](examples/models.md). Explanation is provided in that file to be able to run these queries.
+The models can be found in [examples/models.md](examples/models.md). The comments in that file explain how to get a console to try the queries. There are also example uses of the gem for scopes.
 
 The content below is generated from running `ruby examples/examples.rb`
 

data/README.md

@@ -80,7 +80,7 @@ Post.where_assoc_not_exists(:comments, is_spam: true)
 
 ### `#where_assoc_count`
 
-This is a generalization of `#where_assoc_exists` and `#where_assoc_not_exists`. It behave behaves the same way as them, but is more flexible as it allows you to be specific about how many matches there should be. To clarify, here are equivalent examples:
+This is a generalization of `#where_assoc_exists` and `#where_assoc_not_exists`. It behaves the same way as them, but is more flexible as it allows you to be specific about how many matches there should be. To clarify, here are equivalent examples:
 
 ```ruby
 Post.where_assoc_exists(:comments, is_spam: true)
@@ -90,7 +90,12 @@ Post.where_assoc_not_exists(:comments, is_spam: true)
 Post.where_assoc_count(0, :==, :comments, is_spam: true)
 ```
 
-* 1st parameter: a number or any string of SQL to embed in the query used for the leftoperand of the comparison.
+* 1st parameter: the left side of the comparison. One of:  
+  * a number  
+  * a string of SQL to embed in the query  
+  * a range (operator must be `:==` or `:!=`)  
+    will use SQL's `BETWEEN` or `NOT BETWEEN`  
+    supports infinite ranges and exclusive end
 * 2nd parameter: the operator to use: `:<`, `:<=`, `:==`, `:!=`, `:>=`, `:>`
 * 3rd, 4th, 5th parameters are the same as the 1st, 2nd and 3rd parameters of `#where_assoc_exists`.
 * block: same as `#where_assoc_exists`' block

data/lib/active_record_where_assoc/core_logic.rb

@@ -69,16 +69,9 @@ module ActiveRecordWhereAssoc
       end
 
       nested_relation = relation_on_association(base_relation, association_name, given_scope, options, deepest_scope_mod, NestWithSumBlock)
-      operator = case operator.to_s
-                 when "=="
-                   "="
-                 when "!="
-                   "<>"
-                 else
-                   operator
-                 end
 
-      base_relation.where("(#{left_operand}) #{operator} COALESCE((#{nested_relation.to_sql}), 0)")
+      sql = sql_for_count_operator(left_operand, operator, "COALESCE((#{nested_relation.to_sql}), 0)")
+      base_relation.where(sql)
     end
 
     # Returns the receiver (with possible alterations) and a relation meant to be embed in the received.
@@ -333,5 +326,44 @@ module ActiveRecordWhereAssoc
       parent = ActiveRecordCompat.parent_reflection(reflection)
       parent && parent.macro == :has_and_belongs_to_many
     end
+
+    # Doing (SQL) BETWEEN v1 AND v2, where v2 is infinite means (SQL) >= v1. However,
+    # we place the SQL on the right side, so the operator is flipped to become v1 <= (SQL).
+    # Doing (SQL) NOT BETWEEN v1 AND v2 where v2 is infinite means (SQL) < v1. However,
+    # we place the SQL on the right side, so the operator is flipped to become v1 > (SQL).
+    RIGHT_INFINITE_RANGE_OPERATOR_MAP = { "=" => "<=", "<>" => ">" }.freeze
+    # We flip the operators to use when it's about the left-side of the range.
+    LEFT_INFINITE_RANGE_OPERATOR_MAP = Hash[RIGHT_INFINITE_RANGE_OPERATOR_MAP.map { |k, v| [k, v.tr("<>", "><")] }].freeze
+
+    RANGE_OPERATOR_MAP = { "=" => "BETWEEN", "<>" => "NOT BETWEEN" }.freeze
+
+    def self.sql_for_count_operator(left_operand, operator, right_sql)
+      operator = case operator.to_s
+                 when "=="
+                   "="
+                 when "!="
+                   "<>"
+                 else
+                   operator.to_s
+                 end
+
+      return "(#{left_operand}) #{operator} #{right_sql}" unless left_operand.is_a?(Range)
+
+      unless %w(= <>).include?(operator)
+        raise ArgumentError, "Operator should be one of '==', '=', '<>' or '!=' when using a Range not: #{operator.inspect}"
+      end
+
+      v1 = left_operand.begin || 0
+      v2 = left_operand.end || Float::INFINITY
+
+      v1 = 0 if v1 == -Float::INFINITY
+
+      return sql_for_count_operator(v1, RIGHT_INFINITE_RANGE_OPERATOR_MAP.fetch(operator), right_sql) if v2 == Float::INFINITY
+
+      # Its int or a float with no mantissa, exclude_end? means -1
+      v2 -= 1 if left_operand.exclude_end? && v2 % 1 == 0
+
+      "#{right_sql} #{RANGE_OPERATOR_MAP.fetch(operator)} #{v1} AND #{v2}"
+    end
   end
 end

data/lib/active_record_where_assoc/query_methods.rb

@@ -150,8 +150,11 @@ module ActiveRecordWhereAssoc
     # The usage is the same as with #where_assoc_exists, however, 2 arguments are inserted
     # at the beginning.
     #
-    # 1st argument: a number or any string of SQL to embed in the query used for the left
-    #               operand of the comparison.
+    # 1st argument: the left side of the comparison. One of:
+    #               a number
+    #               a string of SQL to embed in the query
+    #               a range (operator must be :== or :!=), will use BETWEEN or NOT BETWEEN
+    #                                                      supports infinite ranges and exclusive end
     # 2nd argument: the operator to use: :<, :<=, :==, :!=, :>=, :>
     # 3rd, 4th and 5th arguments: same as #where_assoc_exists' 1st, 2nd and 3rd arguments
     # block: same as #where_assoc_exists' block

data/lib/active_record_where_assoc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_where_assoc
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Maxime Handfield Lapointe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-17 00:00:00.000000000 Z
+date: 2018-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -190,7 +190,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Make ActiveRecord do conditions on your associations