ransack 2.1.0 → 2.4.0

data/lib/polyamorous/activerecord_5.2_ruby_2/reflection.rb

@@ -0,0 +1,11 @@
+module Polyamorous
+  module ReflectionExtensions
+    def join_scope(table, foreign_table, foreign_klass)
+      if respond_to?(:polymorphic?) && polymorphic?
+        super.where!(foreign_table[foreign_type].eq(klass.name))
+      else
+        super
+      end
+    end
+  end
+end

data/lib/polyamorous/activerecord_6.0_ruby_2/join_association.rb

@@ -0,0 +1 @@
+require 'polyamorous/activerecord_5.2_ruby_2/join_association'

data/lib/polyamorous/activerecord_6.0_ruby_2/join_dependency.rb

@@ -0,0 +1,80 @@
+# active_record_6.0_ruby_2/join_dependency.rb
+module Polyamorous
+  module JoinDependencyExtensions
+    # Replaces ActiveRecord::Associations::JoinDependency#build
+    def build(associations, base_klass)
+      associations.map do |name, right|
+        if name.is_a? Join
+          reflection = find_reflection base_klass, name.name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          klass = if reflection.polymorphic?
+            name.klass || base_klass
+          else
+            reflection.klass
+          end
+          JoinAssociation.new(reflection, build(right, klass), name.klass, name.type)
+        else
+          reflection = find_reflection base_klass, name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          if reflection.polymorphic?
+            raise ActiveRecord::EagerLoadPolymorphicError.new(reflection)
+          end
+          JoinAssociation.new(reflection, build(right, reflection.klass))
+        end
+      end
+    end
+
+    def join_constraints(joins_to_add, alias_tracker)
+      @alias_tracker = alias_tracker
+
+      construct_tables!(join_root)
+      joins = make_join_constraints(join_root, join_type)
+
+      joins.concat joins_to_add.flat_map { |oj|
+        construct_tables!(oj.join_root)
+        if join_root.match?(oj.join_root) && join_root.table.name == oj.join_root.table.name
+          walk join_root, oj.join_root, oj.join_type
+        else
+          make_join_constraints(oj.join_root, oj.join_type)
+        end
+      }
+    end
+
+    private
+      def make_constraints(parent, child, join_type = Arel::Nodes::OuterJoin)
+        foreign_table = parent.table
+        foreign_klass = parent.base_klass
+        join_type = child.join_type || join_type if join_type == Arel::Nodes::InnerJoin
+        joins = child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker)
+        joins.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
+      end
+
+    module ClassMethods
+      # Prepended before ActiveRecord::Associations::JoinDependency#walk_tree
+      #
+      def walk_tree(associations, hash)
+        case associations
+        when TreeNode
+          associations.add_to_tree(hash)
+        when Hash
+          associations.each do |k, v|
+            cache =
+              if TreeNode === k
+                k.add_to_tree(hash)
+              else
+                hash[k] ||= {}
+              end
+            walk_tree(v, cache)
+          end
+        else
+          super(associations, hash)
+        end
+      end
+    end
+
+  end
+end

data/lib/polyamorous/activerecord_6.0_ruby_2/reflection.rb

@@ -0,0 +1 @@
+require 'polyamorous/activerecord_5.2_ruby_2/reflection'

data/lib/polyamorous/activerecord_6.1_ruby_2/join_association.rb

@@ -0,0 +1,74 @@
+module Polyamorous
+  module JoinAssociationExtensions
+    include SwappingReflectionClass
+    def self.prepended(base)
+      base.class_eval { attr_reader :join_type }
+    end
+
+    def initialize(reflection, children, polymorphic_class = nil, join_type = Arel::Nodes::InnerJoin)
+      @join_type = join_type
+      if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
+        swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
+          super(reflection, children)
+          self.reflection.options[:polymorphic] = true
+        end
+      else
+        super(reflection, children)
+      end
+    end
+
+    # Same as #join_constraints, but instead of constructing tables from the
+    # given block, uses the ones passed
+    def join_constraints_with_tables(foreign_table, foreign_klass, join_type, alias_tracker, tables)
+      joins = []
+      chain = []
+
+      reflection.chain.each.with_index do |reflection, i|
+        table = tables[i]
+
+        @table ||= table
+        chain << [reflection, table]
+      end
+
+      # The chain starts with the target table, but we want to end with it here (makes
+      # more sense in this context), so we reverse
+      chain.reverse_each do |reflection, table|
+        klass = reflection.klass
+
+        join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
+
+        unless join_scope.references_values.empty?
+          join_dependency = join_scope.construct_join_dependency(
+            join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
+          )
+          join_scope.joins!(join_dependency)
+        end
+
+        arel = join_scope.arel(alias_tracker.aliases)
+        nodes = arel.constraints.first
+
+        if nodes.is_a?(Arel::Nodes::And)
+          others = nodes.children.extract! do |node|
+            !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+          end
+        end
+
+        joins << table.create_join(table, table.create_on(nodes), join_type)
+
+        if others && !others.empty?
+          joins.concat arel.join_sources
+          append_constraints(joins.last, others)
+        end
+
+        # The current table in this iteration becomes the foreign table in the next
+        foreign_table, foreign_klass = table, klass
+      end
+
+      joins
+    end
+
+    def ==(other)
+      base_klass == other.base_klass
+    end
+  end
+end

