activerecord_follow_assoc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4b8caccb83e94c7443d397e3821ff1e82bd7b97e70eaf4069a35199cec86e4d5
+  data.tar.gz: 974c2775d84c5d1863288bab1d25844c46e3a068502d56885ff0e8b061f61bd4
+SHA512:
+  metadata.gz: 6a24b54072e35365c17cc80a6b112fabab2e535b42f2d6063065fafd1defbd02cb619638d06bfbddb7ac080a74b6476d033d075075fcbeee96fbe7c85f755608
+  data.tar.gz: 27a15ff6481ec90f3dba7d71b1f8b13e82bec4a56918735edf2676f1b6f7fef971372336f881e83a1422cfb79e88a358f36501080ad26395e0635d9ea0685b1b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Maxime 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,152 @@
+This gem is still a work in progress. It hasn't been released yet.
+
+# ActiveRecord Follow Assoc
+
+![Test supported versions](https://github.com/MaxLap/activerecord_follow_assoc/workflows/Test%20supported%20versions/badge.svg)
+
+Let's say that, in your Rails app, you want to get all of the comments to the recent posts the
+current user made.
+
+Think of how you would do it.
+
+Here's how this gem allows you to do it:
+
+```ruby
+current_user.posts.recent.follow_assoc(:comments)
+```
+
+The `follow_assoc` method, added by this gem allows you to query the specified association 
+of the records that the current query would return.
+
+Here is a more complete [introduction to this gem](INTRODUCTION.md).
+
+Benefits of `follow_assoc`:
+* Works the same way for all kinds of association `belongs_to`, `has_many`, `has_one`, `has_and_belongs_to_many`
+* You can use `where`, `order` and other such methods on the result
+* By nesting SQL queries, the only records that need to be loaded are the final ones, so the above example
+  wouldn't have loaded any `Post` from the database. This usually leads to faster code.
+* You avoid many [problems with the alternative options](ALTERNATIVES_PROBLEMS.md).
+
+## Why / when do you need this?
+
+As applications grow, you can end up with quite complex data model and even more complex business rules. You may end up
+needing to fetch records that are deep in your associations.
+
+As a simple example, let's say you have a helper which receives sections of a blog and must return the recent comments
+in those sections.
+```ruby
+def recent_comments_within(sections)
+  sections.follow_assoc(:posts, :comments).recent
+end
+```
+
+Note that this won't work if `sections` is an `Array`. `follow_assoc` is available in the same places as `where`. See [Usage](#Usage) for details.
+
+Doing this without follow_assoc can be verbose, error-prone and less efficient depending on the approach taken.
+
+## Installation
+
+**This is not released yet. This won't work.**
+Rails 4.1 to 6.1 are supported with Ruby 2.1 to 3.0. Tested against SQLite3, PostgreSQL and MySQL. The gem
+only depends on the `activerecord` gem.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord_follow_assoc'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself with:
+
+    $ gem install activerecord_follow_assoc
+
+## Usage
+
+Starting from a query or a model, you call `follow_assoc` with an association's name. It returns another query that:
+
+* searches in the association's model
+* has a `where` to only return the records that are associated with the records that the initial query would have returned.
+
+So `my_comments.follow_assoc(:posts)` gives you a query on `Post` which only returns the posts that are
+associated to the records of `my_comments`.
+
+```ruby
+# Getting the spam comments to posts by a specific author
+spam_comments = author.posts.follow_assoc(:comments).spam
+```
+
+As a shortcut, you can also give multiple association to `follow_assoc`. Doing so is equivalent to consecutive calls to it.
+```ruby
+# Getting the spam comments to posts in some sections
+spam_comments_in_section = my_sections.follow_assoc(:posts, :comments).spam
+# Equivalent to
+spam_comments_in_section = my_sections.follow_assoc(:posts).follow_assoc(:comments).spam
+```
+
+The `follow_assoc` method is only available on models and queries (also often called relation or scope). You cannot use
+it on an `Array` of record. If you need to use `follow_assoc` in that situation, then you must make a query yourself:
+```ruby
+sections_query = Section.where(id: my_sections)
+# Then you can use `follow_assoc`
+spam_comments_in_section = sections_query.follow_assoc(:posts, :comments).spam
+```
+
+Detailed doc is [here](https://maxlap.dev/activerecord_follow_assoc/ActiveRecordFollowAssoc/QueryMethods.html).
+
+## Known issues
+
+**No support for recursive has_one**
+
+The SQL to handle recursive has_one while isolating the different layers of conditions is a mess and I worry about
+the resulting performance. So for now, this will raise an exception. You can use the `ignore_limit: true` option
+to treat the has_one as a has_many.
+
+**MySQL doesn't support sub-limit**
+
+On MySQL databases, it is not possible to use has_one associations.
+
+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: true` option, which means that the `has_one` will be treated
+like a `has_many`.
+
+## Another recommended gem
+
+If you feel a need for this gem's feature, you may also be interested in another gem I made: [activerecord_where_assoc](https://github.com/MaxLap/activerecord_where_assoc).
+
+It allows you to make conditions based on your associations (without changing the kind of objects returned). For simple cases, it's possible that both can build the query your need, but each can handle different situations. Here is an example:
+
+```ruby
+# Find every posts that have comments by an admin
+Post.where_assoc_exists([:comments, :author], &:admins)
+```
+
+This could be done with `follow_assoc`: `User.admins.follow_assoc(:comments, :post)`. But if you wanted conditions on
+a second association, then `follow_assoc` wouldn't work. It all depends on the context where you need to do the query
+and what starting point you have.
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/MaxLap/activerecord_follow_assoc.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ActiveRecordFollowAssoc project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/MaxLap/activerecord_follow_assoc/blob/master/CODE_OF_CONDUCT.md).
+
+
+

data/lib/active_record_follow_assoc/active_record_compat.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ActiveRecordFollowAssoc
+  module ActiveRecordCompat
+    if ActiveRecord.gem_version >= Gem::Version.new("6.1.0.rc1")
+      JoinKeys = Struct.new(:key, :foreign_key)
+      def self.join_keys(reflection, poly_belongs_to_klass)
+        if poly_belongs_to_klass
+          JoinKeys.new(reflection.join_primary_key(poly_belongs_to_klass), reflection.join_foreign_key)
+        else
+          JoinKeys.new(reflection.join_primary_key, reflection.join_foreign_key)
+        end
+      end
+
+    elsif ActiveRecord.gem_version >= Gem::Version.new("5.1")
+      def self.join_keys(reflection, poly_belongs_to_klass)
+        if poly_belongs_to_klass
+          reflection.get_join_keys(poly_belongs_to_klass)
+        else
+          reflection.join_keys
+        end
+      end
+    elsif ActiveRecord.gem_version >= Gem::Version.new("4.2")
+      def self.join_keys(reflection, poly_belongs_to_klass)
+        reflection.join_keys(poly_belongs_to_klass || 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, poly_belongs_to_klass)
+        if reflection.source_macro == :belongs_to
+          key = reflection.association_primary_key(poly_belongs_to_klass)
+          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)
+        pairs = reflection.chain.map do |ref|
+          # PolymorphicReflection is a super weird thing. Like a partial reflection, I don't get it.
+          # Seems like just bypassing it works for our needs.
+          # When doing a has_many through that has a polymorphic source and a source_type, this ends up
+          # part of the chain instead of the regular HasManyReflection that one would expect.
+          ref = ref.instance_variable_get(:@reflection) if ref.is_a?(ActiveRecord::Reflection::PolymorphicReflection)
+
+          [ref, ref.constraints]
+        end
+
+        pairs.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
+
+    if ActiveRecord.gem_version >= Gem::Version.new("5.0")
+      def self.through_reflection?(reflection)
+        reflection.through_reflection?
+      end
+    else
+      def self.through_reflection?(reflection)
+        reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      end
+    end
+  end
+end

data/lib/active_record_follow_assoc/core_logic.rb

@@ -0,0 +1,239 @@
+require_relative "active_record_compat"
+
+module ActiveRecordFollowAssoc
+  module CoreLogic
+    # Arel table used for aliasing when handling recursive associations (such as parent/children)
+    ALIAS_TABLE = Arel::Table.new("_ar_follow_assoc_alias_")
+
+    # Returns the SQL for checking if any of the received relation exists.
+    # Uses a OR if there are multiple relations.
+    # => "EXISTS (SELECT... *relation1*) OR EXISTS (SELECT... *relation2*)"
+    def self.sql_for_any_exists(relations)
+      relations = [relations] unless relations.is_a?(Array)
+      relations = relations.reject { |rel| rel.is_a?(ActiveRecord::NullRelation) }
+      sqls = relations.map { |rel| "EXISTS (#{rel.select('1').to_sql})" }
+      if sqls.size > 1
+        "(#{sqls.join(" OR ")})" # Parens needed when embedding the sql in a `where`, because the OR could make things wrong
+      elsif sqls.size == 1
+        sqls.first
+      else
+        "0=1"
+      end
+    end
+
+
+    def self.follow_assoc(relation, association_names, options_for_last_assoc = {})
+      association_names[0...-1].each do |association_name|
+        relation = follow_one_assoc(relation, association_name)
+      end
+      follow_one_assoc(relation, association_names.last, options_for_last_assoc)
+    end
+
+    def self.follow_one_assoc(relation, association_name, options = {})
+      reflection = fetch_reflection(relation, association_name)
+
+      if reflection.scope && reflection.scope.arity != 0
+        raise ArgumentError, <<-MSG.squish
+            The association scope '#{name}' is instance dependent (the scope
+            block takes an argument). Following instance dependent scopes is
+            not supported.
+        MSG
+      end
+
+      reflection_chain, constraints_chain = ActiveRecordFollowAssoc::ActiveRecordCompat.chained_reflection_and_chained_constraints(reflection)
+
+      # Chained stuff is in reverse order, we want it in forward order
+      reflection_chain = reflection_chain.reverse
+      constraints_chain = constraints_chain.reverse
+
+      reflection_chain.each_with_index do |sub_reflection, i|
+        klass = class_for_reflection(sub_reflection, options[:poly_belongs_to])
+        alias_scope, join_constraints = wrapper_and_join_constraints(sub_reflection, options[:poly_belongs_to])
+
+        constraints_relation = resolve_constraints(sub_reflection, klass, constraints_chain[i])
+        constraints_relation = constraints_relation.unscope(:limit, :offset, :order) if option_value(options, :ignore_limit)
+
+        if constraints_relation.limit_value
+          if alias_scope
+            raise "#{sub_reflection.name} is a recursive has_one, this is not supported by follow_assoc."
+          end
+          sub_relation = constraints_relation.where(join_constraints).unscope(:select).select(klass.primary_key)
+
+          relation = relation.joins(sub_reflection.name)
+                             .unscope(:select)
+                             .select("#{klass.quoted_table_name}.*")
+                             .where("#{klass.quoted_table_name}.#{klass.quoted_primary_key} IN (#{sub_relation.to_sql})")
+
+          relation = klass.unscoped.from("(#{relation.to_sql}) #{klass.quoted_table_name}")
+        else
+          if alias_scope
+            relation = alias_scope.where(sql_for_any_exists(relation.where(join_constraints)))
+            join_constraints = nil
+          end
+
+          relation = klass.unscoped.where(sql_for_any_exists(relation.where(join_constraints)))
+          relation = relation.merge(constraints_relation)
+        end
+      end
+
+      relation
+    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 a fake record because this exception expects a record...
+        raise ActiveRecord::AssociationNotFoundError.new(relation_klass.new, association_name)
+      end
+
+      reflection
+    end
+
+    def self.wrapper_and_join_constraints(reflection, poly_belongs_to_klass = nil)
+      join_keys = ActiveRecordCompat.join_keys(reflection, poly_belongs_to_klass)
+
+      key = join_keys.key
+      foreign_key = join_keys.foreign_key
+
+      table = (poly_belongs_to_klass || reflection.klass).arel_table
+      foreign_klass = reflection.send(:actual_source_reflection).active_record
+      foreign_table = foreign_klass.arel_table
+
+      if table.name == foreign_table.name
+        alias_scope = build_alias_scope_for_recursive_association(reflection, poly_belongs_to_klass)
+        table = ALIAS_TABLE
+      end
+
+      constraints = table[key].eq(foreign_table[foreign_key])
+
+      if reflection.type
+        # Handling of the polymorphic has_many/has_one's type column
+        constraints = constraints.and(table[reflection.type].eq(foreign_klass.base_class.name))
+      end
+
+      if poly_belongs_to_klass
+        constraints = constraints.and(foreign_table[reflection.foreign_type].eq(poly_belongs_to_klass.base_class.name))
+      end
+
+      [alias_scope, constraints]
+    end
+
+    def self.resolve_constraints(reflection, klass, constraints)
+      relation = klass.default_scoped
+      assoc_scope_allowed_lim_off = assoc_scope_to_keep_lim_off_from(reflection)
+
+      constraints.each do |callable|
+        assoc_constraint_relation = klass.unscoped.instance_exec(nil, &callable)
+
+        if callable != assoc_scope_allowed_lim_off
+          # I just want to remove the current values without screwing things in the merge below
+          # so we cannot use #unscope
+          assoc_constraint_relation.limit_value = nil
+          assoc_constraint_relation.offset_value = nil
+          assoc_constraint_relation.order_values = []
+        end
+
+        # Need to use merge to replicate the Last Equality Wins behavior of associations
+        # https://github.com/rails/rails/issues/7365
+        relation = relation.merge(assoc_constraint_relation)
+      end
+
+      relation = relation.limit(1) if reflection.macro == :has_one
+
+      if user_defined_actual_source_reflection(reflection).macro == :belongs_to
+        relation = relation.unscope(:limit, :offset, :order)
+      end
+      relation
+    end
+
+    def self.build_alias_scope_for_recursive_association(reflection, poly_belongs_to_klass)
+      klass = poly_belongs_to_klass || reflection.klass
+      table = klass.arel_table
+      primary_key = klass.primary_key
+      foreign_klass = reflection.send(:actual_source_reflection).active_record
+
+      alias_scope = foreign_klass.base_class.unscoped
+      alias_scope = alias_scope.from("#{table.name} #{ALIAS_TABLE.name}")
+      alias_scope = alias_scope.where(table[primary_key].eq(ALIAS_TABLE[primary_key]))
+      alias_scope
+    end
+
+    def self.class_for_reflection(reflection, on_poly_belongs_to)
+      actual_source_reflection = user_defined_actual_source_reflection(reflection)
+
+      if poly_belongs_to?(actual_source_reflection)
+        if reflection.options[:source_type]
+          [reflection.options[:source_type].safe_constantize].compact
+        else
+          if on_poly_belongs_to.nil?
+            msg = String.new
+            if actual_source_reflection == reflection
+              msg << "Association #{reflection.name.inspect} is a polymorphic belongs_to. "
+            else
+              msg << "Association #{reflection.name.inspect} is a :through relation that uses a polymorphic belongs_to"
+              msg << "#{actual_source_reflection.name.inspect} as source without without a source_type. "
+            end
+            msg << "This is not supported by ActiveRecord when doing joins, but it is by FollowAssoc. However, "
+            msg << "you must pass the :poly_belongs_to option to specify what to do in this case.\n"
+            msg << "See the :poly_belongs_to option at https://maxlap.dev/activerecord_follow_assoc/ActiveRecordFollowAssoc/QueryMethods.html"
+            raise ActiveRecordFollowAssoc::PolymorphicBelongsToWithoutClasses, msg
+          elsif on_poly_belongs_to.is_a?(Class) && on_poly_belongs_to < ActiveRecord::Base
+              on_poly_belongs_to
+          else
+            raise ArgumentError, "Received a bad value for :poly_belongs_to: #{on_poly_belongs_to.inspect}"
+          end
+        end
+      else
+        reflection.klass
+      end
+    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
+
+    def self.assoc_scope_to_keep_lim_off_from(reflection)
+      # 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
+
+    # Gets the value from the options or fallback to default
+    def self.option_value(options, key)
+      options.fetch(key) { ActiveRecordFollowAssoc.default_options[key] }
+    end
+
+    def self.poly_belongs_to?(reflection)
+      reflection.macro == :belongs_to && reflection.options[:polymorphic]
+    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
+
+    # Because we work using Model._reflections, we don't actually get the :has_and_belongs_to_many.
+    # Instead, we get a has_many :through, which is was ActiveRecord created behind the scene.
+    # This code detects that a :through is actually a has_and_belongs_to_many.
+    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_follow_assoc/exceptions.rb

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

data/lib/active_record_follow_assoc/query_methods.rb

@@ -0,0 +1,77 @@
+# See QueryMethods
+module ActiveRecordFollowAssoc
+
+end
+
+module ActiveRecordFollowAssoc::QueryMethods
+  # Query the specified association of the records that the current query would return.
+  #
+  # Returns a new relation (also known as a query) which:
+  # * targets the association's model.
+  #   So +Post.follow_assoc(:comments)+ will return comments.
+  # * only returns the records that are associated with those that the receiver would return.
+  #   So +Post.where(published: true).follow_assoc(:comments)+ only returns the comments of
+  #   published posts.
+  #
+  # You could say this is a way of doing a +#flat_map+ of the association on the result
+  # of the current relation, but without loading the records of the first relation and
+  # without having to worry about eager loading.
+  #
+  # Examples (with equivalent +#flat_map+)
+  #
+  #   # Comments of published posts
+  #   Post.where(published: true).follow_assoc(:comments)
+  #   # Somewhat equivalent to. (Need to use preload to avoid the N+1 query problem)
+  #   Post.where(published: true).preload(:comments).flat_map(:comments)
+  #
+  # The main differences between the +#flat_map+ and +#follow_assoc+ approaches:
+  # * +#follow_assoc+ returns a relation (or query or scope, however you call it), so you can
+  #   use other scoping methods, such as +#where+, +#limit+, +#order+.
+  # * +#flat_map+ returns an Array, so you cannot use other scoping methods.
+  # * +#flat_map+ must be used with eager loading. Forgetting to do so makes N+1 query likely.
+  # * +#follow_assoc+ only loads the final matched records.
+  # * +#flat_map+ loads every associations on the way, this is wasteful when you don't need them.
+  #
+  # [association_names]
+  #   The first argument(s) are the associations that you want to follow. They are the names of
+  #   your +#belongs_to+, +#has_many+, +#has_one+, +#has_and_belongs_to_many+.
+  #
+  #   If you pass in more than one, they will be followed in order.
+  #   Ex: +Post.follow_assoc(:comments, :author)+ gives you the authors of the comments of the posts.
+  #
+  # [options]
+  #   Following are the options that can be passed as last argument.
+  #
+  #   If you are passing multiple association_names, the options only affect the last association.
+  #
+  # [option :ignore_limit]
+  #   When true, +#has_one+ will be treated like a +#has_many+.
+  #
+  #   Main reasons to use ignore_limit: true
+  #   * Needed for MySQL to be able to do anything with +#has_one+ associations because MySQL
+  #     doesn't support sub-limit. <br>
+  #     See {MySQL doesn't support limit}[https://github.com/MaxLap/activerecord_follow_assoc#mysql-doesnt-support-sub-limit] <br>
+  #     Note, this does mean the +#has_one+ will be treated as if it was a +#has_many+ for MySQL too.
+  #   * You have a +#has_one+ association which you know can never have more than one record and are
+  #     dealing with a heavy/slow query. The query used to deal with +#has_many+ is less complex, and
+  #     may prove faster.
+  #   * For this one special case, you want to check the other records that match your has_one
+  #
+  # [option :poly_belongs_to]
+  #   If the last association of association_names is a polymorphic belongs_to, then by default,
+  #   +#follow_assoc+ will raise an exception. This is because there are many unrelated models
+  #   that could be the one referred to by the records, but an ActiveRecord relation can only
+  #   target a single Model.
+  #
+  #   For this reason, you must choose which Model to "look into" when following a polymorphic
+  #   belongs_to. This is what the :poly_belongs_to option does.
+  #
+  #   For example, you can't just go from "Picture" and follow_assoc the polymorphic belongs_to
+  #   association "imageable". But if what you are looking for is only the employees, then this works:
+  #     employee_scope = pictures_scope.follow_assoc(:imageable, poly_belongs_to: Employee)
+  #
+  def follow_assoc(*association_names)
+    options = association_names.extract_options!
+    ActiveRecordFollowAssoc::CoreLogic.follow_assoc(self, association_names, options)
+  end
+end

data/lib/active_record_follow_assoc/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordFollowAssoc
+  VERSION = "0.1.0"
+end

data/lib/active_record_follow_assoc.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Just in case of typo in the require. Call the right one automatically
+# The gem name is activerecord_follow_assoc, so it's what gets required automatically
+# But to fit with usual naming, since we write ActiveRecord, it means for namespacing, we use active_record_follow_assoc
+require_relative "activerecord_follow_assoc"

data/lib/activerecord_follow_assoc.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_record_follow_assoc/version"
+require "active_record"
+
+module ActiveRecordFollowAssoc
+  def self.default_options
+    @default_options ||= {
+        ignore_limit: false,
+    }
+  end
+
+  require_relative "active_record_follow_assoc/exceptions"
+  require_relative "active_record_follow_assoc/core_logic"
+  require_relative "active_record_follow_assoc/query_methods"
+
+  module ClassDelegates
+    # Delegating the methods in QueryMethods from ActiveRecord::Base to :all. Same thing ActiveRecord does for #where.
+    new_query_methods = QueryMethods.public_instance_methods
+    delegate(*new_query_methods, to: :all)
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord.eager_load!
+
+  ActiveRecord::Relation.include(ActiveRecordFollowAssoc::QueryMethods)
+  ActiveRecord::Base.extend(ActiveRecordFollowAssoc::ClassDelegates)
+end

metadata

@@ -0,0 +1,196 @@
+--- !ruby/object:Gem::Specification
+name: activerecord_follow_assoc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Maxime Lapointe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-09-28 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: rspec
+  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: 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: 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
+    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: niceql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.23
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.23
+- !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: 'In ActiveRecord, allows you to query the association of the records
+  that your current query would return. If you need the comments of some posts: `Post.where(...).follow_assoc(:comments)`.
+  You can then chain `where` on the comments.'
+email:
+- hunter_spawn@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/active_record_follow_assoc.rb
+- lib/active_record_follow_assoc/active_record_compat.rb
+- lib/active_record_follow_assoc/core_logic.rb
+- lib/active_record_follow_assoc/exceptions.rb
+- lib/active_record_follow_assoc/query_methods.rb
+- lib/active_record_follow_assoc/version.rb
+- lib/activerecord_follow_assoc.rb
+homepage: https://github.com/MaxLap/activerecord_follow_assoc
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/MaxLap/activerecord_follow_assoc
+  source_code_uri: https://github.com/MaxLap/activerecord_follow_assoc
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Follow associations within your ActiveRecord queries
+test_files: []