ransack 1.8.4 → 3.2.1

data/spec/polyamorous/join_dependency_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Polyamorous
+  describe JoinDependency do
+
+    context 'with symbol joins' do
+      subject { new_join_dependency Person, articles: :comments }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq(2) }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
+        .to eq [Polyamorous::InnerJoin] }
+    end
+
+    context 'with has_many :through association' do
+      subject { new_join_dependency Person, :authored_article_comments }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 1 }
+      specify { expect(subject.send(:join_root).drop(1).first.table_name)
+        .to eq 'comments' }
+    end
+
+    context 'with outer join' do
+      subject { new_join_dependency Person, new_join(:articles, :outer) }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 1 }
+      specify { expect(subject.send(:join_root).drop(1).first.join_type)
+        .to eq Polyamorous::OuterJoin }
+    end
+
+    context 'with nested outer joins' do
+      subject { new_join_dependency Person,
+        new_join(:articles, :outer) => new_join(:comments, :outer) }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 2 }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type))
+        .to eq [Polyamorous::OuterJoin, Polyamorous::OuterJoin] }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
+        .to eq [Polyamorous::OuterJoin] }
+    end
+
+    context 'with polymorphic belongs_to join' do
+      subject { new_join_dependency Note, new_join(:notable, :inner, Person) }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 1 }
+      specify { expect(subject.send(:join_root).drop(1).first.join_type)
+        .to eq Polyamorous::InnerJoin }
+      specify { expect(subject.send(:join_root).drop(1).first.table_name)
+        .to eq 'people' }
+    end
+
+    context 'with polymorphic belongs_to join and nested symbol join' do
+      subject { new_join_dependency Note,
+        new_join(:notable, :inner, Person) => :comments }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 2 }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
+        .to eq [Polyamorous::InnerJoin] }
+      specify { expect(subject.send(:join_root).drop(1).first.table_name)
+        .to eq 'people' }
+      specify { expect(subject.send(:join_root).drop(1)[1].table_name)
+        .to eq 'comments' }
+    end
+
+    context 'with polymorphic belongs_to join and nested join' do
+      subject { new_join_dependency Note,
+        new_join(:notable, :outer, Person) => :comments }
+      specify { expect(subject.send(:join_root).drop(1).size).to eq 2 }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type)).to eq [Polyamorous::OuterJoin, Polyamorous::InnerJoin] }
+      specify { expect(subject.send(:join_root).drop(1).first.table_name)
+        .to eq 'people' }
+      specify { expect(subject.send(:join_root).drop(1)[1].table_name)
+        .to eq 'comments' }
+    end
+  end
+end

data/spec/polyamorous/join_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Polyamorous
+  describe Join do
+    it 'is a tree node' do
+      join = new_join(:articles, :outer)
+      expect(join).to be_kind_of(TreeNode)
+    end
+
+    it 'can be added to a tree' do
+      join = new_join(:articles, :outer)
+
+      tree_hash = {}
+      join.add_to_tree(tree_hash)
+
+      expect(tree_hash[join]).to be {}
+    end
+  end
+end

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

@@ -8,7 +8,6 @@ module Ransack
         subject { ::ActiveRecord::Base }
 
         it { should respond_to :ransack }
-        it { should respond_to :search }
 
         describe '#search' do
           subject { Person.ransack }
@@ -18,6 +17,13 @@ module Ransack
             expect(subject.object).to be_an ::ActiveRecord::Relation
           end
 
+          context "multiple database connection" do
+            it "does not raise error" do
+              expect { Person.ransack(name_cont: "test") }.not_to raise_error
+              expect { SubDB::OperationHistory.ransack(people_id_eq: 1) }.not_to raise_error
+            end
+          end
+
           context 'with scopes' do
             before do
               allow(Person)
@@ -37,12 +43,12 @@ module Ransack
 
             it 'applies stringy boolean scopes with true value in an array' do
               s = Person.ransack('of_age' => ['true'])
-              expect(s.result.to_sql).to (include 'age >= 18')
+              expect(s.result.to_sql).to (include rails7_and_mysql ? %q{(age >= '18')} : 'age >= 18')
             end
 
             it 'applies stringy boolean scopes with false value in an array' do
               s = Person.ransack('of_age' => ['false'])
-              expect(s.result.to_sql).to (include 'age < 18')
+              expect(s.result.to_sql).to (include rails7_and_mysql ? %q{age < '18'} : 'age < 18')
             end
 
             it 'ignores unlisted scopes' do
@@ -62,15 +68,25 @@ module Ransack
 
             it 'passes values to scopes' do
               s = Person.ransack('over_age' => 18)
