ransack 1.7.0 → 1.8.0

data/lib/ransack/nodes/grouping.rb

@@ -44,7 +44,7 @@ module Ransack
             self.conditions << condition if condition.valid?
           end
         end
-        self.conditions.uniq!
+        remove_duplicate_conditions!
       end
       alias :c= :conditions=
 
@@ -68,7 +68,7 @@ module Ransack
       def respond_to?(method_id)
         super or begin
           method_name = method_id.to_s
-          writer = method_name.sub!(/\=$/, Constants::EMPTY)
+          writer = method_name.sub!(/\=$/, ''.freeze)
           attribute_method?(method_name) ? true : false
         end
       end
@@ -114,7 +114,7 @@ module Ransack
 
       def method_missing(method_id, *args)
         method_name = method_id.to_s
-        writer = method_name.sub!(/\=$/, Constants::EMPTY)
+        writer = method_name.sub!(/\=$/, ''.freeze)
         if attribute_method?(method_name)
           if writer
             write_attribute(method_name, *args)
@@ -169,7 +169,7 @@ module Ransack
         ]
         .reject { |e| e[1].blank? }
         .map { |v| "#{v[0]}: #{v[1]}" }
-        .join(Constants::COMMA_SPACE)
+        .join(', '.freeze)
         "Grouping <#{data}>"
       end
 
@@ -195,6 +195,17 @@ module Ransack
         Predicate.detect_and_strip_from_string!(string)
         string
       end
+
+      def remove_duplicate_conditions!
+        # If self.conditions.uniq! is called without passing a block, then
+        # conditions differing only by ransacker_args within attributes are
+        # wrongly considered equal and are removed.
+        self.conditions.uniq! do |c|
+          c.attributes.map { |a| [a.name, a.ransacker_args] }.flatten +
+          [c.predicate.name] +
+          c.values.map { |v| v.value }
+        end
+      end
     end
   end
 end

data/lib/ransack/nodes/sort.rb

@@ -3,7 +3,7 @@ module Ransack
     class Sort < Node
       include Bindable
 
-      attr_reader :name, :dir
+      attr_reader :name, :dir, :ransacker_args
       i18n_word :asc, :desc
 
       class << self
@@ -16,7 +16,7 @@ module Ransack
 
       def build(params)
         params.with_indifferent_access.each do |key, value|
-          if key.match(/^(name|dir)$/)
+          if key.match(/^(name|dir|ransacker_args)$/)
             self.send("#{key}=", value)
           end
         end
@@ -32,19 +32,23 @@ module Ransack
 
       def name=(name)
         @name = name
-        context.bind(self, name) unless name.blank?
+        context.bind(self, name)
       end
 
       def dir=(dir)
         dir = dir.downcase if dir
         @dir =
-          if Constants::ASC_DESC.include?(dir)
+          if ['asc'.freeze, 'desc'.freeze].freeze.include?(dir)
             dir
           else
-            Constants::ASC
+            'asc'.freeze
           end
       end
 
+      def ransacker_args=(ransack_args)
+        @ransacker_args = ransack_args
+      end
+
     end
   end
 end

data/lib/ransack/predicate.rb

@@ -10,7 +10,7 @@ module Ransack
       end
 
       def names_by_decreasing_length
-        names.sort { |a,b| b.length <=> a.length }
+        names.sort { |a, b| b.length <=> a.length }
       end
 
       def named(name)
@@ -19,7 +19,7 @@ module Ransack
 
       def detect_and_strip_from_string!(str)
         if p = detect_from_string(str)
-          str.sub! /_#{p}$/, Constants::EMPTY
+          str.sub! /_#{p}$/, ''.freeze
           p
         end
       end
@@ -74,5 +74,9 @@ module Ransack
       vals.any? { |v| validator.call(type ? v.cast(type) : v.value) }
     end
 
+    def negative?
+      @name.include?("not_".freeze)
+    end
+
   end
 end

data/lib/ransack/search.rb

@@ -1,6 +1,6 @@
 require 'ransack/nodes'
 require 'ransack/context'
-Ransack::Adapters.require_search
+Ransack::Adapters.object_mapper.require_search
 require 'ransack/naming'
 
 module Ransack
