ransack 1.6.4 → 1.6.5

data/spec/ransack/configuration_spec.rb

@@ -64,5 +64,41 @@ module Ransack
       expect(Ransack.predicates).not_to have_key 'test_array_predicate_any'
       expect(Ransack.predicates).not_to have_key 'test_array_predicate_all'
     end
+
+    describe '`wants_array` option takes precedence over Arel predicate' do
+      it 'implicitly wants an array for in/not in predicates' do
+        Ransack.configure do |config|
+          config.add_predicate(
+            :test_in_predicate,
+            :arel_predicate => 'in'
+          )
+          config.add_predicate(
+            :test_not_in_predicate,
+            :arel_predicate => 'not_in'
+          )
+        end
+
+        expect(Ransack.predicates['test_in_predicate'].wants_array).to eq true
+        expect(Ransack.predicates['test_not_in_predicate'].wants_array).to eq true
+      end
+
+      it 'explicitly does not want array for in/not_in predicates' do
+        Ransack.configure do |config|
+          config.add_predicate(
+            :test_in_predicate_no_array,
+            :arel_predicate => 'in',
+            :wants_array => false
+          )
+          config.add_predicate(
+            :test_not_in_predicate_no_array,
+            :arel_predicate => 'not_in',
+            :wants_array => false
+          )
+        end
+
+        expect(Ransack.predicates['test_in_predicate_no_array'].wants_array).to eq false
+        expect(Ransack.predicates['test_not_in_predicate_no_array'].wants_array).to eq false
+      end
+    end
   end
 end

data/spec/ransack/helpers/form_helper_spec.rb