-              expect(s.result.to_sql).to (include 'age > 18')
+              expect(s.result.to_sql).to (include rails7_and_mysql ? %q{age > '18'} : 'age > 18')
             end
 
             it 'chains scopes' do
               s = Person.ransack('over_age' => 18, 'active' => true)
-              expect(s.result.to_sql).to (include 'age > 18')
+              expect(s.result.to_sql).to (include rails7_and_mysql ? %q{age > '18'} : 'age > 18')
               expect(s.result.to_sql).to (include 'active = 1')
             end
 
+            it 'applies scopes that define string SQL joins' do
+              allow(Article)
+                .to receive(:ransackable_scopes)
+                .and_return([:latest_comment_cont])
+
+              # Including a negative condition to test removing the scope
+              s = Search.new(Article, notes_note_not_eq: 'Test', latest_comment_cont: 'Test')
+              expect(s.result.to_sql).to include 'latest_comment'
+            end
+
             context "with sanitize_custom_scope_booleans set to false" do
               before(:all) do
                 Ransack.configure { |c| c.sanitize_custom_scope_booleans = false }
@@ -82,20 +98,43 @@ module Ransack
 
               it 'passes true values to scopes' do
                 s = Person.ransack('over_age' => 1)
-                expect(s.result.to_sql).to (include 'age > 1')
+                expect(s.result.to_sql).to (include rails7_and_mysql ? %q{age > '1'} : 'age > 1')
               end
 
               it 'passes false values to scopes'  do
                 s = Person.ransack('over_age' => 0)
-                expect(s.result.to_sql).to (include 'age > 0')
+                expect(s.result.to_sql).to (include rails7_and_mysql ? %q{age > '0'} : 'age > 0')
               end
             end
+
+            context "with ransackable_scopes_skip_sanitize_args enabled for scope" do
+              before do
+                allow(Person)
+                .to receive(:ransackable_scopes_skip_sanitize_args)
+                .and_return([:over_age])
+              end
+
+              it 'passes true values to scopes' do
+                s = Person.ransack('over_age' => 1)
+                expect(s.result.to_sql).to (include rails7_and_mysql ? %q{age > '1'} : 'age > 1')
+              end
+
+              it 'passes false values to scopes'  do
+                s = Person.ransack('over_age' => 0)
+                expect(s.result.to_sql).to (include  rails7_and_mysql ? %q{age > '0'} : 'age > 0')
+              end
+            end
+
           end
 
           it 'does not raise exception for string :params argument' do
             expect { Person.ransack('') }.to_not raise_error
           end
 
+          it 'raises exception if ransack! called with unknown condition' do
+            expect { Person.ransack!(unknown_attr_eq: 'Ernie') }.to raise_error(ArgumentError)
+          end
+
           it 'does not modify the parameters' do
             params = { name_eq: '' }
             expect { Person.ransack(params) }.not_to change { params }
@@ -117,14 +156,12 @@ module Ransack
           it 'removes redundant joins from top query' do
             s = Article.ransack(tags_name_not_eq: "Fantasy")
             sql = s.result.to_sql
-
             expect(sql).to_not include('LEFT OUTER JOIN')
           end
 
           it 'handles != for single values' do
             s = Article.ransack(tags_name_not_eq: "Fantasy")
             articles = s.result.to_a
-
             expect(articles).to include marco
             expect(articles).to_not include arthur
           end
@@ -241,10 +278,12 @@ module Ransack
           # end
 
           it 'creates ransack attributes' do
+            person = Person.create!(name: 'Aric Smith')
+
             s = Person.ransack(reversed_name_eq: 'htimS cirA')
             expect(s.result.size).to eq(1)
 
-            expect(s.result.first).to eq Person.where(name: 'Aric Smith').first
+            expect(s.result.first).to eq person
           end
 
           it 'can be accessed through associations' do
@@ -284,7 +323,11 @@ module Ransack
           end
 
           it 'should function correctly with a multi-parameter attribute' do
-            ::ActiveRecord::Base.default_timezone = :utc
+            if ::ActiveRecord::VERSION::MAJOR >= 7
+              ::ActiveRecord.default_timezone = :utc
+            else
+              ::ActiveRecord::Base.default_timezone = :utc
+            end
             Time.zone = 'UTC'
 
             date = Date.current
@@ -429,6 +472,16 @@ module Ransack
             end
           end
 