@@ -15,6 +15,7 @@ module Ransack
              :translate, :to => :base
 
     def initialize(object, params = {}, options = {})
+      params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
       if params.is_a? Hash
         params = params.dup
         params.delete_if { |k, v| [*v].all?{ |i| i.blank? && i != false } }
@@ -37,7 +38,7 @@ module Ransack
 
     def build(params)
       collapse_multiparameter_attributes!(params).each do |key, value|
-        if Constants::S_SORTS.include?(key)
+        if ['s'.freeze, 'sorts'.freeze].freeze.include?(key)
           send("#{key}=", value)
         elsif base.attribute_method?(key)
           base.send("#{key}=", value)
@@ -92,7 +93,7 @@ module Ransack
 
     def method_missing(method_id, *args)
       method_name = method_id.to_s
-      getter_name = method_name.sub(/=$/, Constants::EMPTY)
+      getter_name = method_name.sub(/=$/, ''.freeze)
       if base.attribute_method?(getter_name)
         base.send(method_id, *args)
       elsif @context.ransackable_scope?(getter_name, @context.object)
@@ -113,8 +114,8 @@ module Ransack
         [:base, base.inspect]
       ]
       .compact
-      .map { |d| d.join(Constants::COLON_SPACE) }
-      .join(Constants::COMMA_SPACE)
+      .map { |d| d.join(': '.freeze) }
+      .join(', '.freeze)
 
       "Ransack::Search<#{details}>"
     end

data/lib/ransack/translate.rb

@@ -25,7 +25,7 @@ module Ransack
         |x| x.respond_to?(:model_name)
       }
       predicate = Predicate.detect_from_string(original_name)
