ransack 1.7.0 → 2.4.1

data/Rakefile

@@ -5,39 +5,20 @@ Bundler::GemHelper.install_tasks
 
 RSpec::Core::RakeTask.new(:spec) do |rspec|
   ENV['SPEC'] = 'spec/ransack/**/*_spec.rb'
-  rspec.rspec_opts = ['--backtrace']
-end
-
-RSpec::Core::RakeTask.new(:mongoid) do |rspec|
-  ENV['SPEC'] = 'spec/mongoid/**/*_spec.rb'
-  rspec.rspec_opts = ['--backtrace']
+  # With Rails 3, using `--backtrace` raises 'invalid option' when testing.
+  # With Rails 4 and 5 it can be uncommented to see the backtrace:
+  #
+  # rspec.rspec_opts = ['--backtrace']
 end
 
 task :default do
-  if ENV['DB'] =~ /mongodb/
-    Rake::Task["mongoid"].invoke
-  else
-    Rake::Task["spec"].invoke
-  end
+  Rake::Task["spec"].invoke
 end
 
 desc "Open an irb session with Ransack and the sample data used in specs"
 task :console do
-  require 'irb'
-  require 'irb/completion'
-  require 'console'
-  ARGV.clear
-  IRB.start
-end
-
-desc "Open an irb session with Ransack, Mongoid and the sample data used in specs"
-task :mongoid_console do
-  require 'irb'
-  require 'irb/completion'
   require 'pry'
-  require 'mongoid'
-  require File.expand_path('../lib/ransack.rb', __FILE__)
-  require File.expand_path('../spec/mongoid/support/schema.rb', __FILE__)
+  require File.expand_path('../spec/console.rb', __FILE__)
   ARGV.clear
   Pry.start
 end

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

@@ -0,0 +1,24 @@
+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
+
+    def ==(other)
+      base_klass == other.base_klass
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+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, join_type, 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
+        else
+          make_join_constraints(oj.join_root, 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_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/join.rb

@@ -0,0 +1,70 @@
+module Polyamorous
+  class Join
+    include TreeNode
+
+    attr_accessor :name
+    attr_reader :type, :klass
+
+    def initialize(name, type = InnerJoin, klass = nil)
+      @name = name
+      @type = convert_to_arel_join_type(type)
+      @klass = convert_to_class(klass) if klass
+    end
+
+    def klass=(klass)
+      @klass = convert_to_class(klass) if klass
+    end
+
+    def type=(type)
+      @type = convert_to_arel_join_type(type) if type
+    end
+
+    def hash
+      [@name, @type, @klass].hash
+    end
+
+    def eql?(other)
+      self.class == other.class &&
+      self.name  == other.name &&
+      self.type  == other.type &&
+      self.klass == other.klass
+    end
+
+    alias :== :eql?
+
+    def add_to_tree(hash)
+      hash[self] ||= {}
+    end
+
+    private
+
+    def convert_to_arel_join_type(type)
+      case type
+      when 'inner', :inner
+        InnerJoin
+      when 'outer', :outer
+        OuterJoin
+      when Class
+        if [InnerJoin, OuterJoin].include? type
+          type
+        else
+          raise ArgumentError, "#{type} cannot be converted to an ARel join type"
+        end
+      else
+        raise ArgumentError, "#{type} cannot be converted to an ARel join type"
+      end
+    end
+
+    def convert_to_class(value)
+      case value
+      when String, Symbol
+        Kernel.const_get(value)
+      when Class
+        value
+      else
+        raise ArgumentError, "#{value} cannot be converted to a Class"
+      end
+    end
+
+  end
+end

data/lib/polyamorous/polyamorous.rb

@@ -0,0 +1,24 @@
+if defined?(::ActiveRecord)
+  module Polyamorous
+    InnerJoin = Arel::Nodes::InnerJoin
+    OuterJoin = Arel::Nodes::OuterJoin
+
+    JoinDependency  = ::ActiveRecord::Associations::JoinDependency
+    JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
+  end
+
+  require 'polyamorous/tree_node'
+  require 'polyamorous/join'
+  require 'polyamorous/swapping_reflection_class'
+
+  ar_version = ::ActiveRecord::VERSION::STRING[0,3]
+  %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)
+end

data/lib/polyamorous/swapping_reflection_class.rb

@@ -0,0 +1,11 @@
+module Polyamorous
+  module SwappingReflectionClass
+    def swapping_reflection_klass(reflection, klass)
+      new_reflection = reflection.clone
+      new_reflection.instance_variable_set(:@options, reflection.options.clone)
+      new_reflection.options.delete(:polymorphic)
+      new_reflection.instance_variable_set(:@klass, klass)
+      yield new_reflection
+    end
+  end
+end

data/lib/polyamorous/tree_node.rb

@@ -0,0 +1,7 @@
+module Polyamorous
+  module TreeNode
+    def add_to_tree(hash)
+      raise NotImplementedError
+    end
+  end
+end

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

@@ -7,25 +7,42 @@ module Ransack
           alias :search :ransack unless base.respond_to? :search
           base.class_eval do
             class_attribute :_ransackers
+            class_attribute :_ransack_aliases
             self._ransackers ||= {}
+            self._ransack_aliases ||= {}
           end
         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
 
+        def ransack!(params = {}, options = {})
+          ransack(params, options.merge(ignore_unknown_conditions: false))
+        end
+
         def ransacker(name, opts = {}, &block)
           self._ransackers = _ransackers.merge name.to_s => Ransacker
             .new(self, name, opts, &block)
         end
 
+        def ransack_alias(new_name, old_name)
+          self._ransack_aliases = _ransack_aliases.merge new_name.to_s =>
+            old_name.to_s
+        end
+
         # Ransackable_attributes, by default, returns all column names
         # and any defined ransackers as an array of strings.
         # For overriding with a whitelist array of strings.
         #
         def ransackable_attributes(auth_object = nil)
-          column_names + _ransackers.keys
+          @ransackable_attributes ||= if Ransack::SUPPORTS_ATTRIBUTE_ALIAS
+            column_names + _ransackers.keys + _ransack_aliases.keys +
+            attribute_aliases.keys
+          else
+            column_names + _ransackers.keys + _ransack_aliases.keys
+          end
         end
 
         # Ransackable_associations, by default, returns the names
@@ -33,7 +50,7 @@ module Ransack
         # For overriding with a whitelist array of strings.
         #
         def ransackable_associations(auth_object = nil)
-          reflect_on_all_associations.map { |a| a.name.to_s }
+          @ransackable_associations ||= reflect_on_all_associations.map { |a| a.name.to_s }
         end
 
         # Ransortable_attributes, by default, returns the names
@@ -52,6 +69,14 @@ module Ransack
           []
         end
 
+        # ransack_scope_skip_sanitize_args, by default, returns an empty array.
+        # i.e. use the sanitize_scope_args setting to determin if args should be converted.
+        # For overriding with a list of scopes which should be passed the args as-is.
+        #
+        def ransackable_scopes_skip_sanitize_args
+          []
+        end
+
       end
     end
   end