data/lib/polyamorous/activerecord_6.1_ruby_2/join_dependency.rb

@@ -0,0 +1,93 @@
+# active_record_6.1_ruby_2/join_dependency.rb
+module Polyamorous
+  module JoinDependencyExtensions
+    # Replaces ActiveRecord::Associations::JoinDependency#build
+    def build(associations, base_klass)
+      associations.map do |name, right|
+        if name.is_a? Join
+          reflection = find_reflection base_klass, name.name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          klass = if reflection.polymorphic?
+            name.klass || base_klass
+          else
+            reflection.klass
+          end
+          JoinAssociation.new(reflection, build(right, klass), name.klass, name.type)
+        else
+          reflection = find_reflection base_klass, name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          if reflection.polymorphic?
+            raise ActiveRecord::EagerLoadPolymorphicError.new(reflection)
+          end
+          JoinAssociation.new(reflection, build(right, reflection.klass))
+        end
+      end
+    end
+
+    def join_constraints(joins_to_add, alias_tracker, references)
+      @alias_tracker = alias_tracker
+      @joined_tables = {}
+      @references = {}
+
+      references.each do |table_name|
+        @references[table_name.to_sym] = table_name if table_name.is_a?(String)
+      end
+
+      joins = make_join_constraints(join_root, join_type)
+
+      joins.concat joins_to_add.flat_map { |oj|
+        if join_root.match?(oj.join_root) && join_root.table.name == oj.join_root.table.name
+          walk join_root, oj.join_root, oj.join_type
+        else
+          make_join_constraints(oj.join_root, oj.join_type)
+        end
+      }
+    end
+
+    def construct_tables_for_association!(join_root, association)
+      tables = table_aliases_for(join_root, association)
+      association.table = tables.first
+      tables
+    end
+
+    private
+
+    def table_aliases_for(parent, node)
+      node.reflection.chain.map { |reflection|
+        alias_tracker.aliased_table_for(reflection.klass.arel_table) do
+          root = reflection == node.reflection
+          name = reflection.alias_candidate(parent.table_name)
+          root ? name : "#{name}_join"
+        end
+      }
+    end
+
+    module ClassMethods
+      # Prepended before ActiveRecord::Associations::JoinDependency#walk_tree
+      #
+      def walk_tree(associations, hash)
+        case associations
+        when TreeNode
+          associations.add_to_tree(hash)
+        when Hash
+          associations.each do |k, v|
+            cache =
+              if TreeNode === k
+                k.add_to_tree(hash)
+              else
+                hash[k] ||= {}
+              end
+            walk_tree(v, cache)
+          end
+        else
+          super(associations, hash)
+        end
+      end
+    end
+
+  end
+end

data/lib/polyamorous/activerecord_6.1_ruby_2/reflection.rb

@@ -0,0 +1 @@
+require 'polyamorous/activerecord_6.0_ruby_2/reflection'

data/lib/{polyamorous.rb → polyamorous/polyamorous.rb}

@@ -12,12 +12,12 @@ if defined?(::ActiveRecord)
   require 'polyamorous/swapping_reflection_class'
 
   ar_version = ::ActiveRecord::VERSION::STRING[0,3]
-  ar_version = ::ActiveRecord::VERSION::STRING[0,5] if ar_version >= '5.2'
-
-  %w(join_association join_dependency).each do |file|
+  %w(join_association join_dependency reflection).each do |file|
     require "polyamorous/activerecord_#{ar_version}_ruby_2/#{file}"
   end
 