-      attributes_str = original_name.sub(/_#{predicate}$/, Constants::EMPTY)
+      attributes_str = original_name.sub(/_#{predicate}$/, ''.freeze)
       attribute_names = attributes_str.split(/_and_|_or_/)
       combinator = attributes_str.match(/_and_/) ? :and : :or
       defaults = base_ancestors.map do |klass|
@@ -74,7 +74,7 @@ module Ransack
     def self.attribute_name(context, name, include_associations = nil)
       @context, @name = context, name
       @assoc_path = context.association_path(name)
-      @attr_name = @name.sub(/^#{@assoc_path}_/, Constants::EMPTY)
+      @attr_name = @name.sub(/^#{@assoc_path}_/, ''.freeze)
       associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
       @include_associated = include_associations && associated_class
 

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = '1.7.0'
+  VERSION = '1.8.0'
 end

data/ransack.gemspec

@@ -20,14 +20,14 @@ Gem::Specification.new do |s|
   s.add_dependency 'activerecord', '>= 3.0'
   s.add_dependency 'activesupport', '>= 3.0'
   s.add_dependency 'i18n'
-  s.add_dependency 'polyamorous', '~> 1.2'
-  s.add_development_dependency 'rspec', '~> 2'
+  s.add_dependency 'polyamorous', '~> 1.3'
+  s.add_development_dependency 'rspec', '~> 3'
   s.add_development_dependency 'machinist', '~> 1.0.6'
   s.add_development_dependency 'faker', '~> 0.9.5'
   s.add_development_dependency 'sqlite3', '~> 1.3.3'
   s.add_development_dependency 'pg'
-  s.add_development_dependency 'mysql2', '0.3.18'
-  s.add_development_dependency 'pry', '0.9.12.2'
+  s.add_development_dependency 'mysql2', '0.3.20'
+  s.add_development_dependency 'pry', '0.10'
 
   s.files         = `git ls-files`.split("\n")
 

data/spec/mongoid/adapters/mongoid/base_spec.rb

@@ -20,7 +20,9 @@ module Ransack
 
           context 'with scopes' do
             before do
-              Person.stub :ransackable_scopes => [:active, :over_age]
+              allow(Person)
+              .to receive(:ransackable_scopes)
+              .and_return([:active, :over_age])
             end
 
             it "applies true scopes" do
@@ -50,6 +52,21 @@ module Ransack
           end
         end
 
+        describe '#ransack_alias' do
+          it 'translates an alias to the correct attributes' do
+            p = Person.create!(name: 'Meatloaf', email: 'babies@example.com')
+
+            s = Person.ransack(term_cont: 'atlo')
+            expect(s.result.to_a).to eq [p]
+
+            s = Person.ransack(term_cont: 'babi')
+            expect(s.result.to_a).to eq [p]
+
+            s = Person.ransack(term_cont: 'nomatch')
+            expect(s.result.to_a).to eq []
+          end
+        end
+
         describe '#ransacker' do
           # For infix tests
           def self.sane_adapter?
@@ -213,6 +230,7 @@ module Ransack
             it { should include 'name' }
             it { should include 'reversed_name' }
             it { should include 'doubled_name' }
+            it { should include 'term' }
             it { should include 'only_search' }
             it { should_not include 'only_sort' }
             it { should_not include 'only_admin' }
@@ -224,6 +242,7 @@ module Ransack
             it { should include 'name' }
             it { should include 'reversed_name' }
             it { should include 'doubled_name' }
+            it { should include 'term' }
             it { should include 'only_search' }
             it { should_not include 'only_sort' }
             it { should include 'only_admin' }

data/spec/mongoid/nodes/condition_spec.rb

@@ -4,6 +4,21 @@ module Ransack
   module Nodes
     describe Condition do
 
+      context 'with an alias' do
+        subject {
+          Condition.extract(
+            Context.for(Person), 'term_start', Person.first(2).map(&:name)
+          )
+        }
+
+        specify { expect(subject.combinator).to eq 'or' }
+        specify { expect(subject.predicate.name).to eq 'start' }
+
+        it 'converts the alias to the correct attributes' do
+          expect(subject.attributes.map(&:name)).to eq(['name', 'email'])
+        end
+      end
+
       context 'with multiple values and an _any predicate' do
         subject { Condition.extract(Context.for(Person), 'name_eq_any', Person.first(2).map(&:name)) }
 

data/spec/mongoid/support/mongoid.yml

@@ -1,4 +1,9 @@
 test:
+  clients:
+    default:
+      database: ransack_mongoid_test
+      hosts:
+        - localhost:27017
   sessions:
     default:
       database: ransack_mongoid_test

data/spec/mongoid/support/schema.rb

@@ -1,6 +1,8 @@
 require 'mongoid'
 
 Mongoid.load!(File.expand_path("../mongoid.yml", __FILE__), :test)
+Mongo::Logger.logger.level = Logger::WARN if defined?(Mongo)
+Mongoid.purge!
 
 class Person
   include Mongoid::Document
@@ -20,6 +22,8 @@ class Person
   has_many   :articles
   has_many   :comments
 
+  ransack_alias :term, :name_or_email
+
   # has_many   :authored_article_comments, :through => :articles,
              # :source => :comments, :foreign_key => :person_id
 

data/spec/mongoid_spec_helper.rb

@@ -9,10 +9,9 @@ I18n.enforce_available_locales = false
 Time.zone = 'Eastern Time (US & Canada)'
 I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'support', '*.yml')]
 
-Dir[File.expand_path('../{mongoid/helpers,mongoid/support,blueprints}/*.rb', __FILE__)]
-.each do |f|
-  require f
-end
+Dir[File.expand_path('../{mongoid/helpers,mongoid/support,blueprints}/*.rb',
+  __FILE__)]
+.each { |f| require f }
 
 Sham.define do
   name        { Faker::Name.name }
@@ -31,11 +30,16 @@ RSpec.configure do |config|
   config.alias_it_should_behave_like_to :it_has_behavior, 'has behavior'
 
   config.before(:suite) do
-    puts '=' * 80
-    connection_name = Mongoid.default_session.inspect
-    puts "Running specs against #{connection_name}, Mongoid #{
-      Mongoid::VERSION}, Moped #{Moped::VERSION} and Origin #{Origin::VERSION}..."
-    puts '=' * 80
+    if ENV['DB'] == 'mongoid4'
+      message = "Running Ransack specs with #{Mongoid.default_session.inspect
+        }, Mongoid #{Mongoid::VERSION}, Moped #{Moped::VERSION
+        }, Origin #{Origin::VERSION} and Ruby #{RUBY_VERSION}"
+    else
+      message = "Running Ransack specs with #{Mongoid.default_client.inspect
+        }, Mongoid #{Mongoid::VERSION}, Mongo driver #{Mongo::VERSION}"
+    end
+    line = '=' * message.length
+    puts line, message, line
     Schema.create
   end
 

