ransack 6.0.1 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9940472d0658f87581dd23a9668c17b557806f72735ed8e66ceef5332c099d8b
-  data.tar.gz: 576b1c827db6b63a08d980c91fd063eee4b5bbdb359503a9c4af0bacfc134cfe
+  metadata.gz: 179b4004dbf19b3b72ebb685877fa5648b8f14b6180f0bf65cc03149be416ca6
+  data.tar.gz: 236e4f6a442ebc4dbd6abd0acb2824d6aff7ac56bff553b3f44bd3b473d766c4
 SHA512:
-  metadata.gz: 173aab57088df1db09eff37d4e3098ebbb18042fe387ab151958d7d5a892481bbfffc2cd35b1934f87e015c79bdd60f53d3be6a1828e9d541cda76725947a19e
-  data.tar.gz: 759843af14c0312b0167661a6e650bf933da0cb8ee652ad381452b7509f9e348f59c4a45fa274f6f0364bb78e48a142e171788039fd8f9690e50200108f8c1f3
+  metadata.gz: 8d19b1a2f55526e8c2bce3f68cdf4c8844d4ae5d6996d0a843f145a48682506157b9aed2578f40cc9b839f31b0a4faea7a65abdfca5da98a43a26b1dae2cb77f
+  data.tar.gz: dacca9e1ecd1ba15e58ca2bd92d87d2d491e3e4326180248d79aa62fb486dc1eb0700459dc86ef6ed2154b4def13ae1e65fcad0d0a0f40f7cfc7284fe1c94607

data/README.md

