ransack 1.7.0 → 2.4.1

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

@@ -1,42 +1,59 @@
 require 'ransack/context'
-require 'ransack/adapters/active_record/compat'
-require 'polyamorous'
+require 'polyamorous/polyamorous'
 
 module Ransack
   module Adapters
     module ActiveRecord
       class Context < ::Ransack::Context
 
-        # Because the AR::Associations namespace is insane
-        JoinDependency = ::ActiveRecord::Associations::JoinDependency
-        JoinPart = JoinDependency::JoinPart
-
-        def initialize(object, options = {})
-          super
-          @arel_visitor = @engine.connection.visitor
-        end
-
         def relation_for(object)
           object.all
         end
 
         def type_for(attr)
           return nil unless attr && attr.valid?
-          name        = attr.arel_attribute.name.to_s
-          table       = attr.arel_attribute.relation.table_name
-          connection  = attr.klass.connection
-          unless connection.table_exists?(table)
-            raise "No table named #{table} exists"
+          name         = attr.arel_attribute.name.to_s
+          table        = attr.arel_attribute.relation.table_name
+          schema_cache = self.klass.connection.schema_cache
+          unless schema_cache.send(:data_source_exists?, table)
+            raise "No table named #{table} exists."
           end
-          connection.schema_cache.columns_hash(table)[name].type
+          attr.klass.columns.find { |column| column.name == name }.type
         end
 
         def evaluate(search, opts = {})
           viz = Visitor.new
           relation = @object.where(viz.accept(search.base))
+
           if search.sorts.any?
-            relation = relation.except(:order).reorder(viz.accept(search.sorts))
+            relation = relation.except(:order)
+            # Rather than applying all of the search's sorts in one fell swoop,
+            # as the original implementation does, we apply one at a time.
+            #
+            # If the sort (returned by the Visitor above) is a symbol, we know
+            # that it represents a scope on the model and we can apply that
+            # scope.
+            #
+            # Otherwise, we fall back to the applying the sort with the "order"
+            # method as the original implementation did. Actually the original
+            # implementation used "reorder," which was overkill since we already
+            # have a clean slate after "relation.except(:order)" above.
+            viz.accept(search.sorts).each do |scope_or_sort|
+              if scope_or_sort.is_a?(Symbol)
+                relation = relation.send(scope_or_sort)
+              else
+                case Ransack.options[:postgres_fields_sort_option]
+                when :nulls_first
+                  scope_or_sort = scope_or_sort.direction == :asc ? "#{scope_or_sort.to_sql} NULLS FIRST" : "#{scope_or_sort.to_sql} NULLS LAST"
+                when :nulls_last
+                  scope_or_sort = scope_or_sort.direction == :asc ? "#{scope_or_sort.to_sql} NULLS LAST" : "#{scope_or_sort.to_sql} NULLS FIRST"
+                end
+
+                relation = relation.order(scope_or_sort)
+              end
+            end
           end
+
           opts[:distinct] ? relation.distinct : relation
         end
 
@@ -44,7 +61,7 @@ module Ransack
           exists = false
           if ransackable_attribute?(str, klass)
             exists = true
-          elsif (segments = str.split(/_/)).size > 1
+          elsif (segments = str.split(Constants::UNDERSCORE)).size > 1
             remainder = []
             found_assoc = nil
             while !found_assoc && remainder.unshift(segments.pop) &&
@@ -79,61 +96,119 @@ module Ransack
           end
         end
 
-        if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_4_1
+        # All dependent Arel::Join nodes used in the search query.
+        #
+        # This could otherwise be done as `@object.arel.join_sources`, except
+        # that ActiveRecord's build_joins sets up its own JoinDependency.
+        # This extracts what we need to access the joins using our existing
+        # JoinDependency to track table aliases.
+        #
+        def join_sources
+          base, joins = begin
+            alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(self.klass.connection, @object.table.name, [])
+            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)
+            end
 
-          def join_associations
-            raise NotImplementedError,
-            "ActiveRecord 4.1 and later does not use join_associations. Use join_sources."
+            [
+              Arel::SelectManager.new(@object.table),
+              constraints
+            ]
           end
-
-          # All dependent Arel::Join nodes used in the search query
-          #
-          # This could otherwise be done as `@object.arel.join_sources`, except
-          # that ActiveRecord's build_joins sets up its own JoinDependency.
-          # This extracts what we need to access the joins using our existing
-          # JoinDependency to track table aliases.
-          #
-          def join_sources
-            base =
-              if ::ActiveRecord::VERSION::MAJOR >= 5
-                Arel::SelectManager.new(@object.table)
-              else
-                Arel::SelectManager.new(@object.engine, @object.table)
-              end
-            joins = @join_dependency.join_constraints(@object.joins_values)
-            joins.each do |aliased_join|
-              base.from(aliased_join)
-            end
-            base.join_sources
+          joins.each do |aliased_join|
+            base.from(aliased_join)
           end