@@ -31,9 +31,9 @@ module Ransack
       describe '#sort_link with default search_key' do
         subject { @controller.view_context
           .sort_link(
-            [:main_app, Person.search(:sorts => ['name desc'])],
+            [:main_app, Person.search(sorts: ['name desc'])],
             :name,
-            :controller => 'people'
+            controller: 'people'
           )
         }
         it {
@@ -53,10 +53,10 @@ module Ransack
         subject { @controller.view_context
           .sort_link(
             Person.search(
-              { :sorts => ['name desc'] }, :search_key => :people_search
+              { sorts: ['name desc'] }, search_key: :people_search
               ),
             :name,
-            :controller => 'people'
+            controller: 'people'
           )
         }
         it {
@@ -73,10 +73,11 @@ module Ransack
       describe '#sort_link desc through association table defined as a symbol' do
         subject { @controller.view_context
           .sort_link(
-            Person.search({ :sorts => 'comments_body asc' }),
-            :comments_body, :controller => 'people'
-            )
-          }
+            Person.search({ sorts: 'comments_body asc' }),
+            :comments_body,
+            controller: 'people'
+          )
+        }
         it {
           should match(
             if ActiveRecord::VERSION::STRING =~ /^3\.[1-2]\./
@@ -93,10 +94,11 @@ module Ransack
       describe '#sort_link through association table defined as a string' do
         subject { @controller.view_context
           .sort_link(
-            Person.search({ :sorts => 'comments.body desc' }),
-            'comments.body', :controller => 'people'
-            )
-          }
+            Person.search({ sorts: 'comments.body desc' }),
+            'comments.body',
+            controller: 'people'
+          )
+        }
         it {
           should match(
             if ActiveRecord::VERSION::STRING =~ /^3\.[1-2]\./
@@ -113,24 +115,25 @@ module Ransack
       describe '#sort_link works even if search params are a blank string' do
         before { @controller.view_context.params[:q] = '' }
         specify {
-          expect {
-            @controller.view_context.sort_link(
-              Person.search(@controller.view_context.params[:q]),
-              :name,
-              :controller => 'people'
-            )
+          expect { @controller.view_context
+            .sort_link(
+              Person.search(
+                @controller.view_context.params[:q]),
+                :name,
+                controller: 'people'
+              )
           }.not_to raise_error
         }
       end
 
       describe '#sort_link with search_key defined as a string' do
-        subject {
-          @controller.view_context.sort_link(
+        subject { @controller.view_context
+          .sort_link(
             Person.search(
-              { :sorts => ['name desc'] }, :search_key => 'people_search'
-              ),
+              { sorts: ['name desc'] }, search_key: 'people_search'
+            ),
             :name,
-            :controller => 'people'
+            controller: 'people'
           )
         }
         it {
@@ -149,8 +152,8 @@ module Ransack
           .sort_link(
             [:main_app, Person.search()],
             :name,
-            :controller => 'people',
-            'default_order' => 'desc'
+            controller: 'people',
+            default_order: 'desc'
           )
         }
         it { should_not match /default_order/ }
@@ -159,9 +162,9 @@ module Ransack
       describe '#sort_link with multiple search_keys defined as an array' do
         subject { @controller.view_context
           .sort_link(
-            [:main_app, Person.search(:sorts => ['name desc', 'email asc'])],
+            [:main_app, Person.search(sorts: ['name desc', 'email asc'])],
             :name, [:name, 'email DESC'],
-            :controller => 'people'
+            controller: 'people'
           )
         }
         it {
@@ -176,9 +179,9 @@ module Ransack
       describe '#sort_link with multiple search_keys does not break on nil values & ignores them' do
         subject { @controller.view_context
           .sort_link(
-            [:main_app, Person.search(:sorts => ['name desc', nil, 'email', nil])],
+            [:main_app, Person.search(sorts: ['name desc', nil, 'email', nil])],
             :name, [nil, :name, nil, 'email DESC', nil],
-            :controller => 'people'
+            controller: 'people'
           )
         }
         it {
@@ -193,10 +196,10 @@ module Ransack
       describe '#sort_link with multiple search_keys should allow a label to be specified' do
         subject { @controller.view_context
           .sort_link(
-            [:main_app, Person.search(:sorts => ['name desc', 'email asc'])],
+            [:main_app, Person.search(sorts: ['name desc', 'email asc'])],
             :name, [:name, 'email DESC'],
             'Property Name',
-            :controller => 'people'
+            controller: 'people'
           )
         }
         it { should match /Property Name ▼/ }
@@ -205,9 +208,9 @@ module Ransack
       describe '#sort_link with multiple search_keys should flip multiple fields specified without a direction' do
         subject { @controller.view_context
           .sort_link(
-            [:main_app, Person.search(:sorts => ['name desc', 'email asc'])],
+            [:main_app, Person.search(sorts: ['name desc', 'email asc'])],
             :name, [:name, :email],
-            :controller => 'people'
+            controller: 'people'
           )
         }
         it {
@@ -224,8 +227,8 @@ module Ransack
           .sort_link(
             [:main_app, Person.search()],
             :name, [:name, :email],
-            :controller => 'people',
-            'default_order' => 'desc'
+            controller: 'people',
+            default_order: 'desc'
           )
         }
         it {
@@ -242,8 +245,8 @@ module Ransack
           .sort_link(
             [:main_app, Person.search()],
             :name, [:name, :email],
-            :controller => 'people',
-            :default_order => :desc
+            controller: 'people',
+            default_order: :desc
           )
         }
         it {
@@ -260,8 +263,8 @@ module Ransack
           .sort_link(
             [:main_app, Person.search()],
             :name, [:name, :email],
-            :controller => 'people',
-            :default_order => { 'name' => 'desc', :email => 'asc' }
+            controller: 'people',
+            default_order: { name: 'desc', email: 'asc' }
           )
         }
         it {
@@ -278,8 +281,8 @@ module Ransack
           .sort_link(
             [:main_app, Person.search()],
             :name, [:name, 'email desc'],
-            :controller => 'people',
-            :default_order => { 'name' => 'desc', :email => 'asc' }
+            controller: 'people',
+            default_order: { name: 'desc', email: 'asc' }
           )
         }
         it {
@@ -295,7 +298,8 @@ module Ransack
         subject { @controller.view_context
           .sort_link(
             [:main_app, Note.search()],
-            :notable_of_Person_type_name, "Notable", :controller => 'notes'
+            :notable_of_Person_type_name, "Notable",
+            controller: 'notes'
           )
         }
         it {
@@ -313,16 +317,17 @@ module Ransack
 
       context 'view has existing parameters' do
         before do
-          @controller.view_context.params.merge!({ :exist => 'existing' })
+          @controller.view_context.params.merge!({ exist: 'existing' })
         end
         describe '#sort_link should not remove existing params' do
-          subject {
-            @controller.view_context.sort_link(
+          subject { @controller.view_context
+            .sort_link(
               Person.search(
-                { :sorts => ['name desc'] }, :search_key => 'people_search'
-                ),
+                { sorts: ['name desc'] },
+                search_key: 'people_search'
+              ),
               :name,
-              :controller => 'people'
+              controller: 'people'
             )
           }
           it { should match /exist\=existing/ }
@@ -332,10 +337,10 @@ module Ransack
       describe '#sort_link with hide order indicator set to true' do
         subject { @controller.view_context
           .sort_link(
-            [:main_app, Person.search(:sorts => ['name desc'])],
+            [:main_app, Person.search(sorts: ['name desc'])],
             :name,
-            :controller => 'people',
-            :hide_indicator => true
+            controller: 'people',
+            hide_indicator: true
           )
         }
         it { should match /Full Name/ }
@@ -344,24 +349,25 @@ module Ransack
       describe '#sort_link with hide order indicator set to false' do
         subject { @controller.view_context
           .sort_link(
-            [:main_app, Person.search(:sorts => ['name desc'])],
+            [:main_app, Person.search(sorts: ['name desc'])],
             :name,
-            :controller => 'people',
-            :hide_indicator => false
+            controller: 'people',
+            hide_indicator: false
           )
         }
         it { should match /Full Name ▼/ }
       end
 
       describe '#search_form_for with default format' do
-        subject { @controller.view_context.search_form_for(Person.search) {} }
+        subject { @controller.view_context
+          .search_form_for(Person.search) {} }
         it { should match /action="\/people"/ }
       end
 
       describe '#search_form_for with pdf format' do
         subject {
           @controller.view_context
-          .search_form_for(Person.search, :format => :pdf) {}
+          .search_form_for(Person.search, format: :pdf) {}
         }
         it { should match /action="\/people.pdf"/ }
       end
@@ -369,14 +375,15 @@ module Ransack
       describe '#search_form_for with json format' do
         subject {
           @controller.view_context
-          .search_form_for(Person.search, :format => :json) {}
+          .search_form_for(Person.search, format: :json) {}
         }
         it { should match /action="\/people.json"/ }
       end
 
       describe '#search_form_for with an array of routes' do
         subject {
-          @controller.view_context.search_form_for([:admin, Comment.search]) {}
+          @controller.view_context
+          .search_form_for([:admin, Comment.search]) {}
         }
         it { should match /action="\/admin\/comments"/ }
       end

data/spec/ransack/search_spec.rb

@@ -3,38 +3,38 @@ require 'spec_helper'
 module Ransack
   describe Search do
     describe '#initialize' do
-      it "removes empty conditions before building" do
+      it 'removes empty conditions before building' do
         expect_any_instance_of(Search).to receive(:build).with({})
-        Search.new(Person, :name_eq => '')
+        Search.new(Person, name_eq: '')
       end
 
-      it "keeps conditions with a false value before building" do
+      it 'keeps conditions with a false value before building' do
         expect_any_instance_of(Search).to receive(:build)
-        .with({ "name_eq" => false })
-        Search.new(Person, :name_eq => false)
+        .with({ 'name_eq' => false })
+        Search.new(Person, name_eq: false)
       end
 
-      it "keeps conditions with a value before building" do
+      it 'keeps conditions with a value before building' do
         expect_any_instance_of(Search).to receive(:build)
-        .with({ "name_eq" => 'foobar' })
-        Search.new(Person, :name_eq => 'foobar')
+        .with({ 'name_eq' => 'foobar' })
+        Search.new(Person, name_eq: 'foobar')
       end
 
-      it "removes empty suffixed conditions before building" do
+      it 'removes empty suffixed conditions before building' do
         expect_any_instance_of(Search).to receive(:build).with({})
-        Search.new(Person, :name_eq_any => [''])
+        Search.new(Person, name_eq_any: [''])
       end
 
-      it "keeps suffixed conditions with a false value before building" do
+      it 'keeps suffixed conditions with a false value before building' do
         expect_any_instance_of(Search).to receive(:build)
-        .with({ "name_eq_any" => [false] })
-        Search.new(Person, :name_eq_any => [false])
+        .with({ 'name_eq_any' => [false] })
+        Search.new(Person, name_eq_any: [false])
       end
 
-      it "keeps suffixed conditions with a value before building" do
+      it 'keeps suffixed conditions with a value before building' do
         expect_any_instance_of(Search).to receive(:build)
-        .with({ "name_eq_any" => ['foobar'] })
-        Search.new(Person, :name_eq_any => ['foobar'])
+        .with({ 'name_eq_any' => ['foobar'] })
+        Search.new(Person, name_eq_any: ['foobar'])
       end
 
       it 'does not raise exception for string :params argument' do
@@ -43,19 +43,15 @@ module Ransack
 
       it 'accepts a context option' do
         shared_context = Context.for(Person)
-        search1 = Search.new(
-          Person, { "name_eq" => "A" }, context: shared_context
-          )
-        search2 = Search.new(
-          Person, { "name_eq" => "B" }, context: shared_context
-          )
+        search1 = Search.new(Person, { name_eq: 'A' }, context: shared_context)
+        search2 = Search.new(Person, { name_eq: 'B' }, context: shared_context)
         expect(search1.context).to be search2.context
       end
     end
 
     describe '#build' do
       it 'creates conditions for top-level attributes' do
-        search = Search.new(Person, :name_eq => 'Ernie')
+        search = Search.new(Person, name_eq: 'Ernie')
         condition = search.base[:name_eq]
         expect(condition).to be_a Nodes::Condition
         expect(condition.predicate.name).to eq 'eq'
@@ -64,7 +60,7 @@ module Ransack
       end
 
       it 'creates conditions for association attributes' do
-        search = Search.new(Person, :children_name_eq => 'Ernie')
+        search = Search.new(Person, children_name_eq: 'Ernie')
         condition = search.base[:children_name_eq]
         expect(condition).to be_a Nodes::Condition
         expect(condition.predicate.name).to eq 'eq'
@@ -73,33 +69,37 @@ module Ransack
       end
 
       it 'creates conditions for polymorphic belongs_to association attributes' do
-        search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
+        search = Search.new(Note, notable_of_Person_type_name_eq: 'Ernie')
         condition = search.base[:notable_of_Person_type_name_eq]
         expect(condition).to be_a Nodes::Condition
         expect(condition.predicate.name).to eq 'eq'
-        expect(condition.attributes.first.name).to eq 'notable_of_Person_type_name'
+        expect(condition.attributes.first.name)
+          .to eq 'notable_of_Person_type_name'
         expect(condition.value).to eq 'Ernie'
       end
 
-      it 'creates conditions for multiple polymorphic belongs_to association attributes' do
+      it 'creates conditions for multiple polymorphic belongs_to association
+        attributes' do
         search = Search.new(Note,
-          :notable_of_Person_type_name_or_notable_of_Article_type_title_eq => 'Ernie')
+          notable_of_Person_type_name_or_notable_of_Article_type_title_eq: 'Ernie')
         condition = search.
           base[:notable_of_Person_type_name_or_notable_of_Article_type_title_eq]
         expect(condition).to be_a Nodes::Condition
         expect(condition.predicate.name).to eq 'eq'
-        expect(condition.attributes.first.name).to eq 'notable_of_Person_type_name'
-        expect(condition.attributes.last.name).to eq 'notable_of_Article_type_title'
+        expect(condition.attributes.first.name)
+          .to eq 'notable_of_Person_type_name'
+        expect(condition.attributes.last.name)
+          .to eq 'notable_of_Article_type_title'
         expect(condition.value).to eq 'Ernie'
       end
 
       it 'preserves default scope conditions for associations' do
-        search = Search.new(Person, :articles_title_eq => 'Test')
-        expect(search.result.to_sql).to include "default_scope"
+        search = Search.new(Person, articles_title_eq: 'Test')
+        expect(search.result.to_sql).to include 'default_scope'
       end
 
       it 'discards empty conditions' do
-        search = Search.new(Person, :children_name_eq => '')
+        search = Search.new(Person, children_name_eq: '')
         condition = search.base[:children_name_eq]
         expect(condition).to be_nil
       end
@@ -112,8 +112,8 @@ module Ransack
       it 'accepts arrays of groupings' do
         search = Search.new(Person,
           g: [
-            { :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' },
-            { :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert' },
+            { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
+            { m: 'or', name_eq: 'Bert', children_name_eq: 'Bert' },
           ]
         )
         ors = search.groupings
@@ -143,11 +143,13 @@ module Ransack
 
       it 'accepts "attributes" hashes for conditions' do
         search = Search.new(Person,
-          :c => {
-            '0' => { :a => ['name'], :p => 'eq', :v => ['Ernie'] },
-            '1' => { :a => ['children_name', 'parent_name'],
-                     :p => 'eq', :v => ['Ernie'], :m => 'or' }
-            }
+          c: {
+            '0' => { a: ['name'], p: 'eq', v: ['Ernie'] },
+            '1' => {
+                     a: ['children_name', 'parent_name'],
+                     p: 'eq', v: ['Ernie'], m: 'or'
+                   }
+          }
         )
         conditions = search.base.conditions
         expect(conditions.size).to eq(2)
@@ -157,10 +159,10 @@ module Ransack
 
       it 'creates conditions for custom predicates that take arrays' do
         Ransack.configure do |config|
-          config.add_predicate 'ary_pred', :wants_array => true
+          config.add_predicate 'ary_pred', wants_array: true
         end
 
-        search = Search.new(Person, :name_ary_pred => ['Ernie', 'Bert'])
+        search = Search.new(Person, name_ary_pred: ['Ernie', 'Bert'])
         condition = search.base[:name_ary_pred]
         expect(condition).to be_a Nodes::Condition
         expect(condition.predicate.name).to eq 'ary_pred'
@@ -169,14 +171,14 @@ module Ransack
       end
 
       it 'does not evaluate the query on #inspect' do
-        search = Search.new(Person, :children_id_in => [1, 2, 3])
+        search = Search.new(Person, children_id_in: [1, 2, 3])
         expect(search.inspect).not_to match /ActiveRecord/
       end
 
       context 'with an invalid condition' do
-        subject { Search.new(Person, :unknown_attr_eq => 'Ernie') }
+        subject { Search.new(Person, unknown_attr_eq: 'Ernie') }
 
-        context "when ignore_unknown_conditions is false" do
+        context 'when ignore_unknown_conditions is false' do
           before do
             Ransack.configure { |c| c.ignore_unknown_conditions = false }
           end
@@ -184,7 +186,7 @@ module Ransack
           specify { expect { subject }.to raise_error ArgumentError }
         end
 
-        context "when ignore_unknown_conditions is true" do
+        context 'when ignore_unknown_conditions is true' do
           before do
             Ransack.configure { |c| c.ignore_unknown_conditions = true }
           end
@@ -194,7 +196,7 @@ module Ransack
       end
 
       it 'does not modify the parameters' do
-        params = { :name_eq => '' }
+        params = { name_eq: '' }
         expect { Search.new(Person, params) }.not_to change { params }
       end
 
@@ -208,68 +210,87 @@ module Ransack
         "#{quote_table_name("children_people")}.#{quote_column_name("name")}"
       }
       it 'evaluates conditions contextually' do
-        search = Search.new(Person, :children_name_eq => 'Ernie')
+        search = Search.new(Person, children_name_eq: 'Ernie')
         expect(search.result).to be_an ActiveRecord::Relation
-        where = search.result.where_values.first
-        expect(where.to_sql).to match /#{children_people_name_field} = 'Ernie'/
+        expect(search.result.to_sql).to match /#{
+          children_people_name_field} = 'Ernie'/
+      end
+
+      # FIXME: Make this spec pass for Rails 4.1 / 4.2 / 5.0 and not just 4.0 by
+      # commenting out lines 221 and 242 to run the test. Addresses issue #374.
+      # https://github.com/activerecord-hackery/ransack/issues/374
+      #
+      if ::ActiveRecord::VERSION::STRING.first(3) == '4.0'
+        it 'evaluates conditions for multiple belongs_to associations to the
+        same table contextually' do
+          s = Search.new(Recommendation,
+            person_name_eq: 'Ernie',
+            target_person_parent_name_eq: 'Test'
+          ).result
+          expect(s).to be_an ActiveRecord::Relation
+          real_query = remove_quotes_and_backticks(s.to_sql)
+          expected_query = <<-SQL
+            SELECT recommendations.* FROM recommendations
+            LEFT OUTER JOIN people ON people.id = recommendations.person_id
+            LEFT OUTER JOIN people target_people_recommendations
+              ON target_people_recommendations.id = recommendations.target_person_id
+            LEFT OUTER JOIN people parents_people
+              ON parents_people.id = target_people_recommendations.parent_id
+            WHERE ((people.name = 'Ernie' AND parents_people.name = 'Test'))
+          SQL
+          .squish
+          expect(real_query).to eq expected_query
+        end
       end
 
       it 'evaluates compound conditions contextually' do
-        search = Search.new(Person, :children_name_or_name_eq => 'Ernie')
-        expect(search.result).to be_an ActiveRecord::Relation
-        where = search.result.where_values.first
-        expect(where.to_sql).to match /#{children_people_name_field
+        search = Search.new(Person, children_name_or_name_eq: 'Ernie').result
+        expect(search).to be_an ActiveRecord::Relation
+        expect(search.to_sql).to match /#{children_people_name_field
           } = 'Ernie' OR #{people_name_field} = 'Ernie'/
       end
 
       it 'evaluates polymorphic belongs_to association conditions contextually' do
-        search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
-        expect(search.result).to be_an ActiveRecord::Relation
-        where = search.result.where_values.first
-        expect(where.to_sql).to match /#{people_name_field} = 'Ernie'/
+        search = Search.new(Note, notable_of_Person_type_name_eq: 'Ernie')
+        .result
+        expect(search).to be_an ActiveRecord::Relation
+        expect(search.to_sql).to match /#{people_name_field} = 'Ernie'/
       end
 
       it 'evaluates nested conditions' do
-        search = Search.new(Person, :children_name_eq => 'Ernie',
-          :g => [
-            { :m => 'or',
-              :name_eq => 'Ernie',
-              :children_children_name_eq => 'Ernie'
-            }
+        search = Search.new(Person, children_name_eq: 'Ernie',
+          g: [
+            { m: 'or', name_eq: 'Ernie', children_children_name_eq: 'Ernie' }
           ]
-        )
-        expect(search.result).to be_an ActiveRecord::Relation
-        where = search.result.where_values.first
-        expect(where.to_sql).to match /#{children_people_name_field} = 'Ernie'/
-        expect(where.to_sql).to match /#{people_name_field} = 'Ernie'/
-        expect(where.to_sql).to match /#{quote_table_name("children_people_2")
-          }.#{quote_column_name("name")} = 'Ernie'/
+        ).result
+        expect(search).to be_an ActiveRecord::Relation
+        first, last = search.to_sql.split(/ AND /)
+        expect(first).to match /#{children_people_name_field} = 'Ernie'/
+        expect(last).to match /#{
+          people_name_field} = 'Ernie' OR #{
+          quote_table_name("children_people_2")}.#{
+          quote_column_name("name")} = 'Ernie'/
       end
 
       it 'evaluates arrays of groupings' do
         search = Search.new(Person,
-          :g => [
-            { :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' },
-            { :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert' }
+          g: [
+            { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
+            { m: 'or', name_eq: 'Bert', children_name_eq: 'Bert' }
           ]
-        )
-        expect(search.result).to be_an ActiveRecord::Relation
-        where = search.result.where_values.first
-        sql = where.to_sql
-        first, second = sql.split(/ AND /)
-        expect(first).to match /#{people_name_field} = 'Ernie'/
-        expect(first).to match /#{children_people_name_field} = 'Ernie'/
-        expect(second).to match /#{people_name_field} = 'Bert'/
-        expect(second).to match /#{children_people_name_field} = 'Bert'/
+        ).result
+        expect(search).to be_an ActiveRecord::Relation
+        first, last = search.to_sql.split(/ AND /)
+        expect(first).to match /#{people_name_field} = 'Ernie' OR #{
+          children_people_name_field} = 'Ernie'/
+        expect(last).to match /#{people_name_field} = 'Bert' OR #{
+          children_people_name_field} = 'Bert'/
       end
 
-      it 'returns distinct records when passed :distinct => true' do
-        search = Search.new(
-          Person, :g => [
-            { :m => 'or',
-              :comments_body_cont => 'e',
-              :articles_comments_body_cont => 'e'
-            }
+      it 'returns distinct records when passed distinct: true' do
+        search = Search.new(Person,
+          g: [
+            { m: 'or', comments_body_cont: 'e', articles_comments_body_cont: 'e' }
           ]
         )
         if ActiveRecord::VERSION::MAJOR == 3
@@ -279,11 +300,17 @@ module Ransack
         end
         expect(search.result.send(all_or_load).size)
         .to eq(9000)
-        expect(search.result(:distinct => true).size)
+        expect(search.result(distinct: true).size)
         .to eq(10)
         expect(search.result.send(all_or_load).send(uniq_or_distinct))
-        .to eq search.result(:distinct => true).send(all_or_load)
+        .to eq search.result(distinct: true).send(all_or_load)
       end
+
+      private
+
+        def remove_quotes_and_backticks(str)
+          str.gsub(/["`]/, '')
+        end
     end
 
     describe '#sorts=' do
@@ -319,7 +346,7 @@ module Ransack
       end
 
       it 'creates sorts based on multiple attributes/directions in array format' do
-        @s.sorts = ['id desc', { :name => 'name', :dir => 'asc' }]
+        @s.sorts = ['id desc', { name: 'name', dir: 'asc' }]
         expect(@s.sorts.size).to eq(2)
         sort1, sort2 = @s.sorts
         expect(sort1).to be_a Nodes::Sort
@@ -331,7 +358,7 @@ module Ransack
       end
 
       it 'creates sorts based on multiple attributes and uppercase directions in array format' do
-        @s.sorts = ['id DESC', { :name => 'name', :dir => 'ASC' }]
+        @s.sorts = ['id DESC', { name: 'name', dir: 'ASC' }]
         expect(@s.sorts.size).to eq(2)
         sort1, sort2 = @s.sorts
         expect(sort1).to be_a Nodes::Sort
@@ -342,7 +369,8 @@ module Ransack
         expect(sort2.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and different directions in array format' do
+      it 'creates sorts based on multiple attributes and different directions
+        in array format' do
         @s.sorts = ['id DESC', { name: 'name', dir: nil }]
         expect(@s.sorts.size).to eq(2)
         sort1, sort2 = @s.sorts
@@ -356,8 +384,8 @@ module Ransack
 
       it 'creates sorts based on multiple attributes/directions in hash format' do
         @s.sorts = {
-          '0' => { :name => 'id', :dir => 'desc' },
-          '1' => { :name => 'name', :dir => 'asc' }
+          '0' => { name: 'id', dir: 'desc' },
+          '1' => { name: 'name', dir: 'asc' }
         }
         expect(@s.sorts.size).to eq(2)
         expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
@@ -367,10 +395,11 @@ module Ransack
         expect(name_sort.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and uppercase directions in hash format' do
+      it 'creates sorts based on multiple attributes and uppercase directions
+        in hash format' do
         @s.sorts = {
-          '0' => { :name => 'id', :dir => 'DESC' },
-          '1' => { :name => 'name', :dir => 'ASC' }
+          '0' => { name: 'id', dir: 'DESC' },
+          '1' => { name: 'name', dir: 'ASC' }
         }
         expect(@s.sorts.size).to eq(2)
         expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
@@ -380,10 +409,11 @@ module Ransack
         expect(name_sort.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and different directions in hash format' do
+      it 'creates sorts based on multiple attributes and different directions
+        in hash format' do
         @s.sorts = {
-          '0' => { :name => 'id', :dir => 'DESC' },
-          '1' => { :name => 'name', :dir => nil }
+          '0' => { name: 'id', dir: 'DESC' },
+          '1' => { name: 'name', dir: nil }
         }
         expect(@s.sorts.size).to eq(2)
         expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
@@ -415,7 +445,7 @@ module Ransack
 
       it 'allows chaining to access nested conditions' do
         @s.groupings = [
-          { :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' }
+          { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' }
         ]
         expect(@s.groupings.first.children_name_eq).to eq 'Ernie'
       end