@@ -1,88 +1,63 @@
-# ![Ransack](./docs/assets/logo/ransack-h.png "Ransack")
+# Ransack
+
+> Search everywhere and in a hurry!
 
 [![Build Status](https://github.com/activerecord-hackery/ransack/workflows/test/badge.svg)](https://github.com/activerecord-hackery/ransack/actions)
 [![Gem Version](https://badge.fury.io/rb/ransack.svg)](http://badge.fury.io/rb/ransack)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/activerecord-hackery/ransack)
-[![Code Climate](https://codeclimate.com/github/activerecord-hackery/ransack/badges/gpa.svg)](https://codeclimate.com/github/activerecord-hackery/ransack)
-
-# Introduction
-
-Ransack will help you easily add **searching to your Rails application**, without any additional dependencies.
-
-There are advanced searching solutions around, like ElasticSearch or Algolia. **Ransack** will do the job for many Rails websites, without the need to run additional infrastructure or work in a different language. With Ransack you do it all with standard Ruby and ERB.
-
-Ready to move beyond the basics? Use **advanced features** like i18n and extensive configuration options.
 
-Ransack is supported for Rails 8.1, 8.0, 7.2 on Ruby 3.2 and later.
+Ransack adds **searching and sorting to your Rails application** with plain Ruby
+and ERB, without a search server or any other infrastructure.
 
-## Installation
+Ransack is supported for Rails 8.1 on Ruby 3.4 and later, on Postgres, MySQL, Trilogy and SQLite.
 
-To install `ransack` and add it to your Gemfile, run
-
-```ruby title='Gemfile'
+```ruby
 gem 'ransack'
 ```
 
-### Bleeding edge
-
-If you would like to use the latest updates not yet published to RubyGems, use the `main` branch:
-
-```ruby title='Gemfile'
-gem 'ransack', :github => 'activerecord-hackery/ransack', :branch => 'main'
+```ruby
+@q = Post.ransack(params[:q])
+@posts = @q.result
 ```
 
-### Documentation
-
-There is [extensive documentation on Ransack](https://activerecord-hackery.github.io/ransack/), built with [Jekyll](https://jekyllrb.com/) and [Just the Docs](https://just-the-docs.com/) from the Markdown under `docs/` and published as a GitHub Pages site. Alternatively there is [AI Generated documentation](https://deepwiki.com/activerecord-hackery/ransack/1-overview) produced by [devin.ai](https://devin.ai/).
-
-This [gist](https://gist.github.com/raghubetina/d5fc3df67ddbadcac271) has a quick-start cheatsheet, created by [@raghubetina](https://gist.github.com/raghubetina)
-
-## Issue tracker
-
-* Before filing an issue, please read the [Contributing Guide](CONTRIBUTING.md).
-* File an issue if a bug is caused by Ransack, is new (has not already been reported), and _can be reproduced from the information you provide_.
-* Please consider creating a pull request with a failing test that demonstrates the problem.
-* Contributions are welcome. :smiley:
-* Please do not use the issue tracker for personal support requests. Stack Overflow or [GitHub Discussions](https://github.com/activerecord-hackery/ransack/discussions) is a better place for that where a wider community can help you!
-
-
-## Contributions
-
-To support the project:
-
-* Use Ransack in your apps, and let us know if you encounter anything that's
-broken or missing. A failing spec to demonstrate the issue is awesome. A pull
-request with passing tests is even better!
-* Before filing an issue or pull request, be sure to read and follow the
-[Contributing Guide](CONTRIBUTING.md).
-* Please use Stack Overflow or [GitHub Discussions](https://github.com/activerecord-hackery/ransack/discussions) for questions or discussion not
-directly related to bug reports, pull requests, or documentation improvements.
-* Spread the word on social media if Ransack's been useful
-to you. The more people who are using the project, the quicker we can find and
-fix bugs!
+```erb
+<%= search_form_for @q do |f| %>
+  <%= f.search_field :title_cont %>
+<% end %>
+<%= sort_link(@q, :published_at) %>
+```
 
-## Ransack for enterprise
+## Documentation
 
-Available as part of the [Tidelift Subscription](https://tidelift.com/subscription/pkg/rubygems-ransack?utm_source=rubygems-ransack&utm_medium=referral&utm_campaign=enterprise&utm_term=repo).
+**[activerecord-hackery.github.io/ransack](https://activerecord-hackery.github.io/ransack/)**:
+[getting started](https://activerecord-hackery.github.io/ransack/getting-started/),
+[authorization](https://activerecord-hackery.github.io/ransack/getting-started/authorization/),
+[predicates](https://activerecord-hackery.github.io/ransack/getting-started/search-matches/),
+[upgrading](https://activerecord-hackery.github.io/ransack/getting-started/upgrading/)
+and more. The site is built from the Markdown under [`docs/`](docs/).
 
-The maintainers of Ransack and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/rubygems-ransack?utm_source=rubygems-ransack&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+## Getting help and contributing
 
-## Security contact information
+* Questions belong in [GitHub Discussions](https://github.com/activerecord-hackery/ransack/discussions).
+* Reproducible bugs belong in [Issues](https://github.com/activerecord-hackery/ransack/issues).
+  Read the [Contributing Guide](CONTRIBUTING.md) first; a failing test is the best bug report.
+* Report security vulnerabilities privately, through GitHub
+  [private vulnerability reporting](https://github.com/activerecord-hackery/ransack/security/advisories/new)
+  or the [Tidelift security contact](https://tidelift.com/security). See the
+  [Security Policy](.github/SECURITY.md) for supported versions.
 
-To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure. See the [Security Policy](.github/SECURITY.md) for supported versions.
+Ransack is maintained by volunteers. If it is useful to you, please consider
+supporting us via [Open Collective](https://opencollective.com/ransack), or
+through the [Tidelift Subscription](https://tidelift.com/subscription/pkg/rubygems-ransack?utm_source=rubygems-ransack&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+for commercial support.
 
 ## Contributors
 
-Ransack was created by [Ernie Miller](http://twitter.com/erniemiller) and is developed and maintained by:
-* [Sean Carroll](https://github.com/scarroll32)
-* [Deivid Rodriguez](https://github.com/deivid-rodriguez)
-* [Greg Molnar](https://github.com/gregmolnar)
-* [A great group of contributors](https://github.com/activerecord-hackery/ransack/graphs/contributors).
-- Ransack's logo is designed by [Anıl Kılıç](https://github.com/anilkilic).
-
-Alumni Maintainers
-- [Jon Atack](http://twitter.com/jonatack)
-- [Ryan Bigg](http://twitter.com/ryanbigg)
-
-This project exists thanks to all the people who contribute. <img src="https://opencollective.com/ransack/contributors.svg?width=890&button=false" />
+Ransack is maintained by [Sean Carroll](https://github.com/scarroll32),
+[Deivid Rodriguez](https://github.com/deivid-rodriguez),
+[Greg Molnar](https://github.com/gregmolnar) and
+[a great group of contributors](https://github.com/activerecord-hackery/ransack/graphs/contributors).
+It was created by [Ernie Miller](http://twitter.com/erniemiller). See
+[Community and support](https://activerecord-hackery.github.io/ransack/project/community/)
+for the full list.
 
+<img src="https://opencollective.com/ransack/contributors.svg?width=890&button=false" />

data/lib/ransack/active_record/context.rb

@@ -20,23 +20,36 @@ module Ransack
       # Attributes API rather than the schema column, so that
       # `attribute :starts_at, :datetime` on a date column is honoured (#1028);
       # a column with no attribute override reports its column type.
+      #
+      # There is no separate check that the table exists: the schema cache
+      # does not list temporary tables, and matches names case-sensitively
+      # where SQLite does not, so it rejected tables Active Record queries
+      # fine (#1770, #657, #668). A table that really is missing fails when
+      # the model loads its columns, with Active Record's own error.
       def type_for(attr)
         return nil unless attr && attr.valid?
-        relation     = attr.arel_attribute.relation
-        name         = attr.arel_attribute.name.to_s
-        table        = relation.respond_to?(:table_name) ? relation.table_name : relation.name
-        schema_cache = self.klass.connection_pool.schema_cache
-        unless schema_cache.send(:data_source_exists?, table)
-          raise "No table named #{table} exists."
-        end
+        name = attr.arel_attribute.name.to_s
         return nil unless attr.klass.attribute_types.key?(name)
 
         attr.klass.type_for_attribute(name).type
       end
 
+      # Evaluating a search leaves the context as it was, so the search can
+      # be evaluated again, or given another condition or sort, and still
+      # line up with the query Active Record builds (#1745, #1750).
+      #
+      # The relation returned keeps only the joins Ransack added that the
+      # search, as it stands now, reads: a condition or sort on the joined
+      # table, or one on an association reached through it. A negative
+      # condition on a collection is a correlated subquery and reads none of
+      # its own. Joins the relation already had are always kept.
       def evaluate(search, opts = {})
         viz = Visitor.new
-        relation = @object.where(viz.accept(search.base))
+        predicate, used = tracking_used_associations do
+          search.sorts.each { |sort| use_association(sort.parent) if sort.valid? }
+          viz.accept(search.base)
+        end
+        relation = with_joins_used_by(@object, used).where(predicate)
 
         if search.sorts.any?
           relation = relation.except(:order)
@@ -74,12 +87,22 @@ module Ransack
         opts[:distinct] ? relation.distinct : relation
       end
 
+      # Asked for the same names over and over while a search is built, and
+      # answered from the allowlists, so kept per model for the life of the
+      # context and dropped with them.
       def attribute_method?(str, klass = @klass)
         return false unless key_within_depth_limit?(str)
 
+        cache = ((@attribute_methods ||= {})[klass] ||= {})
+        key = str.to_s
+        return cache[key] if cache.key?(key)
+
+        cache[key] = attribute_method_uncached?(key, klass)
+      end
+
+      def attribute_method_uncached?(str, klass)
         exists = false
-        if ransackable_attribute?(str, klass) ||
-           ransortable_attribute?(str, klass)
+        if allowlisted_attribute?(str, klass)
           exists = true
         elsif (segments = str.split(Constants::UNDERSCORE)).size > 1
           remainder = []
@@ -90,7 +113,7 @@ module Ransack
               segments.join(Constants::UNDERSCORE)
               )
             if found_assoc = traversable_association(assoc, poly_class, klass)
-              exists = attribute_method?(
+              exists = attribute_method_uncached?(
                 remainder.join(Constants::UNDERSCORE),
                 poly_class || found_assoc.klass
                 )
@@ -99,6 +122,20 @@ module Ransack
         end
         exists
       end
+      private :attribute_method_uncached?
+
+      # A name on the allowlists is only taken for an attribute of `klass`
+      # when it is one: a column or `attribute` declaration, an
+      # `alias_attribute`, a ransacker or a `ransack_alias`. Anything else,
+      # such as `person_name` listed on Article, is left to be followed
+      # through the associations rather than bound as a missing column
+      # (#1774).
+      def allowlisted_attribute?(str, klass)
+        (ransackable_attribute?(str, klass) || ransortable_attribute?(str, klass)) &&
+          (klass.has_attribute?(str) || klass._ransackers.key?(str) ||
+           klass._ransack_aliases.key?(str))
+      end
+      private :allowlisted_attribute?
 
       def table_for(parent)
         parent.table
@@ -155,24 +192,36 @@ module Ransack
         @join_dependency.send(:alias_tracker)
       end
 
+      # Keeps a join, and every join it hangs off, in every evaluation,
+      # whether or not the search reads it.
       def lock_association(association)
         @lock_associations << association
       end
 
-      # Drops a join Ransack added, when a negative condition on a collection
-      # replaces it with a correlated subquery. A join the relation already
-      # had, or one another condition needs, is locked and stays.
-      def remove_association(association)
-        return if @lock_associations.include?(association)
+      # Records that the search being evaluated reads the association's
+      # joined table, so its join, and every join it hangs off, stays.
+      def use_association(association)
+        @used_associations << association if @used_associations && association
+      end
 
-        @associations_pot.delete(association)
-        @base.children.delete_if { |child| child.equal?(association) }
-        @object.left_outer_joins_values = @object.left_outer_joins_values.reject { |jd|
-          jd.is_a?(JoinDependency) &&
-          jd.instance_variable_get(:@join_root).children.map(&:object_id) == [association.object_id]
-        }
+      # Records that the search being evaluated reads the joins the
+      # association hangs off but not its own: a negative condition on a
+      # collection is a subquery, but one nested under another collection
+      # still needs that collection's join.
+      def use_ancestors_of(association)
+        use_association(parent_of(association)) if association
       end
 
+      # Whether the association hangs directly off the model searched,
+      # rather than off another association.
+      def root_association?(association)
+        parent_of(association).equal?(@base)
+      end
+
+      # Kept for callers of the 6.0.0 API. Evaluation now keeps only the
+      # joins the search reads, so a join nothing reads is already left out.
+      def remove_association(_association); end
+
       # Build an Arel subquery that selects keys for the top query,
       # drawn from the first join association's foreign_key.
       #
@@ -192,34 +241,48 @@ module Ransack
       # because it is correlated to the primary key on the outer query.
       #
       def build_correlated_subquery(association)
+        correlated_subquery(association).last
+      end
+
+      # The subquery a negative condition on a collection is tested against,
+      # and the outer query's column to test: the primary key, or the
+      # association's `primary_key:` when it has one.
+      #
+      # The subquery correlates on the join condition that references the
+      # outer table, and keeps the join's other conditions: the type column
+      # of a polymorphic or STI association, the association's scope and the
+      # target's default scope. Leaving them out counted rows the association
+      # does not reach (#1747).
+      def correlated_subquery(association)
         join_constraints = extract_joins(association)
         join_root = join_constraints.shift
-        correlated_key = extract_correlated_key(join_root)
-        subquery = Arel::SelectManager.new(association.base_klass)
+        correlation = extract_correlation(join_root)
+        raise 'Ransack encountered an unexpected arel structure' unless correlation
+
+        inner_key, outer_key = correlated_keys(correlation)
+        subquery = Arel::SelectManager.new(association.base_klass.arel_table)
         subquery.from(join_root.left)
-        subquery.project(correlated_key)
+        subquery.project(inner_key)
         join_constraints.each do |j|
           subquery.join_sources << Arel::Nodes::InnerJoin.new(j.left, j.right)
         end
 
-        # Handle polymorphic associations where correlated_key is an array
-        if correlated_key.is_a?(Array)
-          # For polymorphic associations, we need to add conditions for both the foreign key and type
-          correlated_key.each_with_index do |key, index|
-            if index == 0
-              # This is the foreign key
-              subquery = subquery.where(key.eq(primary_key))
-            else
-              # This is the type key, which should be equal to the model name
-              subquery = subquery.where(key.eq(@klass.name))
-            end
-          end
-        else
-          # Original behavior for non-polymorphic associations
-          subquery = subquery.where(correlated_key.eq(primary_key))
+        subquery.where(inner_key.eq(outer_key))
+        join_conditions(join_root).each do |condition|
+          subquery.where(condition) unless condition.equal?(correlation)
         end
 
-        subquery
+        [outer_key, subquery]
+      end
+
+      # The SQL for a correlated subquery, with bind values inlined the way
+      # Relation#to_sql renders them, since the subquery is embedded in the
+      # outer query as a string. An association or default scope condition
+      # in the subquery carries its value as a bind.
+      def subquery_sql(subquery)
+        @klass.with_connection do |connection|
+          connection.unprepared_statement { connection.to_sql(subquery) }
+        end
       end
 
       def primary_key
@@ -228,50 +291,61 @@ module Ransack
 
       private
 
-      def extract_correlated_key(join_root)
-        case join_root
+      # The conditions in a join's ON clause, with its ANDs flattened.
+      def join_conditions(join)
+        on = [join.right, join.left].find { |node| node.is_a?(Arel::Nodes::On) }
+        on ? and_children(on.expr) : []
+      end
+
+      def and_children(node)
+        node.is_a?(Arel::Nodes::And) ? node.children.flat_map { |child| and_children(child) } : [node]
+      end
+
+      # The equality in a join's ON clause that ties the joined table to
+      # the outer query's table.
+      def extract_correlation(node)
+        case node
         when Arel::Nodes::OuterJoin
-          # one of join_root.right/join_root.left is expected to be Arel::Nodes::On
-          if join_root.right.is_a?(Arel::Nodes::On)
-            extract_correlated_key(join_root.right.expr)
-          elsif join_root.left.is_a?(Arel::Nodes::On)
-            extract_correlated_key(join_root.left.expr)
-          else
-            raise 'Ransack encountered an unexpected arel structure'
-          end
+          on = [node.right, node.left].find { |side| side.is_a?(Arel::Nodes::On) }
+          raise 'Ransack encountered an unexpected arel structure' unless on
+
+          extract_correlation(on.expr)
         when Arel::Nodes::Equality
-          pk = primary_key
-          if join_root.left.eql?(pk)
-            join_root.right
-          elsif join_root.right.eql?(pk)
-            join_root.left
-          else
-            nil
-          end
+          node if correlated_keys(node)
         when Arel::Nodes::And
-          # And may have multiple children, so we need to check all, not via left/right
-          if join_root.children.any?
-            join_root.children.each do |child|
-              key = extract_correlated_key(child)
-              return key if key
-            end
-          else
-            extract_correlated_key(join_root.left) || extract_correlated_key(join_root.right)
+          node.children.each do |child|
+            correlation = extract_correlation(child)
+            return correlation if correlation
           end
+          nil
         else
-          # eg parent was Arel::Nodes::And and the evaluated side was one of
-          # Arel::Nodes::Grouping or MultiTenant::TenantEnforcementClause
+          # eg a Grouping, or a MultiTenant::TenantEnforcementClause
           nil
         end
       end
 
+      # [inner, outer] for an equality with exactly one side on the outer
+      # query's table, or nil.
+      def correlated_keys(equality)
+        left_outer  = outer_attribute?(equality.left)
+        right_outer = outer_attribute?(equality.right)
+        if left_outer && !right_outer
+          [equality.right, equality.left]
+        elsif right_outer && !left_outer
+          [equality.left, equality.right]
+        end
+      end
+
+      def outer_attribute?(node)
+        node.is_a?(Arel::Attributes::Attribute) && node.relation.eql?(@object.table)
+      end
+
       def get_parent_and_attribute_name(str, parent = @base)
         return [parent, nil] unless key_within_depth_limit?(str)
 
         attr_name = nil
 
-        if ransackable_attribute?(str, klassify(parent)) ||
-           ransortable_attribute?(str, klassify(parent))
+        if allowlisted_attribute?(str, klassify(parent))
           attr_name = str
         elsif (segments = str.split(Constants::UNDERSCORE)).size > 1
           remainder = []
@@ -332,7 +406,9 @@ module Ransack
       # agree. Ransack stashes the joins it adds through `left_outer_joins`,
       # one dependency per association in the order they are added, which is
       # where they fall in that order; a join the relation already has is
-      # reused rather than added again.
+      # reused rather than added again. Their aliases are pinned, so a join
+      # added to the result later, which renders ahead of them, is aliased
+      # around them instead (see JoinDependencyExtensions#pin_search_tables).
       #
       # The relation's own joins keep their tree shape in the mirror. A node
       # Ransack adds sits directly under the mirror root whatever its depth,
@@ -358,14 +434,24 @@ module Ransack
         # `where(assoc: { ... })` records the association name as a reference,
         # and Active Record then aliases that join to the name (#1437).
         mirror.instance_variable_set(:@references, referenced_aliases(relation))
+        # Before any join is given an alias, so the joins an earlier search
+        # added keep theirs (#1776).
+        mirror.pin_search_tables(left.grep(JoinDependency))
         root = mirror.instance_variable_get(:@join_root)
 
         root.children.each { |child| adopt(mirror, root, child, Arel::Nodes::InnerJoin) }
         stashed.each { |jd| graft(mirror, jd, jd.instance_variable_get(:@join_type)) }
         graft(mirror, JoinDependency.new(relation.klass, relation.table, named_joins(left), Arel::Nodes::OuterJoin), Arel::Nodes::OuterJoin)
-        left.grep(JoinDependency).each { |jd| graft(mirror, jd, jd.instance_variable_get(:@join_type)) }
+        # The joins a search added after counting the eager load are rendered
+        # after it (JoinDependencyExtensions#eager_load_first), as long as the
+        # relation still eager loads; otherwise they keep their order. Those
+        # this search adds are counted after it too.
+        @eager_loading = !eager_jd.nil? || eager.any?
+        after_eager, before_eager = left.grep(JoinDependency).partition { |jd| @eager_loading && jd.after_eager_load }
+        before_eager.each { |jd| graft(mirror, jd, jd.instance_variable_get(:@join_type)) }
         graft(mirror, eager_jd, Arel::Nodes::OuterJoin) if eager_jd
         graft(mirror, JoinDependency.new(relation.klass, relation.table, eager, Arel::Nodes::OuterJoin), Arel::Nodes::OuterJoin)
+        after_eager.each { |jd| graft(mirror, jd, jd.instance_variable_get(:@join_type)) }
 
         mirror
       end
@@ -435,9 +521,53 @@ module Ransack
       end
 
       # The nodes that hang off a parent: the relation's own joins under it,
-      # plus the ones Ransack added under it.
+      # plus the ones Ransack added under it. The nodes Ransack added all sit
+      # under the mirror root whatever their parent, so the root's children
+      # are filtered to the relation's own; otherwise a nested `person` would
+      # be found as the root's `person` too (#1775).
       def children_of(parent)
-        parent.children + @associations_pot.select { |_node, node_parent| node_parent.equal?(parent) }.keys
+        parent.children.reject { |node| @associations_pot.key?(node) } +
+          @associations_pot.select { |_node, node_parent| node_parent.equal?(parent) }.keys
+      end
+
+      # Collects the associations the block's evaluation reads. Saved and
+      # restored, so an evaluation nested inside another one (a ransacker
+      # that runs a search on this context) keeps its own list.
+      def tracking_used_associations
+        outer = @used_associations
+        @used_associations = []
+        result = yield
+        [result, @used_associations]
+      ensure
+        @used_associations = outer
+      end
+
+      # The relation without the joins Ransack added that the search does not
+      # read. A join the relation already had is not Ransack's, and stays.
+      def with_joins_used_by(relation, used)
+        needed = with_ancestors(used + @lock_associations).map(&:object_id)
+        unused = @associations_pot.keys.map(&:object_id) - needed
+        return relation if unused.empty?
+
+        relation = relation.dup
+        relation.left_outer_joins_values = relation.left_outer_joins_values.reject { |jd|
+          jd.is_a?(JoinDependency) &&
+          (children = jd.instance_variable_get(:@join_root).children).size == 1 &&
+          unused.include?(children.first.object_id)
+        }
+        relation
+      end
+
+      def with_ancestors(associations)
+        associations.flat_map do |association|
+          chain = []
+          node = association
+          while node && !node.equal?(@base)
+            chain << node
+            node = parent_of(node)
+          end
+          chain
+        end
       end
 
       def build_or_find_association(name, parent = @base, klass = nil)
@@ -460,6 +590,8 @@ module Ransack
           Join.new(name, @join_type, klass),
           @join_type
         )
+        jd.added_by_search = true
+        jd.after_eager_load = @eager_loading
         found_association = jd.instance_variable_get(:@join_root).children.last
 
         @associations_pot[found_association] = parent

data/lib/ransack/active_record/join_association.rb

@@ -8,7 +8,13 @@ module Ransack
     # collection uses the same aliases as the outer query.
     module JoinAssociationExtensions
       def self.prepended(base)
-        base.class_eval { attr_reader :join_type }
+        base.class_eval do
+          attr_reader :join_type
+          # The tables of the joins this node renders itself, as Ransack
+          # first assigned them: its reflection chain up to the first table
+          # an earlier join already provides.
+          attr_accessor :own_tables
+        end
       end
 
       def initialize(reflection, children, polymorphic_class = nil, join_type = Arel::Nodes::InnerJoin)
@@ -75,7 +81,7 @@ module Ransack
 
           if others && !others.empty?
             joins.concat arel.join_sources
-            append_constraints_to(joins.last, others)
+            append_constraints(joins.last, others)
           end
 
           # The current table in this iteration becomes the foreign table in the next
@@ -84,21 +90,6 @@ module Ransack
 
         joins
       end
-
-      private
-
-      # Active Record's private append_constraints takes a leading connection
-      # argument in 7.2.0–7.2.2.2 and 8.0.0–8.0.2, and none in 7.2.3+, 8.0.3+
-      # and 8.1; the arity says which is loaded.
-      def append_constraints_to(join, constraints)
-        if method(:append_constraints).arity == 3
-          base_klass.with_connection do |connection|
-            append_constraints(connection, join, constraints)
-          end
-        else
-          append_constraints(join, constraints)
-        end
-      end
     end
   end
 end