ransack 1.7.0 → 2.4.1

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

@@ -9,11 +9,10 @@ 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' do
+          expect(subject.alias_tracker)
+          .to be_an ::ActiveRecord::Associations::AliasTracker
         end
 
         describe '#relation_for' do
@@ -24,8 +23,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,54 +32,93 @@ 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
-          let(:shared_context) { Context.for(Person) }
+        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
 
-          before do
-            Search.new(Person, { :parent_name_eq => 'A' },
-              context: shared_context)
-            Search.new(Person, { :children_name_eq => 'B' },
-              context: shared_context)
+          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
 
-          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
+          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
 
-              expect(children.aliased_table_name).to eq "children_people"
-              expect(parents.aliased_table_name).to eq "parents_people"
-            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
 
-            it 'can be rejoined to execute a valid query' do
-              parents, children = shared_context.join_associations
+        describe 'sharing context across searches' do
+          let(:shared_context) { Context.for(Person) }
 
-              expect { Person.joins(parents).joins(children).to_a }
-              .to_not raise_error
-            end
+          before do
+            Search.new(Person, { parent_name_eq: 'A' },
+              context: shared_context)
+            Search.new(Person, { children_name_eq: 'B' },
+              context: shared_context)
           end
 
           describe '#join_sources' do
-            # FIXME: fix this test for Rails 4.2.
             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

@@ -3,9 +3,7 @@ require 'spec_helper'
 module Ransack
   describe Configuration do
     it 'yields Ransack on configure' do
-      Ransack.configure do |config|
-        expect(config).to eq Ransack
-      end
+      Ransack.configure { |config| expect(config).to eq Ransack }
     end
 
     it 'adds predicates' do
@@ -38,17 +36,88 @@ module Ransack
     end
 
     it 'changes default search key parameter' do
-      # store original state so we can restore it later
-      before = Ransack.options.clone
+      default = Ransack.options.clone
 
-      Ransack.configure do |config|
-        config.search_key = :query
-      end
+      Ransack.configure { |c| c.search_key = :query }
 
       expect(Ransack.options[:search_key]).to eq :query
 
-      # restore original state so we don't break other tests
-      Ransack.options = before
+      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 '▲'
+      expect(Ransack.options[:default_arrow]).to eq nil
+    end
+
+    it 'changes the default value for the up arrow only' do
+      default, new_up_arrow = Ransack.options.clone, 'U+02191'
+
+      Ransack.configure { |c| c.custom_arrows = { up_arrow: new_up_arrow } }
+
+      expect(Ransack.options[:down_arrow]).to eq default[:down_arrow]
+      expect(Ransack.options[:up_arrow]).to eq new_up_arrow
+
+      Ransack.options = default
+    end
+
+    it 'changes the default value for the down arrow only' do
+      default, new_down_arrow  = Ransack.options.clone, '<i class="down"></i>'
+
+      Ransack.configure { |c| c.custom_arrows = { down_arrow: new_down_arrow } }
+
+      expect(Ransack.options[:up_arrow]).to eq default[:up_arrow]
+      expect(Ransack.options[:down_arrow]).to eq new_down_arrow
+
+      Ransack.options = default
+    end
+
+    it 'changes the default value for the default arrow only' do
+      default, new_default_arrow  = Ransack.options.clone, '<i class="default"></i>'
+
+      Ransack.configure { |c| c.custom_arrows = { default_arrow: new_default_arrow } }
+
+      expect(Ransack.options[:up_arrow]).to eq default[:up_arrow]
+      expect(Ransack.options[:down_arrow]).to eq default[:down_arrow]
+      expect(Ransack.options[:default_arrow]).to eq new_default_arrow
+
+      Ransack.options = default
+    end
+
+    it 'changes the default value for all arrows' do
+      default        = Ransack.options.clone
+      new_up_arrow   = '<i class="fa fa-long-arrow-up"></i>'
+      new_down_arrow = 'U+02193'
+      new_default_arrow = 'defaultarrow'
+
+      Ransack.configure do |c|
+        c.custom_arrows = { up_arrow: new_up_arrow, down_arrow: new_down_arrow, default_arrow: new_default_arrow }
+      end
+
+      expect(Ransack.options[:up_arrow]).to eq new_up_arrow
+      expect(Ransack.options[:down_arrow]).to eq new_down_arrow
+      expect(Ransack.options[:default_arrow]).to eq new_default_arrow
+
+      Ransack.options = default
+    end
+
+    it 'consecutive arrow customizations respect previous customizations' do
+      default = Ransack.options.clone
+
+      Ransack.configure { |c| c.custom_arrows = { up_arrow: 'up' } }
+      expect(Ransack.options[:down_arrow]).to eq default[:down_arrow]
+
+      Ransack.configure { |c| c.custom_arrows = { down_arrow: 'DOWN' } }
+      expect(Ransack.options[:up_arrow]).to eq 'up'
+
+      Ransack.configure { |c| c.custom_arrows = { up_arrow: '<i>U-Arrow</i>' } }
+      expect(Ransack.options[:down_arrow]).to eq 'DOWN'
+
+      Ransack.configure { |c| c.custom_arrows = { down_arrow: 'down arrow-2' } }
+      expect(Ransack.options[:up_arrow]).to eq '<i>U-Arrow</i>'
+
+      Ransack.options = default
     end
 
     it 'adds predicates that take arrays, overriding compounds' do
@@ -78,8 +147,10 @@ module Ransack
           )
         end
 
-        expect(Ransack.predicates['test_in_predicate'].wants_array).to eq true
-        expect(Ransack.predicates['test_not_in_predicate'].wants_array).to eq true
+        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
@@ -96,9 +167,21 @@ module Ransack
           )
         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
+        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
+
+    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

@@ -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
@@ -72,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
@@ -168,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