ransack 1.7.0 → 1.8.0

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

@@ -9,11 +9,11 @@ module Ransack
       describe Context do
         subject { Context.new(Person) }
 
-        if AR_version >= '3.1'
-          it 'has an Active Record alias tracker method' do
-            expect(subject.alias_tracker)
-            .to be_an ::ActiveRecord::Associations::AliasTracker
-          end
+
+        it 'has an Active Record alias tracker method',
+        if: AR_version >= '3.1' do
+          expect(subject.alias_tracker)
+          .to be_an ::ActiveRecord::Associations::AliasTracker
         end
 
         describe '#relation_for' do
@@ -24,8 +24,8 @@ module Ransack
 
         describe '#evaluate' do
           it 'evaluates search objects' do
-            search = Search.new(Person, :name_eq => 'Joe Blow')
-            result = subject.evaluate(search)
+            s = Search.new(Person, name_eq: 'Joe Blow')
+            result = subject.evaluate(s)
 
             expect(result).to be_an ::ActiveRecord::Relation
             expect(result.to_sql)
@@ -33,25 +33,25 @@ module Ransack
           end
 
           it 'SELECTs DISTINCT when distinct: true' do
-            search = Search.new(Person, :name_eq => 'Joe Blow')
-            result = subject.evaluate(search, :distinct => true)
+            s = Search.new(Person, name_eq: 'Joe Blow')
+            result = subject.evaluate(s, distinct: true)
 
             expect(result).to be_an ::ActiveRecord::Relation
             expect(result.to_sql).to match /SELECT DISTINCT/
           end
         end
 
-        describe "sharing context across searches" do
+        describe 'sharing context across searches' do
           let(:shared_context) { Context.for(Person) }
 
           before do
