activerecord_where_assoc 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78be7fdd6b3da54253f5fe51709c258256dbe013341b69c3f0c9a23a3e2968f3
-  data.tar.gz: 69c40eabe1332c945abef850347d2b39dc4412eedc65cc02aabcd07901ef2de5
+  metadata.gz: '0805c22b1a2c499a1d642f4bf4c624e31318192e2243a38ef3dca92cadce2a58'
+  data.tar.gz: bbebf2d6e4402c07a54af54fa87c25c5f94c7813e4b0cc6cc63a761bd291cb7c
 SHA512:
-  metadata.gz: f004ca618191fe6b8841d354ef10b3e0209e6721f5d35d5ebc6aff87f13fcbf62a92e0cd42bd77ef4b87b987310a56155bab9f50b59915b361871c3d51cebe4a
-  data.tar.gz: 84da6aaedd53c494913bad518a36ca18dd717c3ac2d3dbed3af5fe78561716ad0c38af67832272ea2b26dddd0319f5ae820a1d636cea5fb14aa27a8814a2f2dc
+  metadata.gz: b17588d07e22a79132e62f6341fad4b4e39106ec2b957bed866d85ae3e20c59de95efae7ea1a91cdd812111c40afda385277800a90fc33b95ec14ad5af9f9bdb
+  data.tar.gz: b34651a306ac5503fa96bf30058c00e1b071f9bcb5bc429b249c7455a2d8ec6d6fe6518c95c6060aa507f3fb59bfe44434aba4c5fc0e1ffec6b25c673209e13f

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+
+* Use `SELECT 1` instead of `SELECT 0`...  
+  ... it just seems more natural that way.
+* Bugfixes
+
+# 0.1.2
+
+* It is now possible to pass a `Range` as first argument to `#where_assoc_count`.  
+  Ex: Users that have between 10 and 20 posts
+  `User.where_assoc_count(10..20, :==, :posts)`
+  The operator in that case must be either :== or :!=.  
+  This will use `BETWEEN` and `NOT BETWEEN`.  
+  Ranges that exclude the last value, i.e. `5...10`, are also supported, resulting in `BETWEEN 5 and 9`.
+  Ranges with infinities are also supported.

data/EXAMPLES.md

@@ -2,7 +2,7 @@ Here are some example usages of the gem, along with the generated SQL. Each of t
 
 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`
+The content of this file is generated from running `ruby examples/examples.rb`
 
 -------
 
@@ -13,9 +13,9 @@ The content below is generated from running `ruby examples/examples.rb`
 Post.where_assoc_exists(:comments)
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
+SELECT "posts".* FROM "posts"
   WHERE (EXISTS (
-    SELECT 0 FROM "comments" 
+    SELECT 1 FROM "comments"
     WHERE "comments"."post_id" = "posts"."id"
   ))
 ```
@@ -27,9 +27,9 @@ SELECT "posts".* FROM "posts"
 Post.where_assoc_not_exists(:comments)
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
+SELECT "posts".* FROM "posts"
   WHERE (NOT EXISTS (
-    SELECT 0 FROM "comments" 
+    SELECT 1 FROM "comments"
     WHERE "comments"."post_id" = "posts"."id"
   ))
 ```
@@ -41,9 +41,9 @@ SELECT "posts".* FROM "posts"
 Post.where_assoc_count(50, :<=, :comments)
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
+SELECT "posts".* FROM "posts"
   WHERE ((50) <= COALESCE((
-    SELECT COUNT(*) FROM "comments" 
+    SELECT COUNT(*) FROM "comments"
     WHERE "comments"."post_id" = "posts"."id"
   ), 0))
 ```
@@ -57,9 +57,9 @@ SELECT "posts".* FROM "posts"
 my_post.comments.where_assoc_exists(:author, is_admin: true)
 ```
 ```sql
-SELECT "comments".* FROM "comments" 
+SELECT "comments".* FROM "comments"
   WHERE "comments"."post_id" = 1 AND (EXISTS (
-    SELECT 0 FROM "users" 
+    SELECT 1 FROM "users"
     WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
   ))
 ```
@@ -71,9 +71,9 @@ SELECT "comments".* FROM "comments"
 my_post.comments.where_assoc_not_exists(:author, &:admins)
 ```
 ```sql
-SELECT "comments".* FROM "comments" 
+SELECT "comments".* FROM "comments"
   WHERE "comments"."post_id" = 1 AND (NOT EXISTS (
-    SELECT 0 FROM "users" 
+    SELECT 1 FROM "users"
     WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
   ))
 ```