+          base.join_sources
+        end
 
-        else
+        def alias_tracker
+          @join_dependency.send(:alias_tracker)
+        end
 
-          # All dependent JoinAssociation items used in the search query
-          #
-          # Deprecated: this goes away in ActiveRecord 4.1. Use join_sources.
-          #
-          def join_associations
-            @join_dependency.join_associations
-          end
+        def lock_association(association)
+          @lock_associations << association
+        end
 
-          def join_sources
-            base = Arel::SelectManager.new(@object.engine, @object.table)
-            joins = @object.joins_values
-            joins.each do |assoc|
-              assoc.join_to(base)
-            end
-            base.join_sources
-          end
+        def remove_association(association)
+          return if @lock_associations.include?(association)
+          @join_dependency.instance_variable_get(:@join_root).children.delete_if { |stashed|
+            stashed.eql?(association)
+          }
+          @object.joins_values.delete_if { |jd|
+            jd.instance_variable_get(:@join_root).children.map(&:object_id) == [association.object_id]
+          }
+        end
 
+        # Build an Arel subquery that selects keys for the top query,
+        # drawn from the first join association's foreign_key.
+        #
+        # Example: for an Article that has_and_belongs_to_many Tags
+        #
+        #   context = Article.search.context
+        #   attribute = Attribute.new(context, "tags_name").tap do |a|
+        #     context.bind(a, a.name)
+        #   end
+        #   context.build_correlated_subquery(attribute.parent).to_sql
+        #
+        #   # SELECT "articles_tags"."article_id" FROM "articles_tags"
+        #   # INNER JOIN "tags" ON "tags"."id" = "articles_tags"."tag_id"
+        #   # WHERE "articles_tags"."article_id" = "articles"."id"
+        #
+        # The WHERE condition on this query makes it invalid by itself,
+        # because it is correlated to the primary key on the outer query.
+        #
+        def build_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)
+          subquery.from(join_root.left)
+          subquery.project(correlated_key)
+          join_constraints.each do |j|
+            subquery.join_sources << Arel::Nodes::InnerJoin.new(j.left, j.right)
+          end
+          subquery.where(correlated_key.eq(primary_key))
         end
 
-        def alias_tracker
-          @join_dependency.alias_tracker
+        def primary_key
+          @object.table[@object.primary_key]
         end
 
         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
 
@@ -168,7 +243,7 @@ module Ransack
         end
 
         def join_dependency(relation)
-          if relation.respond_to?(:join_dependency) # Squeel will enable this
+          if relation.respond_to?(:join_dependency) # Polyamorous enables this
             relation.join_dependency
           else
             build_joins(relation)
@@ -178,7 +253,9 @@ module Ransack
         # Checkout active_record/relation/query_methods.rb +build_joins+ for
         # reference. Lots of duplicated code maybe we can avoid it
         def build_joins(relation)
-          buckets = relation.joins_values.group_by do |join|
+          buckets = relation.joins_values + relation.left_outer_joins_values
+
+          buckets = buckets.group_by do |join|
             case join
             when String
               :string_join
@@ -196,102 +273,99 @@ module Ransack
           association_joins         = buckets[:association_join]
           stashed_association_joins = buckets[:stashed_join]
           join_nodes                = buckets[:join_node].uniq
-          string_joins              = buckets[:string_join].map(&:strip).uniq
-
-          join_list =
-            if ::ActiveRecord::VERSION::MAJOR >= 5
-              join_nodes +
-              convert_join_strings_to_ast(relation.table, string_joins)
-            else
-              relation.send :custom_join_ast,
-                relation.table.from(relation.table), string_joins
-            end
+          string_joins              = buckets[:string_join].map(&:strip)
+          string_joins.uniq!
 
-          join_dependency = JoinDependency.new(
-            relation.klass, association_joins, join_list
-          )
+          join_list = join_nodes + convert_join_strings_to_ast(relation.table, string_joins)
 
-          join_nodes.each do |join|
-            join_dependency.alias_tracker.aliases[join.left.name.downcase] = 1
-          end
-
-          if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_4_1
-            join_dependency
+          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
-            join_dependency.graft(*stashed_association_joins)
+            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
 
         def convert_join_strings_to_ast(table, joins)
+          joins.map! { |join| table.create_string_join(Arel.sql(join)) unless join.blank? }
+          joins.compact!
           joins
-          .flatten
-          .reject(&:blank?)
-          .map { |join| table.create_string_join(Arel.sql(join)) }
         end
 