-            Search.new(Person, { :parent_name_eq => 'A' },
+            Search.new(Person, { parent_name_eq: 'A' },
               context: shared_context)
-            Search.new(Person, { :children_name_eq => 'B' },
+            Search.new(Person, { children_name_eq: 'B' },
               context: shared_context)
           end
 
-          describe '#join_associations', :if => AR_version <= '4.0' do
+          describe '#join_associations', if: AR_version <= '4.0' do
             it 'returns dependent join associations for all searches run
                 against the context' do
               parents, children = shared_context.join_associations
@@ -69,18 +69,16 @@ module Ransack
           end
 
           describe '#join_sources' do
-            # FIXME: fix this test for Rails 4.2.
+            # FIXME: fix this test for Rails 4.2 and 5.0.
             it 'returns dependent arel join nodes for all searches run against
-            the context',
-            :if => %w(3.1 3.2 4.0 4.1).include?(AR_version) do
+            the context', if: %w(3.1 3.2 4.0 4.1).include?(AR_version) do
               parents, children = shared_context.join_sources
-
               expect(children.left.name).to eq "children_people"
               expect(parents.left.name).to eq "parents_people"
             end
 
             it 'can be rejoined to execute a valid query',
-            :if => AR_version >= '3.1' do
+            if: AR_version >= '3.1' do
               parents, children = shared_context.join_sources
 
               expect { Person.joins(parents).joins(children).to_a }

data/spec/ransack/helpers/form_builder_spec.rb

@@ -7,7 +7,6 @@ module Ransack
       router = ActionDispatch::Routing::RouteSet.new
       router.draw do
         resources :people, :comments, :notes
-        get ':controller(/:action(/:id(.:format)))'
       end
 
       include router.url_helpers
@@ -22,7 +21,11 @@ module Ransack
         @controller.view_context.search_form_for(@s) { |f| @f = f }
       end
 
-      it 'selects previously-entered time values with datetime_select' do
+      it 'selects previously-entered time values with datetime_select',
+        unless: (
+          RUBY_VERSION >= '2.3' &&
+          ::ActiveRecord::VERSION::STRING.first(3) < '3.2'
+          ) do
         date_values = %w(2011 1 2 03 04 05)
       # @s.created_at_eq = date_values # This works in Rails 4.x but not 3.x
         @s.created_at_eq = [2011, 1, 2, 3, 4, 5] # so we have to do this

data/spec/ransack/helpers/form_helper_spec.rb

@@ -10,7 +10,6 @@ module Ransack
         namespace :admin do
           resources :comments
         end
-        get ':controller(/:action(/:id(.:format)))'
       end
 
       include router.url_helpers
@@ -19,13 +18,8 @@ module Ransack
       before do
         @controller = ActionView::TestCase::TestController.new
         @controller.instance_variable_set(:@_routes, router)
-        @controller.class_eval do
-          include router.url_helpers
-        end
-
-        @controller.view_context_class.class_eval do
-          include router.url_helpers
-        end
+        @controller.class_eval { include router.url_helpers }
+        @controller.view_context_class.class_eval { include router.url_helpers }
       end
 
       describe '#sort_link with default search_key' do
@@ -316,12 +310,13 @@ module Ransack
       end
 
       context 'view has existing parameters' do
-        before do
-          @controller.view_context.params.merge!({ exist: 'existing' })
-        end
+
         describe '#sort_link should not remove existing params' do
-          subject { @controller.view_context
-            .sort_link(
+
+          before { @controller.view_context.params[:exist] = 'existing' }
+
+          subject {
+            @controller.view_context.sort_link(
               Person.search(
                 { sorts: ['name desc'] },
                 search_key: 'people_search'
@@ -330,8 +325,44 @@ module Ransack
               controller: 'people'
             )
           }
+
           it { should match /exist\=existing/ }
         end
+
+        context 'using a real ActionController::Parameter object',
+          if: ::ActiveRecord::VERSION::MAJOR > 3 do
+
+          describe 'with symbol q:, #sort_link should include search params' do
+            subject { @controller.view_context.sort_link(Person.search, :name) }
+            let(:params) { ActionController::Parameters.new(
+              { :q => { name_eq: 'TEST' }, controller: 'people' }
+              ) }
+            before { @controller.instance_variable_set(:@params, params) }
+
+            it {
+              should match(
+                /people\?q(%5B|\[)name_eq(%5D|\])=TEST&q(%5B|\[)s(%5D|\])
+                =name\+asc/x,
+              )
+            }
+          end
+
+          describe "with string 'q', #sort_link should include search params" do
+            subject { @controller.view_context.sort_link(Person.search, :name) }
+            let(:params) {
+              ActionController::Parameters.new(
+                { 'q' => { name_eq: 'Test2' }, controller: 'people' }
+                ) }
+            before { @controller.instance_variable_set(:@params, params) }
+
+            it {
+              should match(
+                /people\?q(%5B|\[)name_eq(%5D|\])=Test2&q(%5B|\[)s(%5D|\])
+                =name\+asc/x,
+              )
+            }
+          end
+        end
       end
 
       describe '#sort_link with hide order indicator set to true' do
@@ -344,6 +375,7 @@ module Ransack
           )
         }
         it { should match /Full Name/ }
+        it { should_not match /▼|▲/ }
       end
 
       describe '#sort_link with hide order indicator set to false' do
@@ -358,6 +390,45 @@ module Ransack
         it { should match /Full Name ▼/ }
       end
 
+      describe '#sort_link with config set to globally hide order indicators' do
+        before do
+          Ransack.configure { |c| c.hide_sort_order_indicators = true }
+        end
+        subject { @controller.view_context
+          .sort_link(
+            [:main_app, Person.search(sorts: ['name desc'])],
+            :name,
+            controller: 'people'
+          )
+        }
+        it { should_not match /▼|▲/ }
+      end
+
+      describe '#sort_link with config set to globally show order indicators' do
+        before do
+          Ransack.configure { |c| c.hide_sort_order_indicators = false }
+        end
+        subject { @controller.view_context
+          .sort_link(
+            [:main_app, Person.search(sorts: ['name desc'])],
+            :name,
+            controller: 'people'
+          )
+        }
+        it { should match /Full Name ▼/ }
+      end
+
+      describe '#sort_link with a block' do
+        subject { @controller.view_context
+          .sort_link(
+            [:main_app, Person.search(sorts: ['name desc'])],
+            :name,
+            controller: 'people'
+          ) { 'Block label' }
+        }
+        it { should match /Block label ▼/ }
+      end
+
       describe '#search_form_for with default format' do
         subject { @controller.view_context
           .search_form_for(Person.search) {} }
@@ -398,7 +469,6 @@ module Ransack
         }
         it { should match /example_name_eq/ }
       end
-
     end
   end
 end

data/spec/ransack/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(
@@ -14,6 +29,15 @@ module Ransack
         specify { expect(subject.values.size).to eq(2) }
       end
 
+      describe '#negative?' do
+        let(:context) { Context.for(Person) }
+        let(:eq)      { Condition.extract(context, 'name_eq', 'A') }
+        let(:not_eq)  { Condition.extract(context, 'name_not_eq', 'A') }
+
+        specify { expect(not_eq.negative?).to be true }
+        specify { expect(eq.negative?).to be false }
+      end
+
       context 'with an invalid predicate' do
         subject {
           Condition.extract(

data/spec/ransack/nodes/grouping_spec.rb

@@ -50,6 +50,62 @@ module Ransack
         end
       end
 
+      describe '#conditions=' do
+        context 'when conditions are identical' do
+          let(:conditions) do
+            {
+              '0' => {
+                'a' => { '0'=> { 'name' => 'name', 'ransacker_args' => '' } },
+                'p' => 'cont',
+                'v' => { '0' => { 'value' => 'John' } }
+              },
+              '1' => {
+                'a' => { '0' => { 'name' => 'name', 'ransacker_args' => '' } },
+                'p' => 'cont',
+                'v' => { '0' => { 'value' => 'John' } }
+              }
+            }
+          end
+          before { subject.conditions = conditions }
+
+          it 'expect duplicates to be removed' do
+            expect(subject.conditions.count).to eq 1
+          end
+        end
+
+        context 'when conditions differ only by ransacker_args' do
+          let(:conditions) do
+            {
+              '0' => {
+                'a' => {
+                  '0' => {
+                    'name' => 'with_arguments',
+                    'ransacker_args' => [1,2]
+                  }
+                },
+                'p' => 'eq',
+                'v' => { '0' => { 'value' => '10' } }
+              },
+              '1' => {
+                'a' => {
+                  '0' => {
+                    'name' => 'with_arguments',
+                    'ransacker_args' => [3,4]
+                  }
+                },
+                'p' => 'eq',
+                'v' => { '0' => { 'value' => '10' } }
+              }
+            }
+          end
+          before { subject.conditions = conditions }
+
+          it 'expect them to be parsed as different and not as duplicates' do
+            expect(subject.conditions.count).to eq 2
+          end
+        end
+      end
+
     end
   end
 end

data/spec/ransack/predicate_spec.rb

@@ -16,7 +16,7 @@ module Ransack
         expect { subject.result }.to_not raise_error
       end
 
-      it "escapes '%', '.' and '\\\\' in value" do
+      it "escapes '%', '.', '_' and '\\\\' in value" do
         subject.send(:"#{method}=", '%._\\')
         expect(subject.result.to_sql).to match(regexp)
       end
@@ -124,9 +124,9 @@ module Ransack
     describe 'cont' do
       it_has_behavior 'wildcard escaping', :name_cont,
         (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
-          /"people"."name" ILIKE '%\\%\\._\\\\%'/
+          /"people"."name" ILIKE '%\\%\\.\\_\\\\%'/
         elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
-          /`people`.`name` LIKE '%\\\\%\\\\._\\\\\\\\%'/
+          /`people`.`name` LIKE '%\\\\%\\\\.\\\\_\\\\\\\\%'/
         else
          /"people"."name" LIKE '%%._\\%'/
         end) do
@@ -143,9 +143,9 @@ module Ransack
     describe 'not_cont' do
       it_has_behavior 'wildcard escaping', :name_not_cont,
         (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
-          /"people"."name" NOT ILIKE '%\\%\\._\\\\%'/
+          /"people"."name" NOT ILIKE '%\\%\\.\\_\\\\%'/
         elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
-          /`people`.`name` NOT LIKE '%\\\\%\\\\._\\\\\\\\%'/
+          /`people`.`name` NOT LIKE '%\\\\%\\\\.\\\\_\\\\\\\\%'/
         else
          /"people"."name" NOT LIKE '%%._\\%'/
         end) do

data/spec/ransack/search_spec.rb

@@ -43,16 +43,16 @@ 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)
-        expect(search1.context).to be search2.context
+        s1 = Search.new(Person, { name_eq: 'A' }, context: shared_context)
+        s2 = Search.new(Person, { name_eq: 'B' }, context: shared_context)
+        expect(s1.context).to be s2.context
       end
     end
 
     describe '#build' do
       it 'creates conditions for top-level attributes' do
-        search = Search.new(Person, name_eq: 'Ernie')
-        condition = search.base[:name_eq]
+        s = Search.new(Person, name_eq: 'Ernie')
+        condition = s.base[:name_eq]
         expect(condition).to be_a Nodes::Condition
         expect(condition.predicate.name).to eq 'eq'
         expect(condition.attributes.first.name).to eq 'name'
@@ -60,8 +60,8 @@ module Ransack
       end
 
       it 'creates conditions for association attributes' do
-        search = Search.new(Person, children_name_eq: 'Ernie')
-        condition = search.base[:children_name_eq]
+        s = Search.new(Person, children_name_eq: 'Ernie')
+        condition = s.base[:children_name_eq]
         expect(condition).to be_a Nodes::Condition
         expect(condition.predicate.name).to eq 'eq'
         expect(condition.attributes.first.name).to eq 'children_name'
@@ -69,8 +69,8 @@ module Ransack
       end
 
       it 'creates conditions for polymorphic belongs_to association attributes' do
-        search = Search.new(Note, notable_of_Person_type_name_eq: 'Ernie')
-        condition = search.base[:notable_of_Person_type_name_eq]
+        s = Search.new(Note, notable_of_Person_type_name_eq: 'Ernie')
+        condition = s.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)
@@ -80,9 +80,9 @@ module Ransack
 
       it 'creates conditions for multiple polymorphic belongs_to association
         attributes' do
-        search = Search.new(Note,
+        s = Search.new(Note,
           notable_of_Person_type_name_or_notable_of_Article_type_title_eq: 'Ernie')
-        condition = search.
+        condition = s.
           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'
@@ -93,15 +93,25 @@ module Ransack
         expect(condition.value).to eq 'Ernie'
       end
 
+      it 'creates conditions for aliased attributes',
+      if: Ransack::SUPPORTS_ATTRIBUTE_ALIAS do
+        s = Search.new(Person, full_name_eq: 'Ernie')
+        condition = s.base[:full_name_eq]
+        expect(condition).to be_a Nodes::Condition
+        expect(condition.predicate.name).to eq 'eq'
+        expect(condition.attributes.first.name).to eq 'full_name'
+        expect(condition.value).to eq 'Ernie'
+      end
+
       it 'preserves default scope and conditions for associations' do
-        search = Search.new(Person, published_articles_title_eq: 'Test')
-        expect(search.result.to_sql).to include 'default_scope'
-        expect(search.result.to_sql).to include 'published'
+        s = Search.new(Person, published_articles_title_eq: 'Test')
+        expect(s.result.to_sql).to include 'default_scope'
+        expect(s.result.to_sql).to include 'published'
       end
 
       it 'discards empty conditions' do
-        search = Search.new(Person, children_name_eq: '')
-        condition = search.base[:children_name_eq]
+        s = Search.new(Person, children_name_eq: '')
+        condition = s.base[:children_name_eq]
         expect(condition).to be_nil
       end
 
@@ -111,13 +121,13 @@ module Ransack
       end
 
       it 'accepts arrays of groupings' do
-        search = Search.new(Person,
+        s = Search.new(Person,
           g: [
             { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
             { m: 'or', name_eq: 'Bert', children_name_eq: 'Bert' },
           ]
         )
-        ors = search.groupings
+        ors = s.groupings
         expect(ors.size).to eq(2)
         or1, or2 = ors
         expect(or1).to be_a Nodes::Grouping
@@ -126,14 +136,14 @@ module Ransack
         expect(or2.combinator).to eq 'or'
       end
 
-      it 'accepts "attributes" hashes for groupings' do
-        search = Search.new(Person,
+      it 'accepts attributes hashes for groupings' do
+        s = Search.new(Person,
           g: {
             '0' => { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
             '1' => { m: 'or', name_eq: 'Bert',  children_name_eq: 'Bert' },
           }
         )
-        ors = search.groupings
+        ors = s.groupings
         expect(ors.size).to eq(2)
         or1, or2 = ors
         expect(or1).to be_a Nodes::Grouping
@@ -142,8 +152,8 @@ module Ransack
         expect(or2.combinator).to eq 'or'
       end
 
-      it 'accepts "attributes" hashes for conditions' do
-        search = Search.new(Person,
+      it 'accepts attributes hashes for conditions' do
+        s = Search.new(Person,
           c: {
             '0' => { a: ['name'], p: 'eq', v: ['Ernie'] },
             '1' => {
@@ -152,7 +162,7 @@ module Ransack
                    }
           }
         )
-        conditions = search.base.conditions
+        conditions = s.base.conditions
         expect(conditions.size).to eq(2)
         expect(conditions.map { |c| c.class })
         .to eq [Nodes::Condition, Nodes::Condition]
@@ -163,8 +173,8 @@ module Ransack
           config.add_predicate 'ary_pred', wants_array: true
         end
 
-        search = Search.new(Person, name_ary_pred: ['Ernie', 'Bert'])
-        condition = search.base[:name_ary_pred]
+        s = Search.new(Person, name_ary_pred: ['Ernie', 'Bert'])
+        condition = s.base[:name_ary_pred]
         expect(condition).to be_a Nodes::Condition
         expect(condition.predicate.name).to eq 'ary_pred'
         expect(condition.attributes.first.name).to eq 'name'
@@ -172,8 +182,8 @@ module Ransack
       end
 
       it 'does not evaluate the query on #inspect' do
-        search = Search.new(Person, children_id_in: [1, 2, 3])
-        expect(search.inspect).not_to match /ActiveRecord/
+        s = Search.new(Person, children_id_in: [1, 2, 3])
+        expect(s.inspect).not_to match /ActiveRecord/
       end
 
       context 'with an invalid condition' do
@@ -211,9 +221,9 @@ module Ransack
         "#{quote_table_name("children_people")}.#{quote_column_name("name")}"
       }
       it 'evaluates conditions contextually' do
-        search = Search.new(Person, children_name_eq: 'Ernie')
-        expect(search.result).to be_an ActiveRecord::Relation
-        expect(search.result.to_sql).to match /#{
+        s = Search.new(Person, children_name_eq: 'Ernie')
+        expect(s.result).to be_an ActiveRecord::Relation
+        expect(s.result.to_sql).to match /#{
           children_people_name_field} = 'Ernie'/
       end
 
@@ -221,51 +231,50 @@ module Ransack
       # 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
+      it 'evaluates conditions for multiple `belongs_to` associations to the
+      same table contextually',
+      if: ::ActiveRecord::VERSION::STRING.first(3) == '4.0' 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
 
       it 'evaluates compound conditions contextually' do
-        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
+        s = Search.new(Person, children_name_or_name_eq: 'Ernie').result
+        expect(s).to be_an ActiveRecord::Relation
+        expect(s.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')
-        .result
-        expect(search).to be_an ActiveRecord::Relation
-        expect(search.to_sql).to match /#{people_name_field} = 'Ernie'/
+        s = Search.new(Note, notable_of_Person_type_name_eq: 'Ernie').result
+        expect(s).to be_an ActiveRecord::Relation
+        expect(s.to_sql).to match /#{people_name_field} = 'Ernie'/
       end
 
       it 'evaluates nested conditions' do
-        search = Search.new(Person, children_name_eq: 'Ernie',
+        s = Search.new(Person, children_name_eq: 'Ernie',
           g: [
             { m: 'or', name_eq: 'Ernie', children_children_name_eq: 'Ernie' }
           ]
         ).result
-        expect(search).to be_an ActiveRecord::Relation
-        first, last = search.to_sql.split(/ AND /)
+        expect(s).to be_an ActiveRecord::Relation
+        first, last = s.to_sql.split(/ AND /)
         expect(first).to match /#{children_people_name_field} = 'Ernie'/
         expect(last).to match /#{
           people_name_field} = 'Ernie' OR #{
@@ -274,14 +283,14 @@ module Ransack
       end
 
       it 'evaluates arrays of groupings' do
-        search = Search.new(Person,
+        s = Search.new(Person,
           g: [
             { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
             { m: 'or', name_eq: 'Bert', children_name_eq: 'Bert' }
           ]
         ).result
-        expect(search).to be_an ActiveRecord::Relation
-        first, last = search.to_sql.split(/ AND /)
+        expect(s).to be_an ActiveRecord::Relation
+        first, last = s.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 #{
@@ -289,7 +298,7 @@ module Ransack
       end
 
       it 'returns distinct records when passed distinct: true' do
-        search = Search.new(Person,
+        s = Search.new(Person,
           g: [
             { m: 'or', comments_body_cont: 'e', articles_comments_body_cont: 'e' }
           ]
@@ -299,12 +308,12 @@ module Ransack
         else
           all_or_load, uniq_or_distinct = :load, :distinct
         end
-        expect(search.result.send(all_or_load).size)
+        expect(s.result.send(all_or_load).size)
         .to eq(9000)
-        expect(search.result(distinct: true).size)
+        expect(s.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)
+        expect(s.result.send(all_or_load).send(uniq_or_distinct))
+        .to eq s.result(distinct: true).send(all_or_load)
       end
 
       private