data/spec/ransack/adapters/active_record/base_spec.rb

@@ -20,50 +20,66 @@ module Ransack
 
           context 'with scopes' do
             before do
-              Person.stub :ransackable_scopes => [:active, :over_age, :of_age]
+              allow(Person)
+              .to receive(:ransackable_scopes)
+              .and_return([:active, :over_age, :of_age])
             end
 
-            it "applies true scopes" do
+            it 'applies true scopes' do
               s = Person.ransack('active' => true)
               expect(s.result.to_sql).to (include 'active = 1')
             end
 
-            it "applies stringy true scopes" do
+            it 'applies stringy true scopes' do
               s = Person.ransack('active' => 'true')
               expect(s.result.to_sql).to (include 'active = 1')
             end
 
-            it "applies stringy boolean scopes with true value in an array" do
+            it 'applies stringy boolean scopes with true value in an array' do
               s = Person.ransack('of_age' => ['true'])
               expect(s.result.to_sql).to (include 'age >= 18')
             end
 
-            it "applies stringy boolean scopes with false value in an array" do
+            it 'applies stringy boolean scopes with false value in an array' do
               s = Person.ransack('of_age' => ['false'])
               expect(s.result.to_sql).to (include 'age < 18')
             end
 
-            it "ignores unlisted scopes" do
+            it 'ignores unlisted scopes' do
               s = Person.ransack('restricted' => true)
               expect(s.result.to_sql).to_not (include 'restricted')
             end
 
-            it "ignores false scopes" do
+            it 'ignores false scopes' do
               s = Person.ransack('active' => false)
               expect(s.result.to_sql).not_to (include 'active')
             end
 
-            it "ignores stringy false scopes" do
+            it 'ignores stringy false scopes' do
               s = Person.ransack('active' => 'false')
               expect(s.result.to_sql).to_not (include 'active')
             end
 
-            it "passes values to scopes" do
+            it 'passes values to scopes' do
               s = Person.ransack('over_age' => 18)
               expect(s.result.to_sql).to (include 'age > 18')
             end
 
-            it "chains scopes" do
+            # TODO: Implement a way to pass true/false values like 0 or 1 to
+            # scopes (e.g. with `in` / `not_in` predicates), without Ransack
+            # converting them to true/false boolean values instead.
+
+            # it 'passes true values to scopes', focus: true  do
+            #   s = Person.ransack('over_age' => 1)
+            #   expect(s.result.to_sql).to (include 'age > 1')
+            # end
+
+            # it 'passes false values to scopes', focus: true  do
+            #   s = Person.ransack('over_age' => 0)
+            #   expect(s.result.to_sql).to (include 'age > 0')
+            # end
+
+            it 'chains scopes' do
               s = Person.ransack('over_age' => 18, 'active' => true)
               expect(s.result.to_sql).to (include 'age > 18')
               expect(s.result.to_sql).to (include 'active = 1')
@@ -75,16 +91,112 @@ module Ransack
           end
 
           it 'does not modify the parameters' do
-            params = { :name_eq => '' }
+            params = { name_eq: '' }
             expect { Person.ransack(params) }.not_to change { params }
           end
         end
 
