ransack 2.3.0 → 4.1.0

data/spec/ransack/search_spec.rb

@@ -20,6 +20,44 @@ module Ransack
         Search.new(Person, name_eq: 'foobar')
       end
 
+      context 'whitespace stripping' do
+        context 'when whitespace_strip option is true' do
+          before do
+            Ransack.configure { |c| c.strip_whitespace = true }
+          end
+
+          it 'strips leading & trailing whitespace before building' do
+            expect_any_instance_of(Search).to receive(:build)
+            .with({ 'name_eq' => 'foobar' })
+            Search.new(Person, name_eq: '   foobar     ')
+          end
+        end
+
+        context 'when whitespace_strip option is false' do
+          before do
+            Ransack.configure { |c| c.strip_whitespace = false }
+          end
+
+          it 'doesn\'t strip leading & trailing whitespace before building' do
+            expect_any_instance_of(Search).to receive(:build)
+            .with({ 'name_eq' => '   foobar     ' })
+            Search.new(Person, name_eq: '   foobar     ')
+          end
+        end
+
+        it 'strips leading & trailing whitespace when strip_whitespace search parameter is true' do
+          expect_any_instance_of(Search).to receive(:build)
+          .with({ 'name_eq' => 'foobar' })
+          Search.new(Person, { name_eq: '   foobar     ' }, { strip_whitespace: true })
+        end
+
+        it 'doesn\'t strip leading & trailing whitespace when strip_whitespace search parameter is false' do
+          expect_any_instance_of(Search).to receive(:build)
+          .with({ 'name_eq' => '   foobar     ' })
+          Search.new(Person, { name_eq: '   foobar     ' }, { strip_whitespace: false })
+        end
+      end
+
       it 'removes empty suffixed conditions before building' do
         expect_any_instance_of(Search).to receive(:build).with({})
         Search.new(Person, name_eq_any: [''])
@@ -109,6 +147,43 @@ module Ransack
         expect(s.result.to_sql).to include 'published'
       end
 
