activerecord_where_assoc 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95ce5c0d5802b14a7e1427d949bd45fec4156841
-  data.tar.gz: 928080180b366f561b01cb26f7cf044187ac1c2b
+  metadata.gz: e248bec95c932b0bd11743e33d38915ebc13c398
+  data.tar.gz: bea0b06ff2f9e3f61a92e4e2f0cab78daaf63b9b
 SHA512:
-  metadata.gz: d7e8dccc5e31da6f30a2355994b8ec611de26b015c3786524408f2fc6afb688e31381e71a8908f5df8682637c473a0a55a1d7f6769772389592cb706c316c3e1
-  data.tar.gz: a31a92215befe043a240074e0b358502e943cfb097b1409155193497b6f69ec02251dd9d53c7af3ecf723d7d398c543bff598ba15bd4216ae79ed89838192e30
+  metadata.gz: 9551db7bfb1f1219dd1c23fe9255e4ffd495a4bf6777c53619d7037b432e1b13ecafeabee6be8083d8556bca49cf6473f3fbd4ff601723a1380f953a9dee764b
+  data.tar.gz: 5b1d53119ce95d0ab40665330f63c58512818f4af16352e5eb6a7245853ed15c40c2391152aa08bb894703ef853b775c94d3302c5641ae4372d75dfbda2e91fa

data/ALTERNATIVES_PROBLEMS.md