+        context 'negative conditions on HABTM associations' do
+          let(:medieval) { Tag.create!(name: 'Medieval') }
+          let(:fantasy)  { Tag.create!(name: 'Fantasy') }
+          let(:arthur)   { Article.create!(title: 'King Arthur') }
+          let(:marco)    { Article.create!(title: 'Marco Polo') }
+
+          before do
+            marco.tags << medieval
+            arthur.tags << medieval
+            arthur.tags << fantasy
+          end
+
+          it 'removes redundant joins from top query' do
+            s = Article.ransack(tags_name_not_eq: "Fantasy")
+            sql = s.result.to_sql
+
+            expect(sql).to_not include('LEFT OUTER JOIN')
+          end
+
+          it 'handles != for single values' do
+            s = Article.ransack(tags_name_not_eq: "Fantasy")
+            articles = s.result.to_a
+
+            expect(articles).to include marco
+            expect(articles).to_not include arthur
+          end
+
+          it 'handles NOT IN for multiple attributes' do
+            s = Article.ransack(tags_name_not_in: ["Fantasy", "Scifi"])
+            articles = s.result.to_a
+
+            expect(articles).to include marco
+            expect(articles).to_not include arthur
+          end
+        end
+
+        context 'negative conditions on self-referenced associations' do
+          let(:pop) { Person.create!(name: 'Grandpa') }
+          let(:dad) { Person.create!(name: 'Father') }
+          let(:mom) { Person.create!(name: 'Mother') }
+          let(:son) { Person.create!(name: 'Grandchild') }
+
+          before do
+            son.parent = dad
+            dad.parent = pop
+            dad.children << son
+            mom.children << son
+            pop.children << dad
+            son.save! && dad.save! && mom.save! && pop.save!
+          end
+
+          it 'handles multiple associations and aliases' do
+            s = Person.ransack(
+              c: {
+                '0' => { a: ['name'], p: 'not_eq', v: ['Father'] },
+                '1' => {
+                        a: ['children_name', 'parent_name'],
+                        p: 'not_eq', v: ['Father'], m: 'or'
+                      },
+                '2' => { a: ['children_salary'], p: 'eq', v: [nil] }
+              })
+            people = s.result
+
+            expect(people.to_a).to include son
+            expect(people.to_a).to include mom
+            expect(people.to_a).to_not include dad  # rule '0': 'name'
+            expect(people.to_a).to_not include pop  # rule '1': 'children_name'
+          end
+        end
+
+        describe '#ransack_alias' do
+          it 'translates an alias to the correct attributes' do
+            p = Person.create!(name: 'Meatloaf', email: 'babies@example.com')
+
+            s = Person.ransack(term_cont: 'atlo')
+            expect(s.result.to_a).to eq [p]
+
+            s = Person.ransack(term_cont: 'babi')
+            expect(s.result.to_a).to eq [p]
+
+            s = Person.ransack(term_cont: 'nomatch')
+            expect(s.result.to_a).to eq []
+          end
+
+          it 'also works with associations' do
+            dad = Person.create!(name: 'Birdman')
+            son = Person.create!(name: 'Weezy', parent: dad)
+
+            s = Person.ransack(daddy_eq: 'Birdman')
+            expect(s.result.to_a).to eq [son]
+
+            s = Person.ransack(daddy_eq: 'Drake')
+            expect(s.result.to_a).to eq []
+          end
+        end
+
         describe '#ransacker' do
           # For infix tests
           def self.sane_adapter?
             case ::ActiveRecord::Base.connection.adapter_name
-            when "SQLite3", "PostgreSQL"
+            when 'SQLite3', 'PostgreSQL'
               true
             else
               false
@@ -102,87 +214,111 @@ module Ransack
           # end
 
           it 'creates ransack attributes' do
-            s = Person.ransack(:reversed_name_eq => 'htimS cirA')
+            s = Person.ransack(reversed_name_eq: 'htimS cirA')
             expect(s.result.size).to eq(1)
 
             expect(s.result.first).to eq Person.where(name: 'Aric Smith').first
           end
 
           it 'can be accessed through associations' do
-            s = Person.ransack(:children_reversed_name_eq => 'htimS cirA')
+            s = Person.ransack(children_reversed_name_eq: 'htimS cirA')
             expect(s.result.to_sql).to match(
               /#{quote_table_name("children_people")}.#{
                  quote_column_name("name")} = 'Aric Smith'/
             )
           end
 
-          it 'allows an "attribute" to be an InfixOperation' do
-            s = Person.ransack(:doubled_name_eq => 'Aric SmithAric Smith')
+          it 'allows an attribute to be an InfixOperation' do
+            s = Person.ransack(doubled_name_eq: 'Aric SmithAric Smith')
             expect(s.result.first).to eq Person.where(name: 'Aric Smith').first
           end if defined?(Arel::Nodes::InfixOperation) && sane_adapter?
 
-          it "doesn't break #count if using InfixOperations" do
-            s = Person.ransack(:doubled_name_eq => 'Aric SmithAric Smith')
+          it 'does not break #count if using InfixOperations' do
+            s = Person.ransack(doubled_name_eq: 'Aric SmithAric Smith')
             expect(s.result.count).to eq 1
           end if defined?(Arel::Nodes::InfixOperation) && sane_adapter?
 