+          it 'sorts with different join variants' do
+            comments = [
+              Comment.create(article: Article.create(title: 'Avenger'), person: Person.create(salary: 100_000)),
+              Comment.create(article: Article.create(title: 'Avenge'), person: Person.create(salary: 50_000)),
+            ]
+            expect(Comment.ransack(article_title_cont: 'aven', s: 'person_salary desc').result).to eq(comments)
+            expect(Comment.joins(:person).ransack(s: 'persons_salarydesc', article_title_cont: 'aven').result).to eq(comments)
+            expect(Comment.joins(:person).ransack(article_title_cont: 'aven', s: 'persons_salary desc').result).to eq(comments)
+          end
+
           it 'allows sort by `only_sort` field' do
             s = Person.ransack(
               's' => { '0' => { 'dir' => 'asc', 'name' => 'only_sort' } }
@@ -544,6 +597,37 @@ module Ransack
               /BETWEEN 2 AND 6 GROUP BY articles.person_id \) DESC/
             )
           end
+
+          context 'case insensitive sorting' do
+            it 'allows sort by desc' do
+              search = Person.ransack(sorts: ['name_case_insensitive desc'])
+              expect(search.result.to_sql).to match /ORDER BY LOWER(.*) DESC/
+            end
+
+            it 'allows sort by asc' do
+              search = Person.ransack(sorts: ['name_case_insensitive asc'])
+              expect(search.result.to_sql).to match /ORDER BY LOWER(.*) ASC/
+            end
+          end
+
+          context 'regular sorting' do
+            it 'allows sort by desc' do
+              search = Person.ransack(sorts: ['name desc'])
+              expect(search.result.to_sql).to match /ORDER BY .* DESC/
+            end
+
+            it 'allows sort by asc' do
+              search = Person.ransack(sorts: ['name asc'])
+              expect(search.result.to_sql).to match /ORDER BY .* ASC/
+            end
+          end
+
+          context 'sorting by a scope' do
+            it 'applies the correct scope' do
+              search = Person.ransack(sorts: ['reverse_name asc'])
+              expect(search.result.to_sql).to include("ORDER BY REVERSE(name) ASC")
+            end
+          end
         end
 
         describe '#ransackable_attributes' do
@@ -613,6 +697,16 @@ module Ransack
           it { should eq [] }
         end
 
+        describe '#ransackable_scopes_skip_sanitize_args' do
+          subject { Person.ransackable_scopes_skip_sanitize_args }
+
+          it { should eq [] }
+        end
+
+        private
+        def rails7_and_mysql
+          ::ActiveRecord::VERSION::MAJOR >= 7 && ENV['DB'] == 'mysql'
+        end
       end
     end
   end

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

@@ -9,9 +9,7 @@ module Ransack
       describe Context do
         subject { Context.new(Person) }
 
-
-        it 'has an Active Record alias tracker method',
-        if: AR_version >= '3.1' do
+        it 'has an Active Record alias tracker method' do
           expect(subject.alias_tracker)
           .to be_an ::ActiveRecord::Associations::AliasTracker
         end
@@ -41,6 +39,66 @@ module Ransack
           end
         end
 
+        describe '#build_correlated_subquery' do
+          it 'build correlated subquery for Root STI model' do
+            search = Search.new(Person, { articles_title_not_eq: 'some_title' }, context: subject)
+            attribute = search.conditions.first.attributes.first
+            constraints = subject.build_correlated_subquery(attribute.parent).constraints
+            constraint = constraints.first
+
+            expect(constraints.length).to eql 1
+            expect(constraint.left.name).to eql 'person_id'
+            expect(constraint.left.relation.name).to eql 'articles'
+            expect(constraint.right.name).to eql 'id'
+            expect(constraint.right.relation.name).to eql 'people'
+          end
+
+          it 'build correlated subquery for Child STI model when predicate is not_eq' do
+            search = Search.new(Person, { story_articles_title_not_eq: 'some_title' }, context: subject)
+            attribute = search.conditions.first.attributes.first
+            constraints = subject.build_correlated_subquery(attribute.parent).constraints
+            constraint = constraints.first
+
+            expect(constraints.length).to eql 1
+            expect(constraint.left.relation.name).to eql 'articles'
+            expect(constraint.left.name).to eql 'person_id'
+            expect(constraint.right.relation.name).to eql 'people'
+            expect(constraint.right.name).to eql 'id'
+          end
+
+          it 'build correlated subquery for Child STI model when predicate is eq' do
+            search = Search.new(Person, { story_articles_title_not_eq: 'some_title' }, context: subject)
+            attribute = search.conditions.first.attributes.first
+            constraints = subject.build_correlated_subquery(attribute.parent).constraints
+            constraint = constraints.first
+
+            expect(constraints.length).to eql 1
+            expect(constraint.left.relation.name).to eql 'articles'
+            expect(constraint.left.name).to eql 'person_id'
+            expect(constraint.right.relation.name).to eql 'people'
+            expect(constraint.right.name).to eql 'id'
+          end
+
+          it 'build correlated subquery for multiple conditions (default scope)' do
+            search = Search.new(Person, { comments_body_not_eq: 'some_title' })
+
+            # Was
+            # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
+            #   SELECT "comments"."disabled" FROM "comments"
+            #   WHERE "comments"."disabled" = "people"."id"
+            #     AND NOT ("comments"."body" != 'some_title')
+            # ) ORDER BY "people"."id" DESC
+            # Should Be
+            # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
+            #   SELECT "comments"."person_id" FROM "comments"
+            #   WHERE "comments"."person_id" = "people"."id"
+            #     AND NOT ("comments"."body" != 'some_title')
+            # ) ORDER BY "people"."id" DESC
+
+            expect(search.result.to_sql).to match /.comments.\..person_id. = .people.\..id./
+          end
+        end
+
         describe 'sharing context across searches' do
           let(:shared_context) { Context.for(Person) }
 