-        if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_4_1
-
-          def build_or_find_association(name, parent = @base, klass = nil)
-            found_association = @join_dependency.join_root.children
-            .detect do |assoc|
-              assoc.reflection.name == name &&
-              (@associations_pot.nil? || @associations_pot[assoc] == parent) &&
-              (!klass || assoc.reflection.klass == klass)
-            end
-
-            unless found_association
-              jd = JoinDependency.new(
-                parent.base_klass,
-                Polyamorous::Join.new(name, @join_type, klass),
-                []
-              )
-              found_association = jd.join_root.children.last
-              associations found_association, parent
-
-              # TODO maybe we dont need to push associations here, we could loop
-              # through the @associations_pot instead
-              @join_dependency.join_root.children.push found_association
-
-              # Builds the arel nodes properly for this association
-              @join_dependency.send(
-                :construct_tables!, jd.join_root, found_association
-                )
+        def build_or_find_association(name, parent = @base, klass = nil)
+          find_association(name, parent, klass) or build_association(name, parent, klass)
+        end
 
-              # Leverage the stashed association functionality in AR
-              @object = @object.joins(jd)
-            end
-            found_association
+        def find_association(name, parent = @base, klass = nil)
+          @join_dependency.instance_variable_get(:@join_root).children.detect do |assoc|
+            assoc.reflection.name == name && assoc.table &&
+            (@associations_pot.empty? || @associations_pot[assoc] == parent || !@associations_pot.key?(assoc)) &&
+            (!klass || assoc.reflection.klass == klass)
           end
+        end
 
-          def associations(assoc, parent)
-            @associations_pot ||= {}
-            @associations_pot[assoc] = parent
+        def build_association(name, parent = @base, klass = nil)
+          if ::Gem::Version.new(::ActiveRecord::VERSION::STRING) >= ::Gem::Version.new(Constants::RAILS_6_0)
+            jd = Polyamorous::JoinDependency.new(
+              parent.base_klass,
+              parent.table,
+              Polyamorous::Join.new(name, @join_type, klass),
+              @join_type
+            )
+            found_association = jd.instance_variable_get(:@join_root).children.last
+          else
+            jd = Polyamorous::JoinDependency.new(
+              parent.base_klass,
+              parent.table,
+              Polyamorous::Join.new(name, @join_type, klass)
+            )
+            found_association = jd.instance_variable_get(:@join_root).children.last
           end
 
-        else
+          @associations_pot[found_association] = parent
 
-          def build_or_find_association(name, parent = @base, klass = nil)
-            found_association = @join_dependency.join_associations
-            .detect do |assoc|
-              assoc.reflection.name == name &&
-              assoc.parent == parent &&
-              (!klass || assoc.reflection.klass == klass)
-            end
-            unless found_association
-              @join_dependency.send(
-                :build,
-                Polyamorous::Join.new(name, @join_type, klass),
-                parent
-               )
-              found_association = @join_dependency.join_associations.last
-              # Leverage the stashed association functionality in AR
-              @object = @object.joins(found_association)
-            end
-            found_association
+          # TODO maybe we dont need to push associations here, we could loop
+          # through the @associations_pot instead
+          @join_dependency.instance_variable_get(:@join_root).children.push found_association
+
+          # Builds the arel nodes properly for this association
+          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))
           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 ::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,
+                                 @join_dependency.instance_variable_get(:@alias_tracker),
+                                 @tables_pot[association]
+                               )
+                             else
+                               association.join_constraints(
+                                 parent.table,
+                                 parent.base_klass,
+                                 Arel::Nodes::OuterJoin,
+                                 @join_dependency.instance_variable_get(:@alias_tracker)
+                               )
+                             end
+          join_constraints.to_a.flatten
+        end
       end
     end
   end

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