-          it "should remove empty key value pairs from the params hash" do
-            s = Person.ransack(:children_reversed_name_eq => '')
+          it 'should remove empty key value pairs from the params hash' do
+            s = Person.ransack(children_reversed_name_eq: '')
             expect(s.result.to_sql).not_to match /LEFT OUTER JOIN/
           end
 
-          it "should keep proper key value pairs in the params hash" do
-            s = Person.ransack(:children_reversed_name_eq => 'Testing')
+          it 'should keep proper key value pairs in the params hash' do
+            s = Person.ransack(children_reversed_name_eq: 'Testing')
             expect(s.result.to_sql).to match /LEFT OUTER JOIN/
           end
 
-          it "should function correctly when nil is passed in" do
+          it 'should function correctly when nil is passed in' do
             s = Person.ransack(nil)
           end
 
-          it "should function correctly when a blank string is passed in" do
+          it 'should function correctly when a blank string is passed in' do
             s = Person.ransack('')
           end
 
-          it "should function correctly with a multi-parameter attribute" do
+          it 'should function correctly with a multi-parameter attribute' do
             ::ActiveRecord::Base.default_timezone = :utc
             Time.zone = 'UTC'
 
             date = Date.current
             s = Person.ransack(
-              { "created_at_gteq(1i)" => date.year,
-                "created_at_gteq(2i)" => date.month,
-                "created_at_gteq(3i)" => date.day
+              { 'created_at_gteq(1i)' => date.year,
+                'created_at_gteq(2i)' => date.month,
+                'created_at_gteq(3i)' => date.day
               }
             )
             expect(s.result.to_sql).to match />=/
             expect(s.result.to_sql).to match date.to_s
           end
 
-          it "should function correctly when using fields with dots in them" do
-            s = Person.ransack(:email_cont => "example.com")
+          it 'should function correctly when using fields with dots in them' do
+            s = Person.ransack(email_cont: 'example.com')
             expect(s.result.exists?).to be true
           end
 
-          it "should function correctly when using fields with % in them" do
-            p = Person.create!(:name => "110%-er")
-            s = Person.ransack(:name_cont => "10%")
+          it 'should function correctly when using fields with % in them' do
+            p = Person.create!(name: '110%-er')
+            s = Person.ransack(name_cont: '10%')
             expect(s.result.to_a).to eq [p]
           end
 
-          it "should function correctly when using fields with backslashes in them" do
-            p = Person.create!(:name => "\\WINNER\\")
-            s = Person.ransack(:name_cont => "\\WINNER\\")
+          it 'should function correctly when using fields with backslashes in them' do
+            p = Person.create!(name: "\\WINNER\\")
+            s = Person.ransack(name_cont: "\\WINNER\\")
             expect(s.result.to_a).to eq [p]
           end
 
-          context "searching on an `in` predicate with a ransacker" do
-            it "should function correctly when passing an array of ids" do
+          context 'searching by underscores' do
+            # when escaping is supported right in LIKE expression without adding extra expressions
+            def self.simple_escaping?
+              case ::ActiveRecord::Base.connection.adapter_name
+                when 'Mysql2', 'PostgreSQL'
+                  true
+                else
+                  false
+              end
+            end
+
+            it 'should search correctly if matches exist' do
+              p = Person.create!(name: 'name_with_underscore')
+              s = Person.ransack(name_cont: 'name_')
+              expect(s.result.to_a).to eq [p]
+            end if simple_escaping?
+
+            it 'should return empty result if no matches' do
+              Person.create!(name: 'name_with_underscore')
+              s = Person.ransack(name_cont: 'n_')
+              expect(s.result.to_a).to eq []
+            end if simple_escaping?
+          end
+
+          context 'searching on an `in` predicate with a ransacker' do
+            it 'should function correctly when passing an array of ids' do
               s = Person.ransack(array_users_in: true)
               expect(s.result.count).to be > 0
             end
 
-            it "should function correctly when passing an array of strings" do
+            it 'should function correctly when passing an array of strings' do
               Person.create!(name: Person.first.id.to_s)
               s = Person.ransack(array_names_in: true)
               expect(s.result.count).to be > 0
@@ -196,49 +332,67 @@ module Ransack
             end
           end
 
-          context "search on an `in` predicate with an array" do
-            it "should function correctly when passing an array of ids" do
+          context 'search on an `in` predicate with an array' do
+            it 'should function correctly when passing an array of ids' do
               array = Person.all.map(&:id)
               s = Person.ransack(id_in: array)
               expect(s.result.count).to eq array.size
             end
           end
 
-          it "should function correctly when an attribute name ends with '_start'" do
-            p = Person.create!(:new_start => 'Bar and foo', :name => 'Xiang')
+          it 'should work correctly when an attribute name ends with _start' do
+            p = Person.create!(new_start: 'Bar and foo', name: 'Xiang')
 
-            s = Person.ransack(:new_start_end => ' and foo')
+            s = Person.ransack(new_start_end: ' and foo')
             expect(s.result.to_a).to eq [p]
 
-            s = Person.ransack(:name_or_new_start_start => 'Xia')
+            s = Person.ransack(name_or_new_start_start: 'Xia')
             expect(s.result.to_a).to eq [p]
 
-            s = Person.ransack(:new_start_or_name_end => 'iang')
+            s = Person.ransack(new_start_or_name_end: 'iang')
             expect(s.result.to_a).to eq [p]
           end
 
-          it "should function correctly when an attribute name ends with '_end'" do
-            p = Person.create!(:stop_end => 'Foo and bar', :name => 'Marianne')
+          it 'should work correctly when an attribute name ends with _end' do
+            p = Person.create!(stop_end: 'Foo and bar', name: 'Marianne')
 
-            s = Person.ransack(:stop_end_start => 'Foo and')
+            s = Person.ransack(stop_end_start: 'Foo and')
             expect(s.result.to_a).to eq [p]
 
-            s = Person.ransack(:stop_end_or_name_end => 'anne')
+            s = Person.ransack(stop_end_or_name_end: 'anne')
             expect(s.result.to_a).to eq [p]
 
-            s = Person.ransack(:name_or_stop_end_end => ' bar')
+            s = Person.ransack(name_or_stop_end_end: ' bar')
             expect(s.result.to_a).to eq [p]
           end
 
-          it "should function correctly when an attribute name has 'and' in it" do
-            p = Person.create!(:terms_and_conditions => true)
-            s = Person.ransack(:terms_and_conditions_eq => true)
+          it 'should work correctly when an attribute name has `and` in it' do
+            p = Person.create!(terms_and_conditions: true)
+            s = Person.ransack(terms_and_conditions_eq: true)
             expect(s.result.to_a).to eq [p]
           end
 
-          it 'allows sort by "only_sort" field' do
+          context 'attribute aliased column names',
+          if: Ransack::SUPPORTS_ATTRIBUTE_ALIAS do
+            it 'should be translated to original column name' do
+              s = Person.ransack(full_name_eq: 'Nicolas Cage')
+              expect(s.result.to_sql).to match(
+                /WHERE #{quote_table_name("people")}.#{quote_column_name("name")}/
+              )
+            end
+
+            it 'should translate on associations' do
+              s = Person.ransack(articles_content_cont: 'Nicolas Cage')
+              expect(s.result.to_sql).to match(
+                /#{quote_table_name("articles")}.#{
+                   quote_column_name("body")} I?LIKE '%Nicolas Cage%'/
+              )
+            end
+          end
+
+          it 'allows sort by `only_sort` field' do
             s = Person.ransack(
-              "s" => { "0" => { "dir" => "asc", "name" => "only_sort" } }
+              's' => { '0' => { 'dir' => 'asc', 'name' => 'only_sort' } }
             )
             expect(s.result.to_sql).to match(
               /ORDER BY #{quote_table_name("people")}.#{
@@ -246,9 +400,9 @@ module Ransack
             )
           end
 
