ransack 1.7.0 → 2.1.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.0_ruby_2/join_association.rb

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

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

@@ -0,0 +1,2 @@
+# active_record_5.0_ruby_2/join_dependency.rb
+require 'polyamorous/activerecord_5.1_ruby_2/join_dependency'

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

@@ -0,0 +1,32 @@
+# active_record_5.1_ruby_2/join_association.rb
+
+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 build_constraint(klass, table, key, foreign_table, foreign_key)
+      if reflection.polymorphic?
+        super(klass, table, key, foreign_table, foreign_key)
+          .and(foreign_table[reflection.foreign_type].eq(reflection.klass.name))
+      else
+        super(klass, table, key, foreign_table, foreign_key)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# active_record_5.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
+
+    # Replaces ActiveRecord::Associations::JoinDependency#join_constraints
+    #
+    # This internal method was changed in Rails 5.0 by commit
+    # https://github.com/rails/rails/commit/e038975 which added
+    # left_outer_joins (see #make_polyamorous_left_outer_joins below) and added
+    # passing an additional argument, `join_type`, to #join_constraints.
+    #
+    def join_constraints(outer_joins, join_type)
+      joins = join_root.children.flat_map { |child|
+        if join_type == Arel::Nodes::OuterJoin
+          make_polyamorous_left_outer_joins join_root, child
+        else
+          make_polyamorous_inner_joins join_root, child
+        end
+      }
+
+      joins.concat outer_joins.flat_map { |oj|
+        if join_root.match? oj.join_root
+          walk(join_root, oj.join_root)
+        else
+          oj.join_root.children.flat_map { |child|
+            make_outer_joins(oj.join_root, child)
+          }
+        end
+      }
+    end
+
+    # Replaces ActiveRecord::Associations::JoinDependency#make_left_outer_joins,
+    # a new method that was added in Rails 5.0 with the following commit:
+    # https://github.com/rails/rails/commit/e038975
+    #
+    def make_polyamorous_left_outer_joins(parent, child)
+      tables    = child.tables
+      join_type = Arel::Nodes::OuterJoin
+      info      = make_constraints parent, child, tables, join_type
+
+      [info] + child.children.flat_map { |c|
+        make_polyamorous_left_outer_joins(child, c)
+      }
+    end
+
+    # Replaces ActiveRecord::Associations::JoinDependency#make_inner_joins
+    #
+    def make_polyamorous_inner_joins(parent, child)
+      tables    = child.tables
+      join_type = child.join_type || Arel::Nodes::InnerJoin
+      info      = make_constraints parent, child, tables, join_type
+
+      [info] + child.children.flat_map { |c|
+        make_polyamorous_inner_joins(child, c)
+      }
+    end
+
+    private :make_polyamorous_inner_joins, :make_polyamorous_left_outer_joins
+
+    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.0_ruby_2/join_association.rb

@@ -0,0 +1,32 @@
+# active_record_5.2_ruby_2/join_association.rb
+
+module Polyamorous
+  module JoinAssociationExtensions
+    include SwappingReflectionClass
+    def self.prepended(base)
+      base.class_eval { attr_reader :join_type }
+    end
+
+    def initialize(reflection, children, alias_tracker, 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, alias_tracker)
+          self.reflection.options[:polymorphic] = true
+        end
+      else
+        super(reflection, children, alias_tracker)
+      end
+    end
+
+    def build_constraint(klass, table, key, foreign_table, foreign_key)
+      if reflection.polymorphic?
+        super(klass, table, key, foreign_table, foreign_key)
+        .and(foreign_table[reflection.foreign_type].eq(reflection.klass.name))
+      else
+        super(klass, table, key, foreign_table, foreign_key)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# active_record_5.2_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), alias_tracker, 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), alias_tracker)
+        end
+      end
+    end
+
+    # Replaces ActiveRecord::Associations::JoinDependency#join_constraints
+    #
+    # This internal method was changed in Rails 5.0 by commit
+    # https://github.com/rails/rails/commit/e038975 which added
+    # left_outer_joins (see #make_polyamorous_left_outer_joins below) and added
+    # passing an additional argument, `join_type`, to #join_constraints.
+    #
+    def join_constraints(outer_joins, join_type)
+      @alias_tracker = alias_tracker
+      joins = join_root.children.flat_map { |child|
+        if join_type == Arel::Nodes::OuterJoin
+          make_polyamorous_left_outer_joins join_root, child
+        else
+          make_polyamorous_inner_joins join_root, child
+        end
+      }
+
+      joins.concat outer_joins.flat_map { |oj|
+        if join_root.match? oj.join_root
+          walk(join_root, oj.join_root)
+        else
+          oj.join_root.children.flat_map { |child|
+            make_outer_joins(oj.join_root, child)
+          }
+        end
+      }
+    end
+
+    # Replaces ActiveRecord::Associations::JoinDependency#make_left_outer_joins,
+    # a new method that was added in Rails 5.0 with the following commit:
+    # https://github.com/rails/rails/commit/e038975
+    #
+    def make_polyamorous_left_outer_joins(parent, child)
+      tables    = child.tables
+      join_type = Arel::Nodes::OuterJoin
+      info      = make_constraints parent, child, tables, join_type
+
+      info + child.children.flat_map { |c|
+        make_polyamorous_left_outer_joins(child, c)
+      }
+    end
+
+    # Replaces ActiveRecord::Associations::JoinDependency#make_inner_joins
+    #
+    def make_polyamorous_inner_joins(parent, child)
+      tables    = child.tables
+      join_type = child.join_type || Arel::Nodes::InnerJoin
+      info      = make_constraints parent, child, tables, join_type
+
+      info + child.children.flat_map { |c|
+        make_polyamorous_inner_joins(child, c)
+      }
+    end
+
+    private :make_polyamorous_inner_joins, :make_polyamorous_left_outer_joins
+
+    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.1_ruby_2/join_association.rb

@@ -0,0 +1,31 @@
+# active_record_5.2.1_ruby_2/join_association.rb
+
+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 build_constraint(klass, table, key, foreign_table, foreign_key)
+      if reflection.polymorphic?
+        super(klass, table, key, foreign_table, foreign_key)
+        .and(foreign_table[reflection.foreign_type].eq(reflection.klass.name))
+      else
+        super(klass, table, key, foreign_table, foreign_key)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# active_record_5.2.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
+
+    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/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/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/polyamorous.rb

@@ -0,0 +1,25 @@
+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]
+  ar_version = ::ActiveRecord::VERSION::STRING[0,5] if ar_version >= "5.2"
+  ar_version = "5.2.1" if ::ActiveRecord::VERSION::STRING >= "5.2.1"
+
+  %w(join_association join_dependency).each do |file|
+    require "polyamorous/activerecord_#{ar_version}_ruby_2/#{file}"
+  end
+
+  Polyamorous::JoinDependency.send(:prepend, Polyamorous::JoinDependencyExtensions)
+  Polyamorous::JoinDependency.singleton_class.send(:prepend, Polyamorous::JoinDependencyExtensions::ClassMethods)
+  Polyamorous::JoinAssociation.send(:prepend, Polyamorous::JoinAssociationExtensions)
+end

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

@@ -7,11 +7,14 @@ 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
 
@@ -20,12 +23,22 @@ module Ransack
             .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 +46,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 +65,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