+  ActiveRecord::Reflection::AbstractReflection.send(:prepend, Polyamorous::ReflectionExtensions)
+
   Polyamorous::JoinDependency.send(:prepend, Polyamorous::JoinDependencyExtensions)
   Polyamorous::JoinDependency.singleton_class.send(:prepend, Polyamorous::JoinDependencyExtensions::ClassMethods)
   Polyamorous::JoinAssociation.send(:prepend, Polyamorous::JoinAssociationExtensions)

data/lib/ransack.rb

@@ -1,6 +1,7 @@
 require 'active_support/core_ext'
 require 'ransack/configuration'
 require 'ransack/adapters'
+require 'polyamorous/polyamorous.rb'
 
 Ransack::Adapters.object_mapper.require_constants
 
@@ -20,12 +21,11 @@ end
 
 require 'ransack/search'
 require 'ransack/ransacker'
-require 'ransack/helpers'
-require 'action_controller'
 require 'ransack/translate'
 
 Ransack::Adapters.object_mapper.require_adapter
 
 ActiveSupport.on_load(:action_controller) do
+  require 'ransack/helpers'
   ActionController::Base.helper Ransack::Helpers::FormHelper
 end

data/lib/ransack/adapters/active_record/base.rb

@@ -14,6 +14,7 @@ module Ransack
         end
 
         def ransack(params = {}, options = {})
+          ActiveSupport::Deprecation.warn("#search is deprecated and will be removed in 2.3, please use #ransack instead") if __callee__ == :search
           Search.new(self, params, options)
         end
 

data/lib/ransack/adapters/active_record/context.rb

@@ -1,18 +1,11 @@
 require 'ransack/context'
-require 'polyamorous'
+require 'polyamorous/polyamorous'
 
 module Ransack
   module Adapters
     module ActiveRecord
       class Context < ::Ransack::Context
 
-        def initialize(object, options = {})
-          super
-          if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_2
-            @arel_visitor = @engine.connection.visitor
-          end
-        end
-
         def relation_for(object)
           object.all
         end
@@ -104,20 +97,21 @@ module Ransack
         # JoinDependency to track table aliases.
         #
         def join_sources
-          base, joins =
-          if ::ActiveRecord::VERSION::STRING > Constants::RAILS_5_2_0
+          base, joins = begin
             alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, @object.table.name, [])
-            [
-              Arel::SelectManager.new(@object.table),
+            constraints   = if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_1_ALPHA)
+              @join_dependency.join_constraints(@object.joins_values, alias_tracker, @object.references_values)
+            elsif ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_0)
+              @join_dependency.join_constraints(@object.joins_values, alias_tracker)
+            else
               @join_dependency.join_constraints(@object.joins_values, @join_type, alias_tracker)
-            ]
-          else
+            end
+
             [
               Arel::SelectManager.new(@object.table),
-              @join_dependency.join_constraints(@object.joins_values, @join_type)
+              constraints
             ]
           end
-          joins = joins.collect(&:joins).flatten if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_2
           joins.each do |aliased_join|
             base.from(aliased_join)
           end
@@ -163,7 +157,7 @@ module Ransack
         def build_correlated_subquery(association)
           join_constraints = extract_joins(association)
           join_root = join_constraints.shift
-          correlated_key = join_root.right.expr.left
+          correlated_key = extract_correlated_key(join_root)
           subquery = Arel::SelectManager.new(association.base_klass)
           subquery.from(join_root.left)
           subquery.project(correlated_key)
@@ -179,6 +173,35 @@ module Ransack
 
         private
 
+        def extract_correlated_key(join_root)
+          case join_root
+          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
+          when Arel::Nodes::Equality
+            pk = primary_key
+            if join_root.left == pk
+              join_root.right
+            elsif join_root.right == pk
+              join_root.left
+            else
+              nil
+            end
+          when Arel::Nodes::And
+            extract_correlated_key(join_root.left) || extract_correlated_key(join_root.right)
+          else
+            # eg parent was Arel::Nodes::And and the evaluated side was one of
+            # Arel::Nodes::Grouping or MultiTenant::TenantEnforcementClause
+            nil
+          end
+        end
+
         def get_parent_and_attribute_name(str, parent = @base)
           attr_name = nil
 
@@ -248,24 +271,15 @@ module Ransack
 
           join_list = join_nodes + convert_join_strings_to_ast(relation.table, string_joins)
 