-          it "doesn't sort by 'only_search' field" do
+          it 'does not sort by `only_search` field' do
             s = Person.ransack(
-              "s" => { "0" => { "dir" => "asc", "name" => "only_search" } }
+              's' => { '0' => { 'dir' => 'asc', 'name' => 'only_search' } }
             )
             expect(s.result.to_sql).not_to match(
               /ORDER BY #{quote_table_name("people")}.#{
@@ -256,25 +410,25 @@ module Ransack
             )
           end
 
-          it 'allows search by "only_search" field' do
-            s = Person.ransack(:only_search_eq => 'htimS cirA')
+          it 'allows search by `only_search` field' do
+            s = Person.ransack(only_search_eq: 'htimS cirA')
             expect(s.result.to_sql).to match(
               /WHERE #{quote_table_name("people")}.#{
                 quote_column_name("only_search")} = 'htimS cirA'/
             )
           end
 
-          it "can't be searched by 'only_sort'" do
-            s = Person.ransack(:only_sort_eq => 'htimS cirA')
+          it 'cannot be searched by `only_sort`' do
+            s = Person.ransack(only_sort_eq: 'htimS cirA')
             expect(s.result.to_sql).not_to match(
               /WHERE #{quote_table_name("people")}.#{
                 quote_column_name("only_sort")} = 'htimS cirA'/
             )
           end
 