@@ -51,34 +109,15 @@ module Ransack
               context: shared_context)
           end
 
-          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
-
-              expect(children.aliased_table_name).to eq "children_people"
-              expect(parents.aliased_table_name).to eq "parents_people"
-            end
-
-            it 'can be rejoined to execute a valid query' do
-              parents, children = shared_context.join_associations
-
-              expect { Person.joins(parents).joins(children).to_a }
-              .to_not raise_error
-            end
-          end
-
           describe '#join_sources' do
-            # 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' 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
+            it 'can be rejoined to execute a valid query' do
               parents, children = shared_context.join_sources
 
               expect { Person.joins(parents).joins(children).to_a }

data/spec/ransack/configuration_spec.rb

@@ -45,6 +45,20 @@ module Ransack
       Ransack.options = default
     end
 
+    it 'should have default value for strip_whitespace' do
+      expect(Ransack.options[:strip_whitespace]).to eq true
+    end
+
+    it 'changes default search key parameter' do
+      default = Ransack.options.clone
+
+      Ransack.configure { |c| c.strip_whitespace = false }
+
+      expect(Ransack.options[:strip_whitespace]).to eq false
+
+      Ransack.options = default
+    end
+
     it 'should have default values for arrows' do
       expect(Ransack.options[:up_arrow]).to eq '▼'
       expect(Ransack.options[:down_arrow]).to eq '▲'
@@ -173,5 +187,15 @@ module Ransack
         .to eq false
       end
     end
+
+    it "PG's sort option", if: ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" do
+      default = Ransack.options.clone
+
+      Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_first }
+
+      expect(Ransack.options[:postgres_fields_sort_option]).to eq :nulls_first
+
+      Ransack.options = default
+    end
   end
 end

data/spec/ransack/helpers/form_builder_spec.rb

@@ -21,11 +21,7 @@ module Ransack
         @controller.view_context.search_form_for(@s) { |f| @f = f }
       end
 
-      it 'selects previously-entered time values with datetime_select',
-        unless: (
-          RUBY_VERSION >= '2.3' &&
-          ::ActiveRecord::VERSION::STRING.first(3) < '3.2'
-          ) do
+      it 'selects previously-entered time values with datetime_select' 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
@@ -75,11 +71,7 @@ module Ransack
       describe '#sort_link' do
         it 'sort_link for ransack attribute' do
           sort_link = @f.sort_link :name, :controller => 'people'
-          if ActiveRecord::VERSION::STRING =~ /^3\.[1-2]\./
-            expect(sort_link).to match /people\?q%5Bs%5D=name\+asc/
-          else
-            expect(sort_link).to match /people\?q(%5B|\[)s(%5D|\])=name\+asc/
-          end
+          expect(sort_link).to match /people\?q(%5B|\[)s(%5D|\])=name\+asc/
           expect(sort_link).to match /sort_link/
           expect(sort_link).to match /Full Name<\/a>/
         end
@@ -171,11 +163,7 @@ module Ransack
         # Starting from Rails 4.2, the date_select html attributes are no longer
         # `sort`ed (for a speed gain), so the tests have to be different:
         def date_select_html(val)
-          if ::ActiveRecord::VERSION::STRING >= '4.2'
-            %(<option value="#{val}" selected="selected">#{val}</option>)
-          else
-            %(<option selected="selected" value="#{val}">#{val}</option>)
-          end
+          %(<option value="#{val}" selected="selected">#{val}</option>)
         end
 
     end