-          if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_2_0
-            join_dependency = Polyamorous::JoinDependency.new(relation.klass, association_joins, join_list)
-            join_nodes.each do |join|
-              join_dependency.send(:alias_tracker).aliases[join.left.name.downcase] = 1
-            end
-          elsif ::ActiveRecord::VERSION::STRING == Constants::RAILS_5_2_0
-            alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, relation.table.name, join_list)
-            join_dependency = Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins, alias_tracker)
-            join_nodes.each do |join|
-              join_dependency.send(:alias_tracker).aliases[join.left.name.downcase] = 1
-            end
+          alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, relation.table.name, join_list)
+          join_dependency = if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_0)
+            Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins, Arel::Nodes::OuterJoin)
           else
-            alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, relation.table.name, join_list)
-            join_dependency = Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins)
-            join_dependency.instance_variable_set(:@alias_tracker, alias_tracker)
-            join_nodes.each do |join|
-              join_dependency.send(:alias_tracker).aliases[join.left.name.downcase] = 1
-            end
+            Polyamorous::JoinDependency.new(relation.klass, relation.table, association_joins)
+          end
+          join_dependency.instance_variable_set(:@alias_tracker, alias_tracker)
+          join_nodes.each do |join|
+            join_dependency.send(:alias_tracker).aliases[join.left.name.downcase] = 1
           end
           join_dependency
         end
@@ -289,32 +303,23 @@ module Ransack
         end
 
         def build_association(name, parent = @base, klass = nil)
-          if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_2_0
-            jd = Polyamorous::JoinDependency.new(
-              parent.base_klass,
-              Polyamorous::Join.new(name, @join_type, klass),
-              []
-            )
-            found_association = jd.join_root.children.last
-          elsif ::ActiveRecord::VERSION::STRING == Constants::RAILS_5_2_0
-            alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, parent.table.name, [])
+          if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_0)
             jd = Polyamorous::JoinDependency.new(
               parent.base_klass,
-              parent.base_klass.arel_table,
+              parent.table,
               Polyamorous::Join.new(name, @join_type, klass),
-              alias_tracker
+              @join_type
             )
             found_association = jd.instance_variable_get(:@join_root).children.last
           else
             jd = Polyamorous::JoinDependency.new(
               parent.base_klass,
-              parent.base_klass.arel_table,
-              Polyamorous::Join.new(name, @join_type, klass),
+              parent.table,
+              Polyamorous::Join.new(name, @join_type, klass)
             )
             found_association = jd.instance_variable_get(:@join_root).children.last
           end
 
-
           @associations_pot[found_association] = parent
 
           # TODO maybe we dont need to push associations here, we could loop
@@ -322,40 +327,27 @@ module Ransack
           @join_dependency.instance_variable_get(:@join_root).children.push found_association
 
           # Builds the arel nodes properly for this association
-          if ::ActiveRecord::VERSION::STRING > Constants::RAILS_5_2_0
-            @join_dependency.send(:construct_tables!, jd.instance_variable_get(:@join_root))
+          if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_1_ALPHA)
+            @tables_pot[found_association] = @join_dependency.construct_tables_for_association!(jd.instance_variable_get(:@join_root), found_association)
           else
-            @join_dependency.send(
-              :construct_tables!, jd.instance_variable_get(:@join_root), found_association
-            )
+            @join_dependency.send(:construct_tables!, jd.instance_variable_get(:@join_root))
           end
 
           # Leverage the stashed association functionality in AR
           @object = @object.joins(jd)
-
           found_association
         end
 
         def extract_joins(association)
           parent = @join_dependency.instance_variable_get(:@join_root)
           reflection = association.reflection
-          join_constraints = if ::ActiveRecord::VERSION::STRING < Constants::RAILS_5_1
-                               association.join_constraints(
-                                 parent.table,
-                                 parent.base_klass,
-                                 association,
-                                 Arel::Nodes::OuterJoin,
-                                 association.tables,
-                                 reflection.scope_chain,
-                                 reflection.chain
-                               )
-                             elsif ::ActiveRecord::VERSION::STRING <= Constants::RAILS_5_2_0
-                               association.join_constraints(
+          join_constraints = if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_1_ALPHA)
+                               association.join_constraints_with_tables(
                                  parent.table,
                                  parent.base_klass,
                                  Arel::Nodes::OuterJoin,
-                                 association.tables,
-                                 reflection.chain
+                                 @join_dependency.instance_variable_get(:@alias_tracker),
+                                 @tables_pot[association]
                                )
                              else
                                association.join_constraints(