-          it 'allows sort by "only_admin" field, if auth_object: :admin' do
+          it 'allows sort by `only_admin` field, if auth_object: :admin' do
             s = Person.ransack(
-              { "s" => { "0" => { "dir" => "asc", "name" => "only_admin" } } },
+              { 's' => { '0' => { 'dir' => 'asc', 'name' => 'only_admin' } } },
               { auth_object: :admin }
             )
             expect(s.result.to_sql).to match(
@@ -283,9 +437,9 @@ module Ransack
             )
           end
 
-          it "doesn't sort by 'only_admin' field, if auth_object: nil" do
+          it 'does not sort by `only_admin` field, if auth_object: nil' do
             s = Person.ransack(
-              "s" => { "0" => { "dir" => "asc", "name" => "only_admin" } }
+              's' => { '0' => { 'dir' => 'asc', 'name' => 'only_admin' } }
             )
             expect(s.result.to_sql).not_to match(
               /ORDER BY #{quote_table_name("people")}.#{
@@ -293,10 +447,10 @@ module Ransack
             )
           end
 
-          it 'allows search by "only_admin" field, if auth_object: :admin' do
+          it 'allows search by `only_admin` field, if auth_object: :admin' do
             s = Person.ransack(
-              { :only_admin_eq => 'htimS cirA' },
-              { :auth_object => :admin }
+              { only_admin_eq: 'htimS cirA' },
+              { auth_object: :admin }
             )
             expect(s.result.to_sql).to match(
               /WHERE #{quote_table_name("people")}.#{
@@ -304,8 +458,8 @@ module Ransack
             )
           end
 
-          it "can't be searched by 'only_admin', if auth_object: nil" do
-            s = Person.ransack(:only_admin_eq => 'htimS cirA')
+          it 'cannot be searched by `only_admin`, if auth_object: nil' do
+            s = Person.ransack(only_admin_eq: 'htimS cirA')
             expect(s.result.to_sql).not_to match(
               /WHERE #{quote_table_name("people")}.#{
                 quote_column_name("only_admin")} = 'htimS cirA'/
@@ -332,6 +486,25 @@ module Ransack
               )
             expect { s.result.first }.to_not raise_error
           end
+
+          it 'should allow sort passing arguments to a ransacker' do
+            s = Person.ransack(
+              s: {
+                '0' => {
+                  name: 'with_arguments', dir: 'desc', ransacker_args: [2, 6]
+                }
+              }
+            )
+            expect(s.result.to_sql).to match(
+              /ORDER BY \(SELECT MAX\(articles.title\) FROM articles/
+              )
+            expect(s.result.to_sql).to match(
+              /WHERE articles.person_id = people.id AND LENGTH\(articles.body\)/
+              )
+            expect(s.result.to_sql).to match(
+              /BETWEEN 2 AND 6 GROUP BY articles.person_id \) DESC/
+            )
+          end
         end
 
         describe '#ransackable_attributes' do
@@ -341,9 +514,14 @@ module Ransack
             it { should include 'name' }
             it { should include 'reversed_name' }
             it { should include 'doubled_name' }
+            it { should include 'term' }
             it { should include 'only_search' }
             it { should_not include 'only_sort' }
             it { should_not include 'only_admin' }
+
+            if Ransack::SUPPORTS_ATTRIBUTE_ALIAS
+              it { should include 'full_name' }
+            end
           end
 
           context 'with auth_object :admin' do