@@ -4,97 +4,109 @@ module Ransack
 
     DERIVED_PREDICATES = [
       [CONT, {
-        :arel_predicate => 'matches'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
         }
       ],
       ['not_cont'.freeze, {
-        :arel_predicate => 'does_not_match'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}%" }
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}%" }
+        }
+      ],
+      ['i_cont'.freeze, {
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v.downcase)}%" },
+        case_insensitive: true
+        }
+      ],
+      ['not_i_cont'.freeze, {
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v.downcase)}%" },
+        case_insensitive: true
         }
       ],
       ['start'.freeze, {
-        :arel_predicate => 'matches'.freeze,
-        :formatter => proc { |v| "#{escape_wildcards(v)}%" }
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "#{escape_wildcards(v)}%" }
         }
       ],
       ['not_start'.freeze, {
-        :arel_predicate => 'does_not_match'.freeze,
-        :formatter => proc { |v| "#{escape_wildcards(v)}%" }
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "#{escape_wildcards(v)}%" }
         }
       ],
       ['end'.freeze, {
-        :arel_predicate => 'matches'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}" }
+        arel_predicate: 'matches'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}" }
         }
       ],
       ['not_end'.freeze, {
-        :arel_predicate => 'does_not_match'.freeze,
-        :formatter => proc { |v| "%#{escape_wildcards(v)}" }
+        arel_predicate: 'does_not_match'.freeze,
+        formatter: proc { |v| "%#{escape_wildcards(v)}" }
         }
       ],
       ['true'.freeze, {
-        :arel_predicate => proc { |v| v ? EQ : NOT_EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| true }
+        arel_predicate: proc { |v| v ? EQ : NOT_EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| true }
         }
       ],
       ['not_true'.freeze, {
-        :arel_predicate => proc { |v| v ? NOT_EQ : EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| true }
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| true }
         }
       ],
       ['false'.freeze, {
-        :arel_predicate => proc { |v| v ? EQ : NOT_EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| false }
+        arel_predicate: proc { |v| v ? EQ : NOT_EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| false }
         }
       ],
       ['not_false'.freeze, {
-        :arel_predicate => proc { |v| v ? NOT_EQ : EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| false }
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| false }
         }
       ],
       ['present'.freeze, {
-        :arel_predicate => proc { |v| v ? NOT_EQ_ALL : EQ_ANY },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| [nil, EMPTY] }
+        arel_predicate: proc { |v| v ? NOT_EQ_ALL : EQ_ANY },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| [nil, ''.freeze].freeze }
         }
       ],
       ['blank'.freeze, {
-        :arel_predicate => proc { |v| v ? EQ_ANY : NOT_EQ_ALL },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| [nil, EMPTY] }
+        arel_predicate: proc { |v| v ? EQ_ANY : NOT_EQ_ALL },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| [nil, ''.freeze].freeze }
         }
       ],
       ['null'.freeze, {
-        :arel_predicate => proc { |v| v ? EQ : NOT_EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v)},
-        :formatter => proc { |v| nil }
+        arel_predicate: proc { |v| v ? EQ : NOT_EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v)},
+        formatter: proc { |v| nil }
         }
       ],
       ['not_null'.freeze, {
-        :arel_predicate => proc { |v| v ? NOT_EQ : EQ },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| nil } }
+        arel_predicate: proc { |v| v ? NOT_EQ : EQ },
+        compounds: false,
+        type: :boolean,
+        validator: proc { |v| BOOLEAN_VALUES.include?(v) },
+        formatter: proc { |v| nil } }
       ]
     ].freeze
 
@@ -102,9 +114,12 @@ module Ransack
     # replace % \ to \% \\
     def escape_wildcards(unescaped)
       case ActiveRecord::Base.connection.adapter_name
-      when "Mysql2".freeze, "PostgreSQL".freeze
-        # Necessary for PostgreSQL and MySQL
-        unescaped.to_s.gsub(/([\\|\%|.])/, '\\\\\\1')
+      when "Mysql2".freeze
+        # Necessary for MySQL
+        unescaped.to_s.gsub(/([\\%_])/, '\\\\\\1')
+      when "PostgreSQL".freeze
+        # Necessary for PostgreSQL
+        unescaped.to_s.gsub(/([\\%_.])/, '\\\\\\1')
       else
         unescaped
       end

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

@@ -27,23 +27,19 @@ module Ransack
       @join_dependency = join_dependency(@object)
       @join_type = options[:join_type] || Polyamorous::OuterJoin
       @search_key = options[:search_key] || Ransack.options[:search_key]
+      @associations_pot = {}
+      @tables_pot = {}
+      @lock_associations = []
 
-      if ::ActiveRecord::VERSION::STRING >= Constants::RAILS_4_1
-        @base = @join_dependency.join_root
-        @engine = @base.base_klass.arel_engine
-      else
-        @base = @join_dependency.join_base
-        @engine = @base.arel_engine
-      end
+      @base = @join_dependency.instance_variable_get(:@join_root)
+    end
 
-      @default_table = Arel::Table.new(
-        @base.table_name, as: @base.aliased_table_name, type_caster: self
-        )
-      @bind_pairs = Hash.new do |hash, key|
+    def bind_pair_for(key)
+      @bind_pairs ||= {}
+
+      @bind_pairs[key] ||= begin
         parent, attr_name = get_parent_and_attribute_name(key.to_s)
-        if parent && attr_name
-          hash[key] = [parent, attr_name]
-        end
+        [parent, attr_name] if parent && attr_name
       end
     end
 
@@ -52,10 +48,6 @@ module Ransack
         obj
       elsif obj.respond_to? :klass
         obj.klass
-      elsif obj.respond_to? :active_record  # Rails 3
-        obj.active_record
-      elsif obj.respond_to? :base_klass     # Rails 4
-        obj.base_klass
       else
         raise ArgumentError, "Don't know how to klassify #{obj.inspect}"
       end