ransack 1.7.0 → 2.4.1

data/spec/ransack/search_spec.rb

@@ -20,6 +20,12 @@ module Ransack
         Search.new(Person, name_eq: 'foobar')
       end
 
+      it '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
+
       it 'removes empty suffixed conditions before building' do
         expect_any_instance_of(Search).to receive(:build).with({})
         Search.new(Person, name_eq_any: [''])
@@ -43,16 +49,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 +66,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 +75,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 +86,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 +99,62 @@ 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
+
+      # 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
-        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 +164,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 +179,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 +195,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 +205,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 +216,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,14 +225,14 @@ 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
         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
@@ -187,13 +240,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
@@ -210,62 +289,86 @@ 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
-        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
 
-      # 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
+      it 'use appropriate table alias' do
+        skip "Rails 6 regressed here, but it's fixed in 6-0-stable since https://github.com/rails/rails/commit/f9ba52477ca288e7effa5f6794ae3df3f4e982bc" if ENV["RAILS"] == "v6.0.3"
+
+        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})
+        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})
+
+        expect(real_query)
+          .to include "people.name = 'person_name_query'"
+        expect(real_query)
+          .to include "articles.title = 'person_article_title_query'"
+        expect(real_query)
+          .to include "parents_people.name = 'parent_name_query'"
+        expect(real_query)
+          .to include "articles_people.title = 'parents_article_title_query'"
+      end
+
+      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 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'/
+        expect(s.to_sql).to match /#{notable_type_field} = 'Person'/
       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 +377,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,22 +392,24 @@ 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' }
           ]
         )
-        if ActiveRecord::VERSION::MAJOR == 3
-          all_or_load, uniq_or_distinct = :all, :uniq
-        else
-          all_or_load, uniq_or_distinct = :load, :distinct
-        end
-        expect(search.result.send(all_or_load).size)
+
+        all_or_load, uniq_or_distinct = :load, :distinct
+        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
+
+      it 'evaluates joins with belongs_to join' do
+        s = Person.joins(:parent).ransack(parent_name_eq: 'Ernie').result(distinct: true)
+        expect(s).to be_an ActiveRecord::Relation
       end
 
       private
@@ -428,6 +533,27 @@ module Ransack
         @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
     end
 
     describe '#method_missing' do

data/spec/spec_helper.rb

@@ -1,9 +1,15 @@
 require 'machinist/active_record'
+require 'polyamorous/polyamorous.rb'
 require 'sham'
 require 'faker'
 require 'ransack'
+require 'action_controller'
+require 'ransack/helpers'
 require 'pry'
+require 'simplecov'
+require 'byebug'
 
+SimpleCov.start
 I18n.enforce_available_locales = false
 Time.zone = 'Eastern Time (US & Canada)'
 I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'support', '*.yml')]
@@ -35,12 +41,14 @@ RSpec.configure do |config|
     line = '=' * message.length
     puts line, message, line
     Schema.create
+    SubDB::Schema.create
   end
 
   config.before(:all)   { Sham.reset(:before_all) }
   config.before(:each)  { Sham.reset(:before_each) }
 
   config.include RansackHelper
+  config.include PolyamorousHelper
 end
 
 RSpec::Matchers.define :be_like do |expected|