+      # The failure/oversight in Ransack::Nodes::Condition#arel_predicate or deeper is beyond my understanding of the structures
+      it 'preserves (inverts) default scope and conditions for negative subqueries' do
+        # the positive case (published_articles_title_eq) is
+        # SELECT "people".* FROM "people"
+        # LEFT OUTER JOIN "articles" ON "articles"."person_id" = "people"."id"
+        #   AND "articles"."published" = 't'
+        #   AND ('default_scope' = 'default_scope')
+        # WHERE "articles"."title" = 'Test' ORDER BY "people"."id" DESC
+        #
+        # negative case was
+        # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
+        #   SELECT "articles"."person_id" FROM "articles"
+        #   WHERE "articles"."person_id" = "people"."id"
+        #     AND NOT ("articles"."title" != 'Test')
+        # ) ORDER BY "people"."id" DESC
+        #
+        # Should have been like
+        # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
+        #   SELECT "articles"."person_id" FROM "articles"
+        #   WHERE "articles"."person_id" = "people"."id"
+        #     AND "articles"."title" = 'Test' AND "articles"."published" = 't' AND ('default_scope' = 'default_scope')
+        # ) ORDER BY "people"."id" DESC
+        #
+        # With tenanting (eg default_scope with column reference), NOT IN should be like
+        # SELECT "people".* FROM "people" WHERE "people"."tenant_id" = 'tenant_id' AND "people"."id" NOT IN (
+        #   SELECT "articles"."person_id" FROM "articles"
+        #   WHERE "articles"."person_id" = "people"."id"
+        #     AND "articles"."tenant_id" = 'tenant_id'
+        #     AND "articles"."title" = 'Test' AND "articles"."published" = 't' AND ('default_scope' = 'default_scope')
+        # ) ORDER BY "people"."id" DESC
+
+        pending("spec should pass, but I do not know how/where to fix lib code")
+        s = Search.new(Person, published_articles_title_not_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
         s = Search.new(Person, children_name_eq: '')
         condition = s.base[:children_name_eq]
@@ -189,7 +264,7 @@ module Ransack
       context 'with an invalid condition' do
         subject { Search.new(Person, unknown_attr_eq: 'Ernie') }
 
-        context 'when ignore_unknown_conditions is false' do
+        context 'when ignore_unknown_conditions configuration option is false' do
           before do
             Ransack.configure { |c| c.ignore_unknown_conditions = false }
           end
@@ -197,13 +272,39 @@ module Ransack
           specify { expect { subject }.to raise_error ArgumentError }
         end
 
-        context 'when ignore_unknown_conditions is true' do
+        context 'when ignore_unknown_conditions configuration option is true' do
           before do
             Ransack.configure { |c| c.ignore_unknown_conditions = true }
           end
 
           specify { expect { subject }.not_to raise_error }
         end
+
+        subject(:with_ignore_unknown_conditions_false) {
+          Search.new(Person,
+            { unknown_attr_eq: 'Ernie' },
+            { ignore_unknown_conditions: false }
+          )
+        }
+
+        subject(:with_ignore_unknown_conditions_true) {
+          Search.new(Person,
+            { unknown_attr_eq: 'Ernie' },
+            { ignore_unknown_conditions: true }
+          )
+        }
+
+        context 'when ignore_unknown_conditions search parameter is absent' do
+          specify { expect { subject }.not_to raise_error }
+        end
+
+        context 'when ignore_unknown_conditions search parameter is false' do
+          specify { expect { with_ignore_unknown_conditions_false }.to raise_error ArgumentError }
+        end
+
+        context 'when ignore_unknown_conditions search parameter is true' do
+          specify { expect { with_ignore_unknown_conditions_true }.not_to raise_error }
+        end
       end
 
       it 'does not modify the parameters' do
@@ -211,6 +312,29 @@ module Ransack
         expect { Search.new(Person, params) }.not_to change { params }
       end
 
+      context "ransackable_scope" do
+        around(:each) do |example|
+          Person.define_singleton_method(:name_eq) do |name|
+            self.where(name: name)
+          end
+
+          begin
+            example.run
+          ensure
+            Person.singleton_class.undef_method :name_eq
+          end
+        end
+
+        it "is prioritized over base predicates" do
+          allow(Person).to receive(:ransackable_scopes)
+            .and_return(Person.ransackable_scopes + [:name_eq])
+
+          s = Search.new(Person, name_eq: "Johny")
+          expect(s.instance_variable_get(:@scope_args)["name_eq"]).to eq("Johny")
+          expect(s.base[:name_eq]).to be_nil
+        end
+      end
+
     end
 
     describe '#result' do
@@ -220,6 +344,9 @@ module Ransack
       let(:children_people_name_field) {
         "#{quote_table_name("children_people")}.#{quote_column_name("name")}"
       }
+      let(:notable_type_field) {
+        "#{quote_table_name("notes")}.#{quote_column_name("notable_type")}"
+      }
       it 'evaluates conditions contextually' do
         s = Search.new(Person, children_name_eq: 'Ernie')
         expect(s.result).to be_an ActiveRecord::Relation
@@ -228,19 +355,20 @@ module Ransack
       end
 
       it 'use appropriate table alias' do
-        skip "Make this spec pass for Rails <5.2" if ::ActiveRecord::VERSION::STRING < '5.2.0'
         s = Search.new(Person, {
           name_eq: "person_name_query",
           articles_title_eq: "person_article_title_query",
           parent_name_eq: "parent_name_query",
           parent_articles_title_eq: 'parents_article_title_query'
         }).result
+
         real_query = remove_quotes_and_backticks(s.to_sql)
 
         expect(real_query)
-          .to match(%r{LEFT OUTER JOIN articles ON (\('default_scope' = 'default_scope'\) AND )?articles.person_id = people.id})
+                .to match(%r{LEFT OUTER JOIN articles ON (\('default_scope' = 'default_scope'\) AND )?articles.person_id = people.id})
         expect(real_query)
-          .to match(%r{LEFT OUTER JOIN articles articles_people ON (\('default_scope' = 'default_scope'\) AND )?articles_people.person_id = parents_people.id})
+                .to match(%r{LEFT OUTER JOIN articles articles_people ON (\('default_scope' = 'default_scope'\) AND )?articles_people.person_id = parents_people.id})
+
         expect(real_query)
           .to include "people.name = 'person_name_query'"
         expect(real_query)
@@ -251,13 +379,7 @@ module Ransack
           .to include "articles_people.title = 'parents_article_title_query'"
       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
-      #
-      it 'evaluates conditions for multiple `belongs_to` associations to the
-      same table contextually' do
-        skip "Make this spec pass for Rails <5.2" if ::ActiveRecord::VERSION::STRING < '5.2.0'
+      it 'evaluates conditions for multiple `belongs_to` associations to the same table contextually' do
         s = Search.new(
           Recommendation,
           person_name_eq: 'Ernie',
@@ -289,6 +411,7 @@ module Ransack
         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'/
+        expect(s.to_sql).to match /#{notable_type_field} = 'Person'/
       end
 
       it 'evaluates nested conditions' do
@@ -327,11 +450,8 @@ module Ransack
             { m: 'or', comments_body_cont: 'e', articles_comments_body_cont: 'e' }
           ]
         )