@@ -85,9 +85,9 @@ SELECT "comments".* FROM "comments"
 Post.where_assoc_count(5, :<=, :comments, ["is_reported = ?", true])
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
+SELECT "posts".* FROM "posts"
   WHERE ((5) <= COALESCE((
-    SELECT COUNT(*) FROM "comments" 
+    SELECT COUNT(*) FROM "comments"
     WHERE "comments"."post_id" = "posts"."id" AND (is_reported = 't')
   ), 0))
 ```
@@ -99,9 +99,9 @@ SELECT "posts".* FROM "posts"
 Post.where_assoc_exists(:author, "is_admin = 't'")
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
+SELECT "posts".* FROM "posts"
   WHERE (EXISTS (
-    SELECT 0 FROM "users" 
+    SELECT 1 FROM "users"
     WHERE "users"."id" = "posts"."author_id" AND (is_admin = 't')
   ))
 ```
@@ -113,9 +113,9 @@ SELECT "posts".* FROM "posts"
 my_post.comments.where_assoc_not_exists(:author) { admins }
 ```
 ```sql
-SELECT "comments".* FROM "comments" 
+SELECT "comments".* FROM "comments"
   WHERE "comments"."post_id" = 1 AND (NOT EXISTS (
-    SELECT 0 FROM "users" 
+    SELECT 1 FROM "users"
     WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
   ))
 ```
@@ -123,15 +123,15 @@ SELECT "comments".* FROM "comments"
 ---
 
 ```ruby
-# Posts that have at least 5 reported comments (Using block with #where)
-Post.where_assoc_count(5, :<=, :comments) { where(is_reported: true) }
+# Posts that have 5 to 10 reported comments (Using block with #where and range for count)
+Post.where_assoc_count(5..10, :==, :comments) { where(is_reported: true) }
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
-  WHERE ((5) <= COALESCE((
-    SELECT COUNT(*) FROM "comments" 
+SELECT "posts".* FROM "posts"
+  WHERE (COALESCE((
+    SELECT COUNT(*) FROM "comments"
     WHERE "comments"."post_id" = "posts"."id" AND "comments"."is_reported" = 't'
-  ), 0))
+  ), 0) BETWEEN 5 AND 10)
 ```
 
 ---
@@ -141,9 +141,9 @@ SELECT "posts".* FROM "posts"
 Comment.where_assoc_exists(:post, author_id: my_user.id)
 ```
 ```sql
-SELECT "comments".* FROM "comments" 
+SELECT "comments".* FROM "comments"
   WHERE (EXISTS (
-    SELECT 0 FROM "posts" 
+    SELECT 1 FROM "posts"
     WHERE "posts"."id" = "comments"."post_id" AND "posts"."author_id" = 1
   ))
 ```
@@ -157,11 +157,11 @@ SELECT "comments".* FROM "comments"
 Post.where_assoc_exists([:comments, :author], is_admin: true)
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
+SELECT "posts".* FROM "posts"
   WHERE (EXISTS (
-    SELECT 0 FROM "comments" 
+    SELECT 1 FROM "comments"
     WHERE "comments"."post_id" = "posts"."id" AND (EXISTS (
-      SELECT 0 FROM "users" 
+      SELECT 1 FROM "users"
       WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
     ))
   ))