@@ -0,0 +1,222 @@
+There are multiple ways of achieving results similar to what this gems does using either only built-in ActiveRecord functionalities or other gems.
+
+This is a list of some of those alternatives, explaining what issues they have or reasons to prefer this gem over them.
+
+
+## Too long; didn't read
+
+**Use this gem, you will avoid problems and save time**
+
+* No more having to choose, case by case, which way has the less problems.  
+  Just use `#where_assoc_*` each time and avoid every problems.
+* Need less raw SQL, which means less code, more clarity and less maintenance.
+* Allows powerful scopes without traps.
+* Handles recursive associations correctly.
+* Handles has_one correctly.
+
+## Short version
+
+Summary of the problems of the alternatives that `activerecord_where_assoc` solves. The following sections go in more details.
+
+* 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)
+* `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)
+  * 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.
+  * 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.
+* `where_exists` gem:
+  * can't use scopes of the association's model.
+  * can't go deeper than one level of association.
+
+## Common problems to most alternatives
+
+These are problems that affect most alternatives. Details are written in this section and just referred to by a one liner when they apply to an alternative.
+
+### Treating has_one like has_many
+
+Every alternative treats a has_one just like a has_many. So if any of the records (instead of only the first) matches your condition, you will get a match.
+
+And example to clarify:
+
+```ruby
+class Person < ActiveRecord::Base
+  has_many :addresses
+  has_one :current_address, -> { order("effective_date DESC") }, class_name: 'Address'
+end
+
+# This correctly matches only those whose current_address is in Montreal
+Person.where_assoc_exists(:current_address, city: 'Montreal')
+
+# Every alternatives (except raw SQL):
+# Matches those that have had an address in Montreal, no matter when
+Person.where_assoc_exists(:addresses, city: 'Montreal')
+```
+
+The general version of this problem is the handling of `limit` and `offset` on associations and in default_scopes. where_assoc_exists handle those correctly and only checks the records that match the limit and the offset.
+
+### Raw SQL joins or sub-selects
+
+Having to write the joins and conditions in raw SQL is more painful and more error prone than having a method do it for you. It hides the important details of what you are doing in a lot of verbosity.
+
+If there are conditions set on either the association or a default_scope of the model, then you must rewrite those conditions in your manual joins and your manual sub-selects. Worst, if you add/change those conditions on the association / default_scope, then you must find every raw SQL that apply and do the same operation.
+
+```ruby
+class Post < ActiveRecord::Base
+  # Any raw SQL doing a join or sub-select on public_comments, if it want to be representative,
+  # must repeat "public = true".
+  has_many :public_comments, -> { where(public: true) }, class_name: 'Comment'
+end
+
+class Comment < ActiveRecord::Base
+  # Any raw SQL doing a join or sub-select to this model, if it want to be representative,
+  # must repeat "deleted_at IS NULL".
+  default_scope -> { where(deleted_at: nil) }
+end
+```
+
+All of this is avoided by where_assoc_* methods.
+
+### Unable to handle recursive associations
+
+When you have recursive associations such as parent/children, you must compare multiple rows of the same table. To do this, you have no choice but to write your own raw SQL to, at the very least, do a SQL join with an alias.
+
+This brings us back to the [raw SQL joins](#raw-sql-joins-or-sub-selects) problem.
+
+`where_assoc_*` methods handle this seemlessly.
+
+## ActiveRecord only
+
+Those are the common ways given in stack overflow answers.
+
+### Using `joins` and `where`
+
+```ruby
+Post.where_assoc_exists(:comments, is_spam: true)
+Post.joins(:comments).where(comments: {is_spam: true})
+```
+
+* If the association maps to multiple records (such as with a has_many), then the the relation will return one record for each matching association record. In this example, you would get the same post twice if it has 2 comments that are marked as spam.  
+  Using `uniq` can solve this issue, but if you do that in a scope, then that scope unexpectedly adds a DISTINCT to your query, which can lead to unexpected results if you actually wanted duplicates for a different reason.
+
+* Doing the opposite is a lot more complicated, as seen below. You have to include your conditions directly in the join and use a LEFT JOIN, this means writing the whole thing in raw SQL, and then you must check for the id of the association to be empty.
+
+```ruby
+Post.where_assoc_not_exists(:comments, is_spam: true)
+Post.joins("LEFT JOIN comments ON posts.id = comments.post_id AND comments.is_spam = true").where(comments: {id: nil})
+```
+
+Writing a raw join like that has yet more problems: [raw SQL joins](#raw-sql-joins-or-sub-selects)
+
+* If you want to have another condition referring to the same association (or just the same table), then you need to write out the SQL for the second join using an alias. Therefore, your scopes are not even compatible unless each of them has a join with a unique alias.
+
+```ruby
+# We want to be able to match either different or the same records
+Post.where_assoc_exists(:comments, is_spam: true)
+    .where_assoc_exists(:comments, is_reported: true)
+
+# Please don't ever do this, this just shows how painful it would be
+# If you reach the need to do this but won't use where_assoc_exists,
+# go for a regular #where("EXISTS( SELECT ...)")
+Post.joins(:comments).where(comments: {is_spam: true})
+    .joins("JOIN comments comments_for_reported ON posts.id = comments_for_reported.post_id")
+    .where(comments_for_reported: {is_reported: true})
+```
+
+* Cannot be used with Rails 5's `or` unless both side do the same `joins`.
+* [Treats has_one like a has_many](#treating-has_one-like-has_many)
+* [Can't handle recursive associations](#unable-to-handle-recursive-associations)
+
+### Using `includes` (or `eager_load`) and `where`
+
+This solution is similar to the `joins` one above, but avoids the need for `uniq`. Every other problems of the `joins` remain. You also add other potential issues.
+
+```ruby
+Post.where_assoc_exists(:comments, is_spam: true)
+Post.eager_load(:comments).where(comments: {is_spam: true})
+```
+
+* You are triggering the loading of potentially lots of records that you might not need. You don't expect a scope like `have_reported_comments` to trigger eager loading. This is a performance degradation.
+
+* The eager loaded records of the association are actually also filtered by the conditions. All of the posts returned will only have the comments that are spam.  
+  This means if you iterate on `Post.have_reported_comments` to display each of the comments of the posts that have at least one reported comment, you are actually only going to display the reported comments. This may be what you wanted to do, but it clearly isn't intuitive.
+
+* Cannot be used with Rails 5's `or` unless both side do the same `includes` or `eager_load`.
+
+* [Treats has_one like a has_many](#treating-has_one-like-has_many)
+* [Can't handle recursive associations](#unable-to-handle-recursive-associations)
+
+* Simply cannot be used for complex cases.
+
+Note: using `includes` (or `eager_load`) already does a LEFT JOIN, so it is pretty easy to do a "not exists", but only if you don't need any condition on the association (which would normally need to be in the JOIN clause):
+
+```ruby
+Post.where_assoc_exists(:comments)
+Post.eager_load(:comments).where(comments: {id: nil})
+```
+
+### Using `where("EXISTS( SELECT... )")`
+
+This is what is gem does behind the scene, but doing it manually can lead to troubles:
+
+* Problems with writing [raw SQL sub-selects](#raw-sql-joins-or-sub-selects)
+
+* Unless you do a quite complex nested sub-selects, you will [treat has_one like a has_many](#treating-has_one-like-has_many)
+
+
+## Gems
+
+### where_exists
+
+https://github.com/EugZol/where_exists
+
+An interesting gem that also does `EXISTS (SELECT ... )`behind the scene. Solves most issues from ActiveRecord only alternatives, but appears less powerful than where_assoc_exists.
+
+* where_exists supports polymorphic belongs_to. This is something that where_assoc doesn't do at the moment.  
+  However, the way it does this is by doing a pluck on the type column, which in some situation could be a slow query if there is a lots of rows to scan.
+  
+* Unable to use scopes of the association's model.
+```ruby
+# There is no equivalent for this (admins is a scope on User)
+Comment.where_assoc_exists(:author, &:admins)
+```
+
+* Cannot use a block for more complex conditions
+```ruby
+# There is no equivalent for this
+Comment.where_assoc_exists(:author) { admins.where("created_at <= ?", 1.month.ago) }
+```
+
+* Unable to dig deeper in the associations  
+  Note: it does follow :through associations so doing a custom associations for your need can be a workaround.
+
+```ruby
+# There is no equivalent for this (Users that have posts with at least a comments)
+User.where_assoc_exists([:posts, :comments])
+```
+
+* Has no equivalent to `where_assoc_count`
+```ruby
+# There is no equivalent for this (posts with more than 5 comments)
+Post.where_assoc_count(:comments, :>, 5)
+```
+
+* [Treats has_one like a has_many](#treating-has_one-like-has_many)
+
+* [Can't handle recursive associations](#unable-to-handle-recursive-associations)
+
+* `where_exists` is shorter than `where_assoc_exists`, but it is also less obvious about what it does.  
+  In any case, it is trivial to alias one name to the other one.
+
+* where_exists supports Rails 4.2 and up, while where_assoc supports Rails 4.1 and up.

data/EXAMPLES.md

@@ -0,0 +1,222 @@
+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 content below is generated from running `ruby examples/examples.rb`
+
+-------
+
+## Simple examples
+
+```ruby
+# Posts that have a least one comment
+Post.where_assoc_exists(:comments)
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE (EXISTS (
+    SELECT 0 FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id"
+  ))
+```
+
+---
+
+```ruby
+# Posts that have no comments
+Post.where_assoc_not_exists(:comments)
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE (NOT EXISTS (
+    SELECT 0 FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id"
+  ))
+```
+
+---
+
+```ruby
+# Posts that have a least 50 comment
+Post.where_assoc_count(50, :<=, :comments)
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE ((50) <= COALESCE((
+    SELECT COUNT(*) FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id"
+  ), 0))
+```
+
+---
+
+## Examples with condition / scope
+
+```ruby
+# comments of `my_post` that were made by an admin (Using a hash)
+my_post.comments.where_assoc_exists(:author, is_admin: true)
+```
+```sql
+SELECT "comments".* FROM "comments" 
+  WHERE "comments"."post_id" = 1 AND (EXISTS (
+    SELECT 0 FROM "users" 
+    WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
+  ))
+```
+
+---
+
+```ruby
+# comments of `my_post` that were not made by an admin (Using scope)
+my_post.comments.where_assoc_not_exists(:author, &:admins)
+```
+```sql
+SELECT "comments".* FROM "comments" 
+  WHERE "comments"."post_id" = 1 AND (NOT EXISTS (
+    SELECT 0 FROM "users" 
+    WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
+  ))
+```
+
+---
+
+```ruby
+# Posts that have at least 5 reported comments (Using array condition)
+Post.where_assoc_count(5, :<=, :comments, ["is_reported = ?", true])
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE ((5) <= COALESCE((
+    SELECT COUNT(*) FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id" AND (is_reported = 't')
+  ), 0))
+```
+
+---
+
+```ruby
+# Posts made by an admin (Using a string)
+Post.where_assoc_exists(:author, "is_admin = 't'")
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE (EXISTS (
+    SELECT 0 FROM "users" 
+    WHERE "users"."id" = "posts"."author_id" AND (is_admin = 't')
+  ))
+```
+
+---
+
+```ruby
+# comments of `my_post` that were not made by an admin (Using block and a scope)
+my_post.comments.where_assoc_not_exists(:author) { admins }
+```
+```sql
+SELECT "comments".* FROM "comments" 
+  WHERE "comments"."post_id" = 1 AND (NOT EXISTS (
+    SELECT 0 FROM "users" 
+    WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
+  ))
+```
+
+---
+
+```ruby
+# Posts that have at least 5 reported comments (Using block with #where)
+Post.where_assoc_count(5, :<=, :comments) { where(is_reported: true) }
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE ((5) <= COALESCE((
+    SELECT COUNT(*) FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id" AND "comments"."is_reported" = 't'
+  ), 0))
+```
+
+---
+
+```ruby
+# comments made in replies to my_user's post
+Comment.where_assoc_exists(:post, author_id: my_user.id)
+```
+```sql
+SELECT "comments".* FROM "comments" 
+  WHERE (EXISTS (
+    SELECT 0 FROM "posts" 
+    WHERE "posts"."id" = "comments"."post_id" AND "posts"."author_id" = 1
+  ))
+```
+
+---
+
+## Complex / powerful examples
+
+```ruby
+# posts with a comment by an admin (uses array to go through multiple associations)
+Post.where_assoc_exists([:comments, :author], is_admin: true)
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE (EXISTS (
+    SELECT 0 FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id" AND (EXISTS (
+      SELECT 0 FROM "users" 
+      WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
+    ))
+  ))
+```
+
+---
+
+```ruby
+# posts where the author also commented on the post (use conditions between posts)
+Post.where_assoc_exists(:comments, "posts.author_id = comments.author_id")
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE (EXISTS (
+    SELECT 0 FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id" AND (posts.author_id = comments.author_id)
+  ))
+```
+
+---
+
+```ruby
+# posts with a reported comment made by an admin (must be the same comments)
+Post.where_assoc_exists(:comments, is_reported: true) {
+  where_assoc_exists(:author, is_admin: true)
+}
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE (EXISTS (
+    SELECT 0 FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id" AND "comments"."is_reported" = 't' AND (EXISTS (
+      SELECT 0 FROM "users" 
+      WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
+    ))
+  ))
+```
+
+---
+
+```ruby
+# posts with a reported comment and a comment by an admin (can be different or same comments)
+my_user.posts.where_assoc_exists(:comments, is_reported: true)
+             .where_assoc_exists([:comments, :author], is_admin: true)
+```
+```sql
+SELECT "posts".* FROM "posts" 
+  WHERE "posts"."author_id" = 1 AND (EXISTS (
+    SELECT 0 FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id" AND "comments"."is_reported" = 't'
+  )) AND (EXISTS (
+    SELECT 0 FROM "comments" 
+    WHERE "comments"."post_id" = "posts"."id" AND (EXISTS (
+      SELECT 0 FROM "users" 
+      WHERE "users"."id" = "comments"."author_id" AND "users"."is_admin" = 't'
+    ))
+  ))
+```

data/README.md

@@ -15,14 +15,16 @@ my_post.comments.where_assoc_not_exists(:author, is_admin: true).where(...)
 Post.where_assoc_exists([:comments, :author], &:admins).where(...)
  
 # Find my_user's posts that have at least 5 non-spam comments
-my_user.posts.where_assoc_count(5, :>=, :comments) { |comments| comments.where(spam: false) }.where(...)
+my_user.posts.where_assoc_count(5, :>=, :comments) { |comments| comments.where(is_spam: false) }.where(...)
 ```
 
 These allow for powerful, chainable, clear and easy to reuse queries. (Great for scopes)
 
 You also avoid many [problems with the alternative options](ALTERNATIVES_PROBLEMS.md).
 