-        if ActiveRecord::VERSION::MAJOR == 3
-          all_or_load, uniq_or_distinct = :all, :uniq
-        else
-          all_or_load, uniq_or_distinct = :load, :distinct
-        end
+
+        all_or_load, uniq_or_distinct = :load, :distinct
         expect(s.result.send(all_or_load).size)
         .to eq(9000)
         expect(s.result(distinct: true).size)
@@ -384,88 +504,169 @@ module Ransack
         expect(sort.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes/directions in array format' do
-        @s.sorts = ['id desc', { name: 'name', dir: 'asc' }]
+      it 'creates sorts based on a single alias/direction' do
+        @s.sorts = 'daddy desc'
+        expect(@s.sorts.size).to eq(1)
+        sort = @s.sorts.first
+        expect(sort).to be_a Nodes::Sort
+        expect(sort.name).to eq 'parent_name'
+        expect(sort.dir).to eq 'desc'
+      end
+
+      it 'creates sorts based on a single alias and uppercase direction' do
+        @s.sorts = 'daddy DESC'
+        expect(@s.sorts.size).to eq(1)
+        sort = @s.sorts.first
+        expect(sort).to be_a Nodes::Sort
+        expect(sort.name).to eq 'parent_name'
+        expect(sort.dir).to eq 'desc'
+      end
+
+      it 'creates sorts based on a single alias and without direction' do
+        @s.sorts = 'daddy'
+        expect(@s.sorts.size).to eq(1)
+        sort = @s.sorts.first
+        expect(sort).to be_a Nodes::Sort
+        expect(sort.name).to eq 'parent_name'
+        expect(sort.dir).to eq 'asc'
+      end
+
+      it 'creates sorts based on attributes, alias and directions in array format' do
+        @s.sorts = ['id desc', { name: 'daddy', dir: 'asc' }]
         expect(@s.sorts.size).to eq(2)
         sort1, sort2 = @s.sorts
         expect(sort1).to be_a Nodes::Sort
         expect(sort1.name).to eq 'id'
         expect(sort1.dir).to eq 'desc'
         expect(sort2).to be_a Nodes::Sort
-        expect(sort2.name).to eq 'name'
+        expect(sort2.name).to eq 'parent_name'
         expect(sort2.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and uppercase directions in array format' do
-        @s.sorts = ['id DESC', { name: 'name', dir: 'ASC' }]
+      it 'creates sorts based on attributes, alias and uppercase directions in array format' do
+        @s.sorts = ['id DESC', { name: 'daddy', dir: 'ASC' }]
         expect(@s.sorts.size).to eq(2)
         sort1, sort2 = @s.sorts
         expect(sort1).to be_a Nodes::Sort
         expect(sort1.name).to eq 'id'
         expect(sort1.dir).to eq 'desc'
         expect(sort2).to be_a Nodes::Sort
-        expect(sort2.name).to eq 'name'
+        expect(sort2.name).to eq 'parent_name'
         expect(sort2.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and different directions
+      it 'creates sorts based on attributes, alias and different directions
         in array format' do
-        @s.sorts = ['id DESC', { name: 'name', dir: nil }]
+        @s.sorts = ['id DESC', { name: 'daddy', dir: nil }]
         expect(@s.sorts.size).to eq(2)
         sort1, sort2 = @s.sorts
         expect(sort1).to be_a Nodes::Sort
         expect(sort1.name).to eq 'id'
         expect(sort1.dir).to eq 'desc'
         expect(sort2).to be_a Nodes::Sort
-        expect(sort2.name).to eq 'name'
+        expect(sort2.name).to eq 'parent_name'
         expect(sort2.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes/directions in hash format' do
+      it 'creates sorts based on attributes, alias and directions in hash format' do
         @s.sorts = {
           '0' => { name: 'id', dir: 'desc' },
-          '1' => { name: 'name', dir: 'asc' }
+          '1' => { name: 'daddy', dir: 'asc' }
         }
         expect(@s.sorts.size).to eq(2)
         expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
         id_sort = @s.sorts.detect { |s| s.name == 'id' }
-        name_sort = @s.sorts.detect { |s| s.name == 'name' }
+        daddy_sort = @s.sorts.detect { |s| s.name == 'parent_name' }
         expect(id_sort.dir).to eq 'desc'
-        expect(name_sort.dir).to eq 'asc'
+        expect(daddy_sort.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and uppercase directions
+      it 'creates sorts based on attributes, alias and uppercase directions
         in hash format' do
         @s.sorts = {
           '0' => { name: 'id', dir: 'DESC' },
-          '1' => { name: 'name', dir: 'ASC' }
+          '1' => { name: 'daddy', dir: 'ASC' }
         }
         expect(@s.sorts.size).to eq(2)
         expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
         id_sort = @s.sorts.detect { |s| s.name == 'id' }
-        name_sort = @s.sorts.detect { |s| s.name == 'name' }
+        daddy_sort = @s.sorts.detect { |s| s.name == 'parent_name' }
         expect(id_sort.dir).to eq 'desc'
-        expect(name_sort.dir).to eq 'asc'
+        expect(daddy_sort.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and different directions
+      it 'creates sorts based on attributes, alias and different directions
         in hash format' do
         @s.sorts = {
           '0' => { name: 'id', dir: 'DESC' },
-          '1' => { name: 'name', dir: nil }
+          '1' => { name: 'daddy', dir: nil }
         }
         expect(@s.sorts.size).to eq(2)
         expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
         id_sort = @s.sorts.detect { |s| s.name == 'id' }
-        name_sort = @s.sorts.detect { |s| s.name == 'name' }
+        daddy_sort = @s.sorts.detect { |s| s.name == 'parent_name' }
         expect(id_sort.dir).to eq 'desc'
-        expect(name_sort.dir).to eq 'asc'
+        expect(daddy_sort.dir).to eq 'asc'
       end
 
       it 'overrides existing sort' do
         @s.sorts = 'id asc'
         expect(@s.result.first.id).to eq 1
       end
+
+      it "PG's sort option", if: ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" do
+        default = Ransack.options.clone
+
+        s = Search.new(Person, s: 'name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" ASC"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_first }
+        s = Search.new(Person, s: 'name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" ASC NULLS FIRST"
+        s = Search.new(Person, s: 'name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" DESC NULLS LAST"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_last }
+        s = Search.new(Person, s: 'name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" ASC NULLS LAST"
+        s = Search.new(Person, s: 'name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" DESC NULLS FIRST"
+
+        Ransack.options = default
+      end
+
+      it "PG's sort option with double name", if: ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" do
+        default = Ransack.options.clone
+
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_first }
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC NULLS FIRST"
+        s = Search.new(Person, s: 'doubled_name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" DESC NULLS LAST"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_last }
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC NULLS LAST"
+        s = Search.new(Person, s: 'doubled_name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" DESC NULLS FIRST"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_always_first }
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC NULLS FIRST"
+        s = Search.new(Person, s: 'doubled_name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" DESC NULLS FIRST"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_always_last }
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC NULLS LAST"
+        s = Search.new(Person, s: 'doubled_name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" DESC NULLS LAST"
+
+        Ransack.options = default
+      end
     end
 
     describe '#method_missing' do

data/spec/ransack/translate_spec.rb

@@ -8,7 +8,7 @@ module Ransack
         ar_translation = ::Namespace::Article.human_attribute_name(:title)
         ransack_translation = Ransack::Translate.attribute(
           :title,
-          :context => ::Namespace::Article.ransack.context
+          context: ::Namespace::Article.ransack.context
           )
         expect(ransack_translation).to eq ar_translation
       end

data/spec/spec_helper.rb

@@ -1,7 +1,10 @@
 require 'machinist/active_record'
+require 'polyamorous/polyamorous'
 require 'sham'
 require 'faker'
 require 'ransack'
+require 'action_controller'
+require 'ransack/helpers'
 require 'pry'
 require 'simplecov'
 require 'byebug'
@@ -14,16 +17,17 @@ I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'support', '*.yml')]
 Dir[File.expand_path('../{helpers,support,blueprints}/*.rb', __FILE__)]
 .each { |f| require f }
 
+Faker::Config.random = Random.new(0)
 Sham.define do
   name        { Faker::Name.name }
   title       { Faker::Lorem.sentence }
   body        { Faker::Lorem.paragraph }
   salary      { |index| 30000 + (index * 1000) }
-  tag_name    { Faker::Lorem.words(3).join(' ') }
-  note        { Faker::Lorem.words(7).join(' ') }
-  only_admin  { Faker::Lorem.words(3).join(' ') }
-  only_search { Faker::Lorem.words(3).join(' ') }
-  only_sort   { Faker::Lorem.words(3).join(' ') }
+  tag_name    { Faker::Lorem.words(number: 3).join(' ') }
+  note        { Faker::Lorem.words(number: 7).join(' ') }
+  only_admin  { Faker::Lorem.words(number: 3).join(' ') }
+  only_search { Faker::Lorem.words(number: 3).join(' ') }
+  only_sort   { Faker::Lorem.words(number: 3).join(' ') }
   notable_id  { |id| id }
 end