@@ -174,9 +174,9 @@ SELECT "posts".* FROM "posts"
 Post.where_assoc_exists(:comments, "posts.author_id = comments.author_id")
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
+SELECT "posts".* FROM "posts"
   WHERE (EXISTS (
-    SELECT 0 FROM "comments" 
+    SELECT 1 FROM "comments"
     WHERE "comments"."post_id" = "posts"."id" AND (posts.author_id = comments.author_id)
   ))
 ```
@@ -190,11 +190,11 @@ Post.where_assoc_exists(:comments, is_reported: true) {
 }
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
+SELECT "posts".* FROM "posts"
   WHERE (EXISTS (
-    SELECT 0 FROM "comments" 
+    SELECT 1 FROM "comments"
     WHERE "comments"."post_id" = "posts"."id" AND "comments"."is_reported" = 't' AND (EXISTS (
-      SELECT 0 FROM "users" 
+      SELECT 1 FROM "users"
       WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
     ))
   ))
@@ -208,14 +208,14 @@ my_user.posts.where_assoc_exists(:comments, is_reported: true)
              .where_assoc_exists([:comments, :author], is_admin: true)
 ```
 ```sql
-SELECT "posts".* FROM "posts" 
+SELECT "posts".* FROM "posts"
   WHERE "posts"."author_id" = 1 AND (EXISTS (
-    SELECT 0 FROM "comments" 
+    SELECT 1 FROM "comments"
     WHERE "comments"."post_id" = "posts"."id" AND "comments"."is_reported" = 't'
   )) AND (EXISTS (
-    SELECT 0 FROM "comments" 
+    SELECT 1 FROM "comments"
     WHERE "comments"."post_id" = "posts"."id" AND (EXISTS (
-      SELECT 0 FROM "users" 
+      SELECT 1 FROM "users"
       WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
     ))
   ))

data/README.md

@@ -35,9 +35,9 @@ This gem is very new. If you have any feedback, good or bad, do not hesitate to
 * Suggestions to make the documentation easier to follow / more complete.
 
 
-## 0.1.0
+## 0.1
 
-Since the gem is brand new, I'm releasing 0.1.0 as a public beta before bumping to 1.0.0 once I have some feedback.
+Since the gem is brand new, I'm releasing as 0.1 before bumping to 1.0 once I have some feedback. There is an extensive test suite testing for lots of cases, making me quite confident that it can handle most of the cases you can throw at it.
 
 ## Installation
 

data/lib/active_record_where_assoc/core_logic.rb

@@ -12,7 +12,7 @@ module ActiveRecordWhereAssoc
     # Will apply the nested scope to the wrapping_scope with: where("EXISTS (SELECT... *nested_scope*)")
     # exists_prefix: raw sql prefix to the EXISTS, ex: 'NOT '
     NestWithExistsBlock = lambda do |wrapping_scope, nested_scope, exists_prefix = ""|
-      sql = "#{exists_prefix}EXISTS (#{nested_scope.select('0').to_sql})"
+      sql = "#{exists_prefix}EXISTS (#{nested_scope.select('1').to_sql})"
 
       wrapping_scope.where(sql)
     end
@@ -43,7 +43,7 @@ module ActiveRecordWhereAssoc
     # based on if a record for the specified association of the model exists.
     #
     # See #where_assoc_exists in query_methods.rb for usage details.
-    def self.do_where_assoc_exists(base_relation, association_name, given_scope = nil, options = {}, &block)
+    def self.do_where_assoc_exists(base_relation, association_name, given_scope, options, &block)
       nested_relation = relation_on_association(base_relation, association_name, given_scope, options, block, NestWithExistsBlock)
       NestWithExistsBlock.call(base_relation, nested_relation)
     end
@@ -52,7 +52,7 @@ module ActiveRecordWhereAssoc
     # based on if a record for the specified association of the model doesn't exist.
     #
     # See #where_assoc_exists in query_methods.rb for usage details.
-    def self.do_where_assoc_not_exists(base_relation, association_name, given_scope = nil, options = {}, &block)
+    def self.do_where_assoc_not_exists(base_relation, association_name, given_scope, options, &block)
       nested_relation = relation_on_association(base_relation, association_name, given_scope, options, block, NestWithExistsBlock)
       NestWithExistsBlock.call(base_relation, nested_relation, "NOT ")
     end
@@ -61,7 +61,7 @@ module ActiveRecordWhereAssoc
     # based on how many records for the specified association of the model exists.
     #
     # See #where_assoc_exists and #where_assoc_count in query_methods.rb for usage details.
-    def self.do_where_assoc_count(base_relation, left_operand, operator, association_name, given_scope = nil, options = {}, &block)
+    def self.do_where_assoc_count(base_relation, left_operand, operator, association_name, given_scope, options, &block)
       deepest_scope_mod = lambda do |deepest_scope|
         deepest_scope = apply_proc_scope(deepest_scope, block) if block
 
@@ -76,8 +76,7 @@ module ActiveRecordWhereAssoc
 
     # Returns the receiver (with possible alterations) and a relation meant to be embed in the received.
     # association_names_path: can be an array of association names or a single one
-    def self.relation_on_association(base_relation, association_names_path, given_scope = nil, options = {},
-                                     last_assoc_block = nil, nest_assocs_block = nil)
+    def self.relation_on_association(base_relation, association_names_path, given_scope, options, last_assoc_block, nest_assocs_block)
       validate_options(options)
       association_names_path = Array.wrap(association_names_path)
 
@@ -94,8 +93,7 @@ module ActiveRecordWhereAssoc
     end
 
     # Returns the receiver (with possible alterations) and a relation meant to be embed in the received.
-    def self.relation_on_one_association(base_relation, association_name, given_scope = nil, options = {},
-                                         last_assoc_block = nil, nest_assocs_block = nil)
+    def self.relation_on_one_association(base_relation, association_name, given_scope, options, last_assoc_block, nest_assocs_block)
       relation_klass = base_relation.klass
       final_reflection = fetch_reflection(relation_klass, association_name)
 
@@ -118,7 +116,7 @@ module ActiveRecordWhereAssoc
         end
 
         # the 2nd part of has_and_belongs_to_many is handled at the same time as the first.
-        skip_next = true if has_and_belongs_to_many?(reflection)
+        skip_next = true if actually_has_and_belongs_to_many?(reflection)
 
         wrapper_scope, current_scope = initial_scope_from_reflection(reflection_chain[i..-1], constaints_chain[i])
 
@@ -160,11 +158,11 @@ module ActiveRecordWhereAssoc
       reflection = reflection_chain.first
       current_scope = reflection.klass.default_scoped
 
-      if has_and_belongs_to_many?(reflection)
+      if actually_has_and_belongs_to_many?(reflection)
         # has_and_belongs_to_many, behind the scene has a secret model and uses a has_many through.
         # This is the first of those two secret has_many through.
         #
-        # In order to handle limit, offset, order correctly on has_and_belongs_to_man,
+        # In order to handle limit, offset, order correctly on has_and_belongs_to_many,
         # we must do both this reflection and the next one at the same time.
         # Think of it this way, if you have limit 3:
         #   Apply only on 1st step: You check that any of 2nd step for the first 3 of 1st step match
@@ -210,22 +208,19 @@ module ActiveRecordWhereAssoc
     end
 
     def self.constraint_allowed_lim_off_from(reflection)
-      if has_and_belongs_to_many?(reflection)
-        reflection.scope
-      else
-        # For :through associations, it's pretty hard/tricky to apply limit/offset/order of the
-        # whole has_* :through. For now, we only do the direct associations from one model to another
-        # that the :through uses and we ignore the limit from the scope of has_* :through.
-        #
-        # For :through associations, #actual_source_reflection returns final non-through
-        # reflection that is reached by following the :source.
-        # Otherwise, returns itself.
-        reflection.send(:actual_source_reflection).scope
-      end
+      # For :through associations, it's pretty hard/tricky to apply limit/offset/order of the
+      # whole has_* :through. For now, we only apply those of the direct associations from one model
+      # to another that the :through uses and we ignore the limit/offset/order from the scope of has_* :through.
+      #
+      # The exception is for has_and_belongs_to_many, which behind the scene, use a has_many :through.
+      # For those, since we know there is no limits on the internal has_many and the belongs_to,
+      # we can do a special case and handle their limit. This way, we can treat them the same way we treat
+      # the other macros, we only apply the limit/offset/order of the deepest user-define association.
+      user_defined_actual_source_reflection(reflection).scope
     end
 
     def self.process_association_step_limits(current_scope, reflection, relation_klass, options)
-      return current_scope.unscope(:limit, :offset, :order) if reflection.macro == :belongs_to
+      return current_scope.unscope(:limit, :offset, :order) if user_defined_actual_source_reflection(reflection).macro == :belongs_to
 
       current_scope = current_scope.limit(1) if reflection.macro == :has_one
 
@@ -327,6 +322,23 @@ module ActiveRecordWhereAssoc
       parent && parent.macro == :has_and_belongs_to_many
     end
 
+    # Return true if #user_defined_actual_source_reflection is a has_and_belongs_to_many
+    def self.actually_has_and_belongs_to_many?(reflection)
+      has_and_belongs_to_many?(user_defined_actual_source_reflection(reflection))
+    end
+
+    # Returns the deepest user-defined reflection using source_reflection.
+    # This is different from #send(:actual_source_reflection) because it stops on
+    # has_and_belongs_to_many associations, where as actual_source_reflection would continue
+    # down to the belongs_to that is used internally.
+    def self.user_defined_actual_source_reflection(reflection)
+      loop do
+        return reflection if reflection == reflection.source_reflection
+        return reflection if has_and_belongs_to_many?(reflection)
+        reflection = reflection.source_reflection
+      end
+    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,
@@ -353,7 +365,7 @@ module ActiveRecordWhereAssoc
         raise ArgumentError, "Operator should be one of '==', '=', '<>' or '!=' when using a Range not: #{operator.inspect}"
       end
 
-      v1 = left_operand.begin || 0
+      v1 = left_operand.begin
       v2 = left_operand.end || Float::INFINITY
 
       v1 = 0 if v1 == -Float::INFINITY

data/lib/active_record_where_assoc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_where_assoc
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Maxime Handfield Lapointe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-10 00:00:00.000000000 Z
+date: 2018-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: deep-cover
+  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: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -126,16 +140,16 @@ dependencies:
   name: niceql
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.14
+        version: 0.1.23
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.14
+        version: 0.1.23
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -159,6 +173,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ALTERNATIVES_PROBLEMS.md
+- CHANGELOG.md
 - EXAMPLES.md
 - LICENSE.txt
 - README.md