-Works with SQLite3, PostgreSQL and MySQL. [MySQL has one limitation](#mysql-doesnt-support-sub-limit). Untested with other DBMS.
+Works with SQLite3, PostgreSQL and MySQL. [MySQL has one limitation](#mysql-doesnt-support-sub-limit). Untested with other RDBMS.
+
+Here are [many examples](EXAMPLES.md), including the generated SQL queries.
 
 ## Feedback
 
@@ -60,13 +62,13 @@ Or install it yourself as:
 Returns a new relation, which is the result of filtering the current relation based on if a record for the specified association of the model exists (or not). Conditions that the associated model must match to count as existing can also be specified.
 
 ```ruby
-Post.where_assoc_exists(:comments, spam: true)
-Post.where_assoc_not_exists(:comments, spam: true)
+Post.where_assoc_exists(:comments, is_spam: true)
+Post.where_assoc_not_exists(:comments, is_spam: true)
 ```
 
 * 1st parameter: the association we are doing the condition on.
 * 2nd parameter: (optional) the condition to apply on the association. It can be anything that `#where` can receive, so: Hash, String and Array (string with binds).
-* 3rd parameter: [options (listed below)](#options) to alter some behaviors.
+* 3rd parameter: [options (listed below)](#options) to alter some behaviors. (rarely necessary)
 * block: adds more complex conditions by receiving a relation on the association. Can apply `#where`, `#where_assoc_*`, scopes, and other scoping methods.
   The block either:
 
@@ -81,11 +83,11 @@ Post.where_assoc_not_exists(:comments, spam: true)
 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:
 
 ```ruby
-Post.where_assoc_exists(:comments, spam: true)
-Post.where_assoc_count(1, :<=, :comments, spam: true)
+Post.where_assoc_exists(:comments, is_spam: true)
+Post.where_assoc_count(1, :<=, :comments, is_spam: true)
 
-Post.where_assoc_not_exists(:comments, spam: true)
-Post.where_assoc_count(0, :==, :comments, spam: true)
+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.
@@ -99,6 +101,10 @@ The order of the parameters may seem confusing, but you will get used to it. To
 
 The parameters are in the same order as in that query: number, operator, association.
 
+### More examples
+
+You can view [more usage examples](EXAMPLES.md).
+
 ### Options
 
 Each of the methods above can take an options argument. It is also possible to change the default value for the options.
@@ -153,38 +159,6 @@ These methods have many advantages over the alternative ways of achieving the si
 * Handles recursive associations (such as parent/children) seemlessly.
 * Can be used to quickly generate a SQL query that you can edit/use manually.
 
-## More examples
-
-High level explanation of various ways of using the methods. Also take a look at [usage tips](#usage-tips)
-
-```ruby
-# Find my_post's comments that were not made by an admin
-# Uses a Hash for the condition
-my_post.comments.where_assoc_not_exists(:author, is_admin: true)
-
-# Find my_user's posts that have comments by an admin
-# Uses an array as shortcut to go to a nested related
-# Uses the block shortcut to use a scope that exists on Author
-my_user.posts.where_assoc_exists([:comments, :author], &:admins).where(...)
-
-# Find my_user's posts that have at least 5 non-spam comments
-# Uses a block with a parameter to do a condition
-my_user.posts.where_assoc_count(5, :>=, :comments) { |s| s.where(spam: false) }
-
-# Find my_user's posts that have at least 5 non-spam comments
-# Uses a block without parameters to do a condition
-my_user.posts.where_assoc_count(5, :>=, :comments) { where(spam: false) }
-
-# Find my_user's posts that have comments by an honest admin
-# Uses multiple associations.
-# Uses a hash as 2nd parameter to do the conditions
-my_user.posts.where_assoc_exists([:comments, :author], honest: true, is_admin: true)
-
-# Find any post that has reached its maximum number of allowed comments
-# Uses a string on the left side (first parameter) to refer to a column in the previous table.
-Post.where_assoc_count("posts.max_comments_allowed", :==, :comments)
-```
-
 ## Usage tips
 
 ### Nested associations
@@ -216,10 +190,10 @@ This shortcut can be used for every `where_assoc_*` methods. The conditions and
 The following have different meanings:
 
 ```ruby
-my_user.posts.where_assoc_exists(:comments_authors, is_admin: true, honest: true)
+my_user.posts.where_assoc_exists(:comments_authors, is_admin: true, is_honest: true)
 
 my_user.posts.where_assoc_exists(:comments_authors, is_admin: true)
-             .where_assoc_exists(:comments_authors, honest: true)
+             .where_assoc_exists(:comments_authors, is_honest: true)
 ```
 
 The first is the posts of `my_user` that have a comment made by an honest admin. It requires a single comment to match every conditions.

data/lib/active_record_where_assoc.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_record_where_assoc/version"
+require_relative "active_record_where_assoc/version"
 require "active_record"
 
 module ActiveRecordWhereAssoc
@@ -13,9 +13,9 @@ module ActiveRecordWhereAssoc
   end
 end
 
-require "active_record_where_assoc/core_logic"
-require "active_record_where_assoc/query_methods"
-require "active_record_where_assoc/querying"
+require_relative "active_record_where_assoc/core_logic"
+require_relative "active_record_where_assoc/query_methods"
+require_relative "active_record_where_assoc/querying"
 
 ActiveSupport.on_load(:active_record) do
   ActiveRecord.eager_load!

data/lib/active_record_where_assoc/query_methods.rb

@@ -55,13 +55,13 @@ module ActiveRecordWhereAssoc
     #
     #    # Posts that have at least one comment considered as spam
     #    # Using a Hash
-    #    Post.where_assoc_exists(:comments, spam_flag: true)
+    #    Post.where_assoc_exists(:comments, is_spam: true)
     #
     #    # Using a String
-    #    Post.where_assoc_exists(:comments, "spam_flag = true")
+    #    Post.where_assoc_exists(:comments, "is_spam = true")
     #
     #    # Using an Array (a string and its binds)
-    #    Post.where_assoc_exists(:comments, ["spam_flag = ?", true])
+    #    Post.where_assoc_exists(:comments, ["is_spam = ?", true])
     #
     # If the condition argument is blank, it is ignored (just like #where does).
     #
@@ -94,7 +94,7 @@ module ActiveRecordWhereAssoc
     # filters or may return nil to do nothing.
     #
     #    # Using a where for the added condition
-    #    Post.where_assoc_exists(:comments) { |comments| comments.where(spam_flag: true) }
+    #    Post.where_assoc_exists(:comments) { |comments| comments.where(is_spam: true) }
     #
     #    # Applying a scope of the relation
     #    Post.where_assoc_exists(:comments) { |comments| comments.spam_flagged }
@@ -108,7 +108,7 @@ module ActiveRecordWhereAssoc
     # the block. Everything else is identical to the block with one argument.
     #
     #    # Using a where for the added condition
-    #    Post.where_assoc_exists(:comments) { where(spam_flag: true) }
+    #    Post.where_assoc_exists(:comments) { where(is_spam: true) }
     #
     #    # Applying a scope of the relation
     #    Post.where_assoc_exists(:comments) { spam_flagged }

data/lib/active_record_where_assoc/version.rb

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

data/lib/activerecord_where_assoc.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
 # Just in case of typo in the require. Call the right one automatically
-
-
 require_relative "active_record_where_assoc"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_where_assoc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Maxime Handfield Lapointe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-14 00:00:00.000000000 Z
+date: 2018-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: niceql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.14
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.14
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -144,6 +158,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ALTERNATIVES_PROBLEMS.md
+- EXAMPLES.md
 - LICENSE.txt
 - README.md
 - lib/active_record_where_assoc.rb