activerecord_where_assoc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95ce5c0d5802b14a7e1427d949bd45fec4156841
+  data.tar.gz: 928080180b366f561b01cb26f7cf044187ac1c2b
+SHA512:
+  metadata.gz: d7e8dccc5e31da6f30a2355994b8ec611de26b015c3786524408f2fc6afb688e31381e71a8908f5df8682637c473a0a55a1d7f6769772389592cb706c316c3e1
+  data.tar.gz: a31a92215befe043a240074e0b358502e943cfb097b1409155193497b6f69ec02251dd9d53c7af3ecf723d7d398c543bff598ba15bd4216ae79ed89838192e30

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Maxime Handfield Lapointe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,301 @@
+# 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)
+[![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 provides powerful methods to add conditions based on the associations of your records. (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 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
+my_user.posts.where_assoc_count(5, :>=, :comments) { |comments| comments.where(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.
+
+## Feedback
+
+This gem is very new. If you have any feedback, good or bad, do not hesitate to write it here: [General feedback](https://github.com/MaxLap/activerecord_where_assoc/issues/3). If you find any bug, please create a new issue.
+
+* Failure stories, if you had difficulties that kept you from using the gem.
+* Success stories, if you are using it and things are going great, I wanna hear this too.
+* Suggestions to make the documentation easier to follow / more complete.
+
+
+## 0.1.0
+
+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.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord_where_assoc'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install activerecord_where_assoc
+
+## Usage
+
+### `#where_assoc_exists` & `#where_assoc_not_exists`
+
+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)
+```
+
+* 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.
+* 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:
+
+  * receives no argument, in which case `self` is set to the relation, so you can do `{ where(id: 123) }`
+  * receives arguments, in which case the block is called with the relation as first parameter
+
+  The block should return the new relation to use or `nil` to do as if there were no blocks
+  It's common to use `where_assoc_*(..., &:scope_name)` to apply a single scope quickly
+
+### `#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:
+
+```ruby
+Post.where_assoc_exists(:comments, spam: true)
+Post.where_assoc_count(1, :<=, :comments, spam: true)
+
+Post.where_assoc_not_exists(:comments, spam: true)
+Post.where_assoc_count(0, :==, :comments, spam: true)
+```
+
+* 1st parameter: a number or any string of SQL to embed in the query used for the leftoperand of the comparison.
+* 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
+
+The order of the parameters may seem confusing, but you will get used to it. To help remember the order of the parameters, remember that the goal is to do:
+
+    5 < (SELECT COUNT(*) FROM ...)
+
+The parameters are in the same order as in that query: number, operator, association.
+
+### Options
+
+Each of the methods above can take an options argument. It is also possible to change the default value for the options.
+
+* On a per-call basis:
+```ruby
+# Options are passed after the conditions argument
+Posts.where_assoc_exists(:last_status, nil, ignore_limit: true)
+Posts.where_assoc_count(1, :<, :last_status, nil, ignore_limit: true)
+```
+
+* As default for everywhere
+```ruby
+# Somewhere in your setup code, such as an initializer in Rails
+ActiveRecordWhereAssoc.default_options[:ignore_limit] = true
+```
+
+Here is a list of the available options:
+
+#### :ignore_limit
+
+When this option is true, then `#limit` and `#offset` that are set either from default_scope or on associations are ignored. `#has_one` means `limit(1)`, so `#has_one` will behave like `#has_many` with this option.
+
+Main reasons to use this:
+* This is needed for MySQL to be able to do anything with `#has_one` associations because [MySQL doesn't support sub-limit](#mysql-doesnt-support-sub-limit).
+* You have a `#has_one` association which you know can never have more than one record. Using `:ignore_limit`, you will use the simpler query of `#has_many`, which can be more efficient.
+
+Why this isn't the default:
+* From very few tests, the aliasing way seems to produce better plans.
+* Using aliasing produces a shorter query.
+
+#### :never_alias_limit
+
+When this option is true, `#where_assoc_*` will not use `#from` to build relations that have `#limit` or `#offset` set on default_scope or on associations. Note, `#has_one` means `limit(1)`, so it will also use `#from` unless this option is activated.
+
+Main reasons to use this:
+* You have to use `#from` as condition for `#where_assoc_*` method (possibly because a scope needs it).
+* This might result in a difference execution plan for the query since the query ends up being quite different.
+
+## Supported Rails versions
+
+Rails 4.1 to 5.2 are supported with Ruby 2.1 to 2.5.
+
+## Advantages
+
+These methods have many advantages over the alternative ways of achieving the similar results:
+* Avoids the [problems with the alternative ways](ALTERNATIVES_PROBLEMS.md)
+* Can be chained and nested with regular ActiveRecord methods (`where`, `merge`, `scope`, etc).
+* Adds a single condition in the `WHERE` of the query instead of complex things like joins.
+  * So it's easy to have multiple conditions on the same association
+* Handles `has_one` correctly: only testing the "first" record of the association that matches the default_scope and the scope on the association itself.
+* 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
+
+Sometimes, there isn't a single association that goes deep enough. In that situation, you can simply nest the scopes:
+
+```ruby
+# Find users that have a post that has a comment that was made by an admin.
+# Using &:admins to use the admins scope (or any other class method of comments)
+User.where_assoc_exists(:posts) { |posts|
+    posts.where_assoc_exists(:comments) { |comments| 
+        comments.where_assoc_exists(:author, &:admins)
+    }
+}
+```
+
+If you don't need special conditions on any of the intermediary associations, then you can an array as shortcut for multiple steps:
+
+```ruby
+# Same as above
+User.where_assoc_exists([:posts, :comments, :author], &:admins)
+```
+
+This shortcut can be used for every `where_assoc_*` methods. The conditions and the block will only be applied to the last association of the chain.
+
+
+### Beware of spreading conditions on multiple calls
+
+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)
+             .where_assoc_exists(:comments_authors, 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.
+
+The second is the posts of `my_user` that have a comment made by an admin and a comment made by someone honest. It could be the same comment (like the first query) but it could also be 2 different comments.
+
+### Inter-table conditions
+
+It's possible, with string conditions, to refer to all the tables that are used before the association, including the source model.
+
+```ruby
+# Find posts where the author also commented on the post.
+Post.where_assoc_exists(:comments, "posts.author_id = comments.author_id")
+```
+
+Note that some database systems limit how far up you can refer to tables in nested queries. Meaning it's possible that the following query may get refused because of those limits:
+
+```ruby
+# it's hard to come up with a good example...
+Post.where_assoc_exists([:comments, :author, :address], "addresses.country = posts.database_country")
+```
+
+Doing the same thing but with less associations between `address` and `posts` would not be an issue.
+
+### The opposite of multiple nested EXISTS...
+
+... is a single `NOT EXISTS` with then nested ones still using `EXISTS`.
+
+All the methods always chain nested associations using an `EXISTS` when they have to go through multiple hoops. Only the outer-most, or first, association will have a `NOT EXISTS` when using `#where_assoc_not_exists` or a `COUNT` when using `#where_assoc_count`. This is the logical way of doing it.
+
+### Using `#from` in scope
+
+If you want to use a scope / condition which uses `#from`, then you need to use the [:never_alias_limit](#never_alias_limit) option to avoid `#where_assoc_*` being overwritten by your scope and getting a weird exception / wrong result.
+
+## Known issues/limitations
+
+### MySQL doesn't support sub-limit
+On MySQL databases, it is not possible to use `has_one` associations and associations with a scope that apply either a limit or an offset.
+
+I do not know of a way to do a SQL query that can deal with all the specifics of `has_one` for MySQL. If you have one, then please suggest it in an issue/pull request.
+
+In order to work around this, you must use the [ignore_limit](#ignore_limit) option. The behavior is less correct, but better than being unable to use the gem. 
+
+### has_* :through vs limit/offset
+For `has_many` and `has_one` with the `:through` option, `#limit` and `#offset` are ignored. Note that `#limit` and `#offset` of the `:source` and of the `:through` side are applied correctly.
+
+This is the opposite of what `ActiveRecord` does when you fetch the result of such an association. `ActiveRecord` will ignore the limits of the part `:source` and of the `:through` and only use the one of the `has_* :through`.
+
+It is pretty complicated to support `#limit` and `#offset` of the `has_* :through` and would require quite a bit of refactoring. PR welcome
+
+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.
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies.
+
+Run `rake test` to run the tests for the latest version of rails
+
+Run `bin/console` for an interactive prompt that will allow you to experiment in the same environment as the tests.
+
+Run `bin/fixcop` to fix a lot of common styling mistake from your changes and then display the remaining rubocop rules you break. Make sure to do this before committing and submitting PRs. Use common sense, sometimes it's okay to break a rule, add a [rubocop:disable comment](http://rubocop.readthedocs.io/en/latest/configuration/#disabling-cops-within-source-code) in that situation.
+
+Run `bin/testall` to test all supported rails/ruby versions:
+* It will tell you about missing ruby versions, which you can install if you want to test for them
+* It will run `rake test` on each supported version or ruby/rails
+* It automatically installs bundler if a ruby version doesn't have it
+* It automatically runs `bundle install`
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/MaxLap/activerecord_where_assoc.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Acknowledgements
+
+* [René van den Berg](https://github.com/ReneB) for some of the code of [activerecord-like](https://github.com/ReneB/activerecord-like) used for help with setting up the tests

data/lib/active_record_where_assoc.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "active_record_where_assoc/version"
+require "active_record"
+
+module ActiveRecordWhereAssoc
+  # Default options for the gem. Meant to be modified in place by external code
+  def self.default_options
+    @default_options ||= {
+                           ignore_limit: false,
+                           never_alias_limit: false,
+                         }
+  end
+end
+
+require "active_record_where_assoc/core_logic"
+require "active_record_where_assoc/query_methods"
+require "active_record_where_assoc/querying"
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord.eager_load!
+
+  # Need to use #send for the include to support Ruby 2.0
+  ActiveRecord::Relation.send(:include, ActiveRecordWhereAssoc::QueryMethods)
+  ActiveRecord::Base.extend(ActiveRecordWhereAssoc::Querying)
+end

data/lib/active_record_where_assoc/active_record_compat.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ActiveRecordWhereAssoc
+  module ActiveRecordCompat
+    if ActiveRecord.gem_version >= Gem::Version.new("5.1")
+      def self.join_keys(reflection)
+        reflection.join_keys
+      end
+    elsif ActiveRecord.gem_version >= Gem::Version.new("4.2")
+      def self.join_keys(reflection)
+        reflection.join_keys(reflection.klass)
+      end
+    else
+      # 4.1 change that introduced JoinKeys:
+      # https://github.com/rails/rails/commit/5823e429981dc74f8f53187d2ab573823381bf28#diff-523caff658498027f61cae9d91c8503dL108
+      JoinKeys = Struct.new(:key, :foreign_key)
+      def self.join_keys(reflection)
+        if reflection.source_macro == :belongs_to
+          # The original code had to handle polymorphic here. But we don't support polymorphic belongs_to
+          # So the code would never reach here in the polymorphic case.
+          key = reflection.association_primary_key
+          foreign_key = reflection.foreign_key
+        else
+          key         = reflection.foreign_key
+          foreign_key = reflection.active_record_primary_key
+        end
+
+        JoinKeys.new(key, foreign_key)
+      end
+    end
+
+    if ActiveRecord.gem_version >= Gem::Version.new("5.0")
+      def self.chained_reflection_and_chained_constraints(reflection)
+        reflection.chain.map { |ref| [ref, ref.constraints] }.transpose
+      end
+    else
+      def self.chained_reflection_and_chained_constraints(reflection)
+        [reflection.chain, reflection.scope_chain]
+      end
+    end
+
+    if ActiveRecord.gem_version >= Gem::Version.new("5.0")
+      def self.parent_reflection(reflection)
+        reflection.parent_reflection
+      end
+    else
+      def self.parent_reflection(reflection)
+        _parent_name, parent_refl = reflection.parent_reflection
+        parent_refl
+      end
+    end
+
+    if ActiveRecord.gem_version >= Gem::Version.new("4.2")
+      def self.normalize_association_name(association_name)
+        association_name.to_s
+      end
+    else
+      def self.normalize_association_name(association_name)
+        association_name.to_sym
+      end
+    end
+  end
+end

data/lib/active_record_where_assoc/core_logic.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+require_relative "active_record_compat"
+require_relative "exceptions"
+
+module ActiveRecordWhereAssoc
+  module CoreLogic
+    # Arel table used for aliasing when handling recursive associations (such as parent/children)
+    ALIAS_TABLE = Arel::Table.new("_ar_where_assoc_alias_")
+
+    # Block used when nesting associations for a where_assoc_[not_]exists
+    # 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})"
+
+      wrapping_scope.where(sql)
+    end
+
+    # Block used when nesting associations for a where_assoc_count
+    # Will apply the nested scope to the wrapping_scope with: select("SUM(SELECT... *nested_scope*)")
+    NestWithSumBlock = lambda do |wrapping_scope, nested_scope|
+      # Need the double parentheses
+      sql = "SUM((#{nested_scope.to_sql}))"
+
+      wrapping_scope.unscope(:select).select(sql)
+    end
+
+    # List of available options, used for validation purposes.
+    VALID_OPTIONS_KEYS = ActiveRecordWhereAssoc.default_options.keys.freeze
+
+    def self.validate_options(options)
+      invalid_keys = options.keys - VALID_OPTIONS_KEYS
+      raise ArgumentError, "Invalid option keys received: #{invalid_keys.join(', ')}" unless invalid_keys.empty?
+    end
+
+    # Gets the value from the options or fallback to default
+    def self.option_value(options, key)
+      options.fetch(key) { ActiveRecordWhereAssoc.default_options[key] }
+    end
+
+    # Returns a new relation, which is the result of filtering base_relation
+    # 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)
+      nested_relation = relation_on_association(base_relation, association_name, given_scope, options, block, NestWithExistsBlock)
+      NestWithExistsBlock.call(base_relation, nested_relation)
+    end
+
+    # Returns a new relation, which is the result of filtering base_relation
+    # 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)
+      nested_relation = relation_on_association(base_relation, association_name, given_scope, options, block, NestWithExistsBlock)
+      NestWithExistsBlock.call(base_relation, nested_relation, "NOT ")
+    end
+
+    # Returns a new relation, which is the result of filtering base_relation
+    # 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)
+      deepest_scope_mod = lambda do |deepest_scope|
+        deepest_scope = apply_proc_scope(deepest_scope, block) if block
+
+        deepest_scope.unscope(:select).select("COUNT(*)")
+      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)")
+    end
+
+    # 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)
+      validate_options(options)
+      association_names_path = Array.wrap(association_names_path)
+
+      if association_names_path.size > 1
+        recursive_scope_block = lambda do |scope|
+          nested_scope = relation_on_association(scope, association_names_path[1..-1], given_scope, options, last_assoc_block, nest_assocs_block)
+          nest_assocs_block.call(scope, nested_scope)
+        end
+
+        relation_on_one_association(base_relation, association_names_path.first, nil, options, recursive_scope_block, nest_assocs_block)
+      else
+        relation_on_one_association(base_relation, association_names_path.first, given_scope, options, last_assoc_block, nest_assocs_block)
+      end
+    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)
+      relation_klass = base_relation.klass
+      final_reflection = fetch_reflection(relation_klass, association_name)
+
+      nested_scope = nil
+      current_scope = nil
+
+      # Chain deals with through stuff
+      # We will start with the reflection that points on the final model, and slowly move back to the reflection
+      # that points on the model closest to self
+      # 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)
+      skip_next = false
+
+      reflection_chain.each_with_index do |reflection, i|
+        if skip_next
+          skip_next = false
+          next
+        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)
+
+        wrapper_scope, current_scope = initial_scope_from_reflection(reflection_chain[i..-1], constaints_chain[i])
+
+        current_scope = process_association_step_limits(current_scope, reflection, relation_klass, options)
+
+        if i.zero?
+          current_scope = current_scope.where(given_scope) if given_scope
+          current_scope = apply_proc_scope(current_scope, last_assoc_block) if last_assoc_block
+        end
+
+        # Those make no sense since we are only limiting the value that would match, using conditions
+        current_scope = current_scope.unscope(:limit, :order, :offset)
+        current_scope = nest_assocs_block.call(current_scope, nested_scope) if nested_scope
+        current_scope = nest_assocs_block.call(wrapper_scope, current_scope) if wrapper_scope
+
+        nested_scope = current_scope
+      end
+
+      current_scope
+    end
+
+    def self.fetch_reflection(relation_klass, association_name)
+      association_name = ActiveRecordCompat.normalize_association_name(association_name)
+      reflection = relation_klass._reflections[association_name]
+
+      if reflection.nil?
+        # Need to use build because this exception expects a record...
+        raise ActiveRecord::AssociationNotFoundError.new(relation_klass.new, association_name)
+      end
+      if reflection.macro == :belongs_to && reflection.options[:polymorphic]
+        # TODO: We might want an option to indicate that using pluck is ok?
+        raise NotImplementedError, "Can't deal with polymorphic belongs_to"
+      end
+
+      reflection
+    end
+
+    def self.initial_scope_from_reflection(reflection_chain, constraints)
+      reflection = reflection_chain.first
+      current_scope = reflection.klass.default_scoped
+
+      if 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,
+        # 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
+        #   Apply only on 2nd step: You check that any of the first 3 of second step match for any 1st step
+        #   Apply over both (as we do): You check that only the first 3 of doing both step match,
+
+        # To create the join, simply using next_reflection.klass.default_scoped.joins(reflection.name)
+        # would be great, except we cannot add a given_scope 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)
+        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
+
+        wrapper_scope, join_constaints = wrapper_and_join_constraints(next_reflection, habtm_other_reflection: reflection)
+      else
+        wrapper_scope, join_constaints = wrapper_and_join_constraints(reflection)
+      end
+
+      constraint_allowed_lim_off = constraint_allowed_lim_off_from(reflection)
+
+      constraints.each do |callable|
+        relation = reflection.klass.unscoped.instance_exec(&callable)
+
+        if callable != constraint_allowed_lim_off
+          # I just want to remove the current values without screwing things in the merge below
+          # so we cannot use #unscope
+          relation.limit_value = nil
+          relation.offset_value = nil
+          relation.order_values = []
+        end
+
+        # Need to use merge to replicate the Last Equality Wins behavior of associations
+        # https://github.com/rails/rails/issues/7365
+        # See also the test/tests/wa_last_equality_wins_test.rb for an explanation
+        current_scope = current_scope.merge(relation)
+      end
+
+      [wrapper_scope, current_scope.where(join_constaints)]
+    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
+    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
+
+      current_scope = current_scope.limit(1) if reflection.macro == :has_one
+
+      current_scope = current_scope.unscope(:limit, :offset) if option_value(options, :ignore_limit)
+
+      # Order is useless without either limit or offset
+      current_scope = current_scope.unscope(:order) if !current_scope.limit_value && !current_scope.offset_value
+
+      return current_scope unless current_scope.limit_value || current_scope.offset_value
+      if %w(mysql mysql2).include?(relation_klass.connection.adapter_name.downcase)
+        msg = String.new
+        msg << "Associations and default_scopes with a limit or offset are not supported for MySQL (this includes has_many). "
+        msg << "Use ignore_limit: true to ignore both limit and offset, and treat has_one like has_many. "
+        msg << "See https://github.com/MaxLap/activerecord_where_assoc/tree/ignore_limits#mysql-doesnt-support-sub-limit for details."
+        raise MySQLDoesntSupportSubLimitError, msg
+      end
+
+      # We only check the records that would be returned by the associations if called on the model. If:
+      # * the association has a limit in its lambda
+      # * the default scope of the model has a limit
+      # * the association is a has_one
+      # Then not every records that match a naive join would be returned. So we first restrict the query to
+      # only the records that would be in the range of limit and offset.
+      #
+      # Note that if the #where_assoc_* block adds a limit or an offset, it has no effect. This is intended.
+      # An argument could be made for it to maybe make sense for #where_assoc_count, not sure why that would
+      # be useful.
+
+      if reflection.klass.table_name.include?(".") || option_value(options, :never_alias_limit)
+        # This works universally, but seems to sometimes have slower performances.. Need to test if there is an alternative way
+        # of expressing this...
+        # TODO: Investigate a way to improve performances, or maybe require a flag to do it this way?
+        # We use unscoped to avoid duplicating the conditions in the query, which is noise. (unless if it
+        # could helps the query planner of the DB, if someone can show it to be worth it, then this can be changed.)
+
+        reflection.klass.unscoped.where(reflection.klass.primary_key.to_sym => current_scope)
+      else
+        # This works as long as the table_name doesn't have a schema/database, since we need to use an alias
+        # with the table name to make scopes and everything else work as expected.
+
+        # We use unscoped to avoid duplicating the conditions in the query, which is noise. (unless if it
+        # could helps the query planner of the DB, if someone can show it to be worth it, then this can be changed.)
+        reflection.klass.unscoped.from("(#{current_scope.to_sql}) #{reflection.klass.table_name}")
+      end
+    end
+
+    # Apply a proc used as scope
+    # If it can't receive arguments, call the proc with self set to the relation
+    # If it can receive arguments, call the proc the relation passed as argument
+    def self.apply_proc_scope(relation, proc_scope)
+      if proc_scope.arity == 0
+        relation.instance_exec(&proc_scope) || relation
+      else
+        proc_scope.call(relation) || relation
+      end
+    end
+
+    def self.build_wrapper_scope_for_recursive_association(reflection)
+      table = reflection.klass.arel_table
+      primary_key = reflection.klass.primary_key
+      foreign_klass = reflection.send(:actual_source_reflection).active_record
+
+      wrapper_scope = foreign_klass.base_class.unscoped
+      wrapper_scope = wrapper_scope.from("#{table.name} #{ALIAS_TABLE.name}")
+      wrapper_scope = wrapper_scope.where(table[primary_key].eq(ALIAS_TABLE[primary_key]))
+      wrapper_scope
+    end
+
+    def self.wrapper_and_join_constraints(reflection, options = {})
+      join_keys = ActiveRecordCompat.join_keys(reflection)
+
+      key = join_keys.key
+      foreign_key = join_keys.foreign_key
+
+      table = reflection.klass.arel_table
+      foreign_klass = reflection.send(:actual_source_reflection).active_record
+      foreign_table = foreign_klass.arel_table
+
+      habtm_other_reflection = options[:habtm_other_reflection]
+      habtm_other_table = habtm_other_reflection.klass.arel_table if habtm_other_reflection
+
+      if (habtm_other_table || table).name == foreign_table.name
+        wrapper_scope = build_wrapper_scope_for_recursive_association(habtm_other_reflection || reflection)
+        foreign_table = ALIAS_TABLE
+      end
+
+      constraints = table[key].eq(foreign_table[foreign_key])
+
+      if reflection.type
+        # Handing of the polymorphic has_many/has_one's type column
+        constraints = constraints.and(table[reflection.type].eq(foreign_klass.base_class.name))
+      end
+
+      [wrapper_scope, constraints]
+    end
+
+    def self.has_and_belongs_to_many?(reflection) # rubocop:disable Naming/PredicateName
+      parent = ActiveRecordCompat.parent_reflection(reflection)
+      parent && parent.macro == :has_and_belongs_to_many
+    end
+  end
+end

data/lib/active_record_where_assoc/exceptions.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ActiveRecordWhereAssoc
+  class MySQLDoesntSupportSubLimitError < StandardError
+  end
+end

data/lib/active_record_where_assoc/query_methods.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative "active_record_compat"
+require_relative "exceptions"
+
+module ActiveRecordWhereAssoc
+  module QueryMethods
+    # 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. Conditions
+    # the associated model must match to count as existing can also be specified.
+    #
+    # Here is a quick overview of the arguments received followed by a detailed explanation
+    # along with more examples. You may also consider viewing the gem's README. It contains
+    # known issues and some tips. The readme is packaged with the gem and viewable on github:
+    # https://github.com/MaxLap/activerecord_where_assoc
+    #
+    #
+    # As 1st argument, you must specify the association to check against. This can be
+    # any of the associations on the current relation's model.
+    #
+    #    # Posts that have at least one comment
+    #    Post.where_assoc_exists(:comments)
+    #
+    # As 2nd argument, you can add conditions that the records in the association must match
+    # to be considered as existing.
+    #
+    # The 3rd argument is for options that alter how the query is generated.
+    #
+    # If your conditions are too complex or too long to be placed in the 2nd argument,
+    # #where_assoc_* accepts a block in which you can do anything you want on the relation
+    # (any scoping method such as #where, #joins, nested #where_assoc_*, scopes of the model).
+    #
+    # === the association argument (1st argument)
+    #
+    # This is the association you want to check if records exists. If you want, you can pass
+    # an array of associations. They will be followed in order, just like a has_many :through
+    # would.
+    #
+    #    # Posts with at least one comment
+    #    Post.where_assoc_exists(:comments)
+    #
+    #    # Posts for which there is at least one reply to a comment.
+    #    Post.where_assoc_exists([:comments, :replies])
+    #
+    # Note that if you use conditions / blocks, they will only be applied to the last
+    # association of the array. If you want something else, you will need to use
+    # the block argument to nest multiple calls to #where_assoc_exists
+    #
+    #    # Post.where_assoc_exists(:comments) { where_assoc_exists(:replies) }
+    #
+    # === the condition argument (2nd argument)
+    #
+    # This argument is additional conditions the association's records must fulfill to be
+    # considered as "existing". The argument is passed directly to #where.
+    #
+    #    # Posts that have at least one comment considered as spam
+    #    # Using a Hash
+    #    Post.where_assoc_exists(:comments, spam_flag: true)
+    #
+    #    # Using a String
+    #    Post.where_assoc_exists(:comments, "spam_flag = true")
+    #
+    #    # Using an Array (a string and its binds)
+    #    Post.where_assoc_exists(:comments, ["spam_flag = ?", true])
+    #
+    # If the condition argument is blank, it is ignored (just like #where does).
+    #
+    # === the options argument (3rd argument)
+    #
+    # Some options are available to tweak how things queries are generated. In some case, this
+    # also changes the results of the query.
+    #
+    # ignore_limit: when true, #limit and #offset that are set either from default_scope or
+    #               on associations are ignored. #has_one means #limit(1), so this makes
+    #               #has_one be treated like #has_many.
+    #
+    # never_alias_limit: when true, #where_assoc_* will not use #from to build relations that
+    #                    have #limit or #offset set on default_scope or on associations.
+    #                    Note, #has_one means #limit(1), so it will also use #from unless this
+    #                    option is activated.
+    #
+    # === the block
+    #
+    # The block is used to add more complex conditions. The result behaves the same way
+    # as the 2nd argument's conditions, but lets you use any scoping methods, such as
+    # #where, #joins, # nested #where_assoc_* and scopes of the model. 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.
+    #
+    # There are 2 ways of using the block for adding conditions to the association.
+    #
+    # * A block that receives one argument
+    # The block receives a relation on the target association and return a relation with added
+    # 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) }
+    #
+    #    # Applying a scope of the relation
+    #    Post.where_assoc_exists(:comments) { |comments| comments.spam_flagged }
+    #
+    #    # Applying a scope of the relation, using the &:shortcut for procs
+    #    Post.where_assoc_exists(:comments, &:spam_flagged)
+    #
+    #
+    # * A block that receives no argument
+    # Instead of receiving the relation as argument, the relation is used as the "self" of
+    # 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) }
+    #
+    #    # Applying a scope of the relation
+    #    Post.where_assoc_exists(:comments) { spam_flagged }
+    #
+    # The main reason to use a block with an argument instead of without is when you need
+    # to call methods on the self outside of the block, such as:
+    #
+    #    Post.where_assoc_exists(:comments) { |comments| comments.where(id: self.something) }
+    #
+    def where_assoc_exists(association_name, given_scope = nil, options = {}, &block)
+      ActiveRecordWhereAssoc::CoreLogic.do_where_assoc_exists(self, association_name, given_scope, options, &block)
+    end
+
+    # 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 doesn't exist.
+    # Conditions the associated model must match to count as existing can also be specified.
+    #
+    # The parameters and everything is identical to #where_assoc_exists. The only
+    # difference is that a record is matched if no matching association record that
+    # fulfill the conditions are found.
+    def where_assoc_not_exists(association_name, given_scope = nil, options = {}, &block)
+      ActiveRecordWhereAssoc::CoreLogic.do_where_assoc_not_exists(self, association_name, given_scope, options, &block)
+    end
+
+    # Returns a new relation, which is the result of filtering the current relation
+    # based on how many records for the specified association of the model exists. Conditions
+    # the associated model must match can also be specified.
+    #
+    # #where_assoc_count 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:
+    #
+    #    Post.where_assoc_exists(:comments)
+    #    Post.where_assoc_count(1, :<=, :comments)
+    #
+    #    Post.where_assoc_not_exists(:comments)
+    #    Post.where_assoc_count(0, :==, :comments)
+    #
+    # 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.
+    # 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
+    #
+    # The order of the parameters may seem confusing. But you will get used to it. To help
+    # remember the order of the parameters, remember that the goal is to do:
+    #    5 < (SELECT COUNT(*) FROM ...)
+    # So the parameters are in the same order as in that query: number, operator, association.
+    #
+    # To be clear, when you use multiple associations in an array, the count you will be
+    # comparing against is the total number of records of that last association.
+    #
+    #   # The users that have received at least 5 comments total on all of their posts
+    #   # So this can be one post that has 5 comments of 5 posts with 1 comments
+    #   User.where_assoc_count(5, :<=, [:posts, :comments])
+    #
+    #   # The users that have at least 5 posts with at least one comments
+    #   User.where_assoc_count(5, :<=, :posts) { where_assoc_exists(:comments) }
+    def where_assoc_count(left_operand, operator, association_name, given_scope = nil, options = {}, &block)
+      ActiveRecordWhereAssoc::CoreLogic.do_where_assoc_count(self, left_operand, operator, association_name, given_scope, options, &block)
+    end
+  end
+end

data/lib/active_record_where_assoc/querying.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Needed for delegate
+require "active_support"
+
+module ActiveRecordWhereAssoc
+  module Querying
+    new_query_methods = QueryMethods.public_instance_methods
+    delegate(*new_query_methods, to: :all)
+  end
+end

data/lib/active_record_where_assoc/version.rb

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

data/lib/activerecord_where_assoc.rb

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

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: activerecord_where_assoc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Maxime Handfield Lapointe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: sqlite3
+  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'
+description: 'Adds various #where_assoc_* methods to ActiveRecord to make it easy
+  to do correct conditions on the associations of the model being queried.'
+email:
+- maxhlap@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/active_record_where_assoc.rb
+- lib/active_record_where_assoc/active_record_compat.rb
+- lib/active_record_where_assoc/core_logic.rb
+- lib/active_record_where_assoc/exceptions.rb
+- lib/active_record_where_assoc/query_methods.rb
+- lib/active_record_where_assoc/querying.rb
+- lib/active_record_where_assoc/version.rb
+- lib/activerecord_where_assoc.rb
+homepage: https://github.com/MaxLap/activerecord_where_assoc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Make ActiveRecord do conditions on your associations
+test_files: []