ransack 2.4.2 → 4.0.0

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 }
@@ -44,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
@@ -69,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 }
@@ -89,12 +98,12 @@ 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
 
@@ -107,12 +116,12 @@ 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
 
@@ -123,7 +132,7 @@ module Ransack
           end
 
           it 'raises exception if ransack! called with unknown condition' do
-            expect { Person.ransack!(unknown_attr_eq: 'Ernie') }.to raise_error
+            expect { Person.ransack!(unknown_attr_eq: 'Ernie') }.to raise_error(ArgumentError)
           end
 
           it 'does not modify the parameters' do
@@ -314,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
@@ -644,6 +657,37 @@ module Ransack
             it { should_not include 'only_sort' }
             it { should include 'only_admin' }
           end
+
+          context 'when not defined in model, nor in ApplicationRecord' do
+            subject { Article.ransackable_attributes }
+
+            it "raises a helpful error" do
+              without_application_record_method(:ransackable_attributes) do
+                expect { subject }.to raise_error(RuntimeError, /Ransack needs Article attributes explicitly allowlisted/)
+              end
+            end
+          end
+
+          context 'when defined only in model by delegating to super' do
+            subject { Article.ransackable_attributes }
+
+            around do |example|
+              Article.singleton_class.define_method(:ransackable_attributes) do
+                super(nil) - super(nil)
+              end
+
+              example.run
+            ensure
+              Article.singleton_class.remove_method(:ransackable_attributes)
+            end
+
+            it "returns the allowlist in the model, and warns" do
+              without_application_record_method(:ransackable_attributes) do
+                expect { subject }.to output(/Ransack's builtin `ransackable_attributes` method is deprecated/).to_stderr
+                expect(subject).to be_empty
+              end
+            end
+          end
         end
 
         describe '#ransortable_attributes' do
@@ -676,6 +720,37 @@ module Ransack
           it { should include 'parent' }
           it { should include 'children' }
           it { should include 'articles' }
+
+          context 'when not defined in model, nor in ApplicationRecord' do
+            subject { Article.ransackable_associations }
+
+            it "raises a helpful error" do
+              without_application_record_method(:ransackable_associations) do
+                expect { subject }.to raise_error(RuntimeError, /Ransack needs Article associations explicitly allowlisted/)
+              end
+            end
+          end
+
+          context 'when defined only in model by delegating to super' do
+            subject { Article.ransackable_associations }
+
+            around do |example|
+              Article.singleton_class.define_method(:ransackable_associations) do
+                super(nil) - super(nil)
+              end
+
+              example.run
+            ensure
+              Article.singleton_class.remove_method(:ransackable_associations)
+            end
+
+            it "returns the allowlist in the model, and warns" do
+              without_application_record_method(:ransackable_associations) do
+                expect { subject }.to output(/Ransack's builtin `ransackable_associations` method is deprecated/).to_stderr
+                expect(subject).to be_empty
+              end
+            end
+          end
         end
 
         describe '#ransackable_scopes' do
@@ -690,6 +765,21 @@ module Ransack
           it { should eq [] }
         end
 
+        private
+
+        def without_application_record_method(method)
+          ApplicationRecord.singleton_class.alias_method :"original_#{method}", :"#{method}"
+          ApplicationRecord.singleton_class.remove_method :"#{method}"
+
+          yield
+        ensure
+          ApplicationRecord.singleton_class.alias_method :"#{method}", :"original_#{method}"
+          ApplicationRecord.singleton_class.remove_method :"original_#{method}"
+        end
+
+        def rails7_and_mysql
+          ::ActiveRecord::VERSION::MAJOR >= 7 && ENV['DB'] == 'mysql'
+        end
       end
     end
   end

data/spec/ransack/configuration_spec.rb

@@ -20,7 +20,7 @@ module Ransack
       Ransack.configure do |config|
         config.add_predicate(
           :test_predicate_without_compound,
-          :compounds => false
+          compounds: false
           )
       end
       expect(Ransack.predicates)
@@ -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 '▲'
@@ -124,8 +138,8 @@ module Ransack
       Ransack.configure do |config|
         config.add_predicate(
           :test_array_predicate,
-          :wants_array => true,
-          :compounds => true
+          wants_array: true,
+          compounds: true
           )
       end
 
@@ -139,11 +153,11 @@ module Ransack
         Ransack.configure do |config|
           config.add_predicate(
             :test_in_predicate,
-            :arel_predicate => 'in'
+            arel_predicate: 'in'
           )
           config.add_predicate(
             :test_not_in_predicate,
-            :arel_predicate => 'not_in'
+            arel_predicate: 'not_in'
           )
         end
 
@@ -157,13 +171,13 @@ module Ransack
         Ransack.configure do |config|
           config.add_predicate(
             :test_in_predicate_no_array,
-            :arel_predicate => 'in',
-            :wants_array => false
+            arel_predicate: 'in',
+            wants_array: false
           )
           config.add_predicate(
             :test_not_in_predicate_no_array,
-            :arel_predicate => 'not_in',
-            :wants_array => false
+            arel_predicate: 'not_in',
+            wants_array: false
           )
         end
 

data/spec/ransack/helpers/form_builder_spec.rb

@@ -26,7 +26,7 @@ module Ransack
       # @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
         html = @f.datetime_select(
-          :created_at_eq, :use_month_numbers => true, :include_seconds => true
+          :created_at_eq, use_month_numbers: true, include_seconds: true
           )
         date_values.each { |val| expect(html).to include date_select_html(val) }
       end
@@ -70,13 +70,13 @@ module Ransack
 
       describe '#sort_link' do
         it 'sort_link for ransack attribute' do
-          sort_link = @f.sort_link :name, :controller => 'people'
+          sort_link = @f.sort_link :name, controller: 'people'
           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
         it 'sort_link for common attribute' do
-          sort_link = @f.sort_link :id, :controller => 'people'
+          sort_link = @f.sort_link :id, controller: 'people'
           expect(sort_link).to match /id<\/a>/
         end
       end
@@ -99,14 +99,14 @@ module Ransack
         it 'returns ransackable attributes for associations with :associations' do
           attributes = Person.ransackable_attributes +
             Article.ransackable_attributes.map { |a| "articles_#{a}" }
-          html = @f.attribute_select(:associations => ['articles'])
+          html = @f.attribute_select(associations: ['articles'])
           expect(html.split(/\n/).size).to eq(attributes.size)
           attributes.each do |attribute|
             expect(html).to match /<option value="#{attribute}">/
           end
         end
         it 'returns option groups for base and associations with :associations' do
-          html = @f.attribute_select(:associations => ['articles'])
+          html = @f.attribute_select(associations: ['articles'])
           [Person, Article].each do |model|
             expect(html).to match /<optgroup label="#{model}">/
           end
@@ -121,19 +121,19 @@ module Ransack
           end
         end
         it 'filters predicates with single-value :only' do
-          html = @f.predicate_select :only => 'eq'
+          html = @f.predicate_select only: 'eq'
           Predicate.names.reject { |k| k =~ /^eq/ }.each do |key|
             expect(html).not_to match /<option value="#{key}">/
           end
         end
         it 'filters predicates with multi-value :only' do
-          html = @f.predicate_select :only => [:eq, :lt]
+          html = @f.predicate_select only: [:eq, :lt]
           Predicate.names.reject { |k| k =~ /^(eq|lt)/ }.each do |key|
             expect(html).not_to match /<option value="#{key}">/
           end
         end
         it 'excludes compounds when compounds: false' do
-          html = @f.predicate_select :compounds => false
+          html = @f.predicate_select compounds: false
           Predicate.names.select { |k| k =~ /_(any|all)$/ }.each do |key|
             expect(html).not_to match /<option value="#{key}">/
           end

data/spec/ransack/helpers/form_helper_spec.rb

@@ -140,6 +140,32 @@ module Ransack
         }
       end
 
+      describe '#sort_link works even if search params are a string' do
+        before { @controller.view_context.params[:q] = 'input error' }
+        specify {
+          expect { @controller.view_context
+            .sort_link(
+              Person.ransack({}),
+              :name,
+              controller: 'people'
+            )
+          }.not_to raise_error
+        }
+      end
+
+      describe '#sort_url works even if search params are a string' do
+        before { @controller.view_context.params[:q] = 'input error' }
+        specify {
+          expect { @controller.view_context
+            .sort_url(
+              Person.ransack({}),
+              :name,
+              controller: 'people'
+            )
+          }.not_to raise_error
+        }
+      end
+
       describe '#sort_link with search_key defined as a string' do
         subject { @controller.view_context
           .sort_link(
@@ -469,13 +495,12 @@ module Ransack
           it { should match /exist\=existing/ }
         end
 
-        context 'using a real ActionController::Parameter object',
-          if: ::ActiveRecord::VERSION::MAJOR > 3 do
+        context 'using a real ActionController::Parameter object' do
 
           describe 'with symbol q:, #sort_link should include search params' do
             subject { @controller.view_context.sort_link(Person.ransack, :name) }
             let(:params) { ActionController::Parameters.new(
-              { :q => { name_eq: 'TEST' }, controller: 'people' }
+              { q: { name_eq: 'TEST' }, controller: 'people' }
               ) }
             before { @controller.instance_variable_set(:@params, params) }
 
@@ -490,7 +515,7 @@ module Ransack
           describe 'with symbol q:, #sort_url should include search params' do
             subject { @controller.view_context.sort_url(Person.ransack, :name) }
             let(:params) { ActionController::Parameters.new(
-              { :q => { name_eq: 'TEST' }, controller: 'people' }
+              { q: { name_eq: 'TEST' }, controller: 'people' }
               ) }
             before { @controller.instance_variable_set(:@params, params) }
 
@@ -727,6 +752,70 @@ module Ransack
         it { should match /Block label ▼/ }
       end
 
+      describe '#sort_link with class option' do
+        subject { @controller.view_context
+          .sort_link(
+            [:main_app, Person.ransack(sorts: ['name desc'])],
+            :name,
+            class: 'people', controller: 'people'
+          )
+        }
+        it { should match /class="sort_link desc people"/ }
+        it { should_not match /people\?class=people/ }
+      end
+
+      describe '#sort_link with class option workaround' do
+        it "generates a correct link and prints a deprecation" do
+          expect do
+            link = @controller.view_context
+              .sort_link(
+                [:main_app, Person.ransack(sorts: ['name desc'])],
+                :name,
+                'name',
+                { controller: 'people' },
+                class: 'people'
+              )
+
+            expect(link).to match(/class="sort_link desc people"/)
+            expect(link).not_to match(/people\?class=people/)
+          end.to output(
+            /Passing two trailing hashes to `sort_link` is deprecated, merge the trailing hashes into a single one\. \(called at #{Regexp.escape(__FILE__)}:/
+          ).to_stderr
+        end
+      end
+
+      describe '#sort_link with data option' do
+        subject { @controller.view_context
+          .sort_link(
+            [:main_app, Person.ransack(sorts: ['name desc'])],
+            :name,
+            data: { turbo_action: :advance }, controller: 'people'
+          )
+        }
+        it { should match /data-turbo-action="advance"/ }
+        it { should_not match /people\?data%5Bturbo_action%5D=advance/ }
+      end
+
+      describe "#sort_link with host option" do
+        subject { @controller.view_context
+          .sort_link(
+            [:main_app, Person.ransack(sorts: ['name desc'])],
+            :name,
+            host: 'foo', controller: 'people'
+          )
+        }
+        it { should match /href="\/people\?q/ }
+        it { should_not match /href=".*foo/ }
+      end
+
+      describe "#sort_link ignores host in params" do
+        before { @controller.view_context.params[:host] = 'other_domain' }
+        subject { @controller.view_context.sort_link(Person.ransack, :name, controller: 'people') }
+
+        it { should match /href="\/people\?q/ }
+        it { should_not match /href=".*other_domain/ }
+      end
+
       describe '#search_form_for with default format' do
         subject { @controller.view_context
           .search_form_for(Person.ransack) {} }

data/spec/ransack/nodes/condition_spec.rb

@@ -3,6 +3,19 @@ require 'spec_helper'
 module Ransack
   module Nodes
     describe Condition do
+      context 'bug report #1245' do
+        it 'preserves tuple behavior' do
+          ransack_hash = {
+              m: 'and',
+              g: [
+                { title_type_in: ['["title 1", ""]'] }
+              ]
+            }
+
+          sql = Article.ransack(ransack_hash).result.to_sql
+          expect(sql).to include("IN (('title 1', ''))")
+        end
+      end
 
       context 'with an alias' do
         subject {
@@ -61,6 +74,30 @@ module Ransack
           specify { expect(subject).to be_nil }
         end
       end
+
+      context 'with an empty predicate' do
+        subject {
+          Condition.extract(
+            Context.for(Person), 'full_name', Person.first.name
+          )
+        }
+
+        context "when default_predicate = nil" do
+          before do
+            Ransack.configure { |c| c.default_predicate = nil }
+          end
+
+          specify { expect(subject).to be_nil }
+        end
+
+        context "when default_predicate = 'eq'" do
+          before do
+            Ransack.configure { |c| c.default_predicate = 'eq' }
+          end
+
+          specify { expect(subject).to eq Condition.extract(Context.for(Person), 'full_name_eq', Person.first.name) }
+        end
+      end
     end
   end
 end

data/spec/ransack/nodes/value_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+module Ransack
+  module Nodes
+    describe Value do
+      let(:context) { Context.for(Person) }
+
+      subject do
+        Value.new(context, raw_value)
+      end
+
+      context "with a date value" do
+        let(:raw_value) { "2022-05-23" }
+
+        [:date].each do |type|
+          it "should cast #{type} correctly" do
+            result = subject.cast(type)
+
+            expect(result).to be_a_kind_of(Date)
+            expect(result).to eq(Date.parse(raw_value))
+          end
+        end
+      end
+
+      context "with a timestamp value" do
+        let(:raw_value) { "2022-05-23 10:40:02 -0400" }
+
+        [:datetime, :timestamp, :time, :timestamptz].each do |type|
+          it "should cast #{type} correctly" do
+            result = subject.cast(type)
+
+            expect(result).to be_a_kind_of(Time)
+            expect(result).to eq(Time.zone.parse(raw_value))
+          end
+        end
+      end
+
+      Constants::TRUE_VALUES.each do |value|
+        context "with a true boolean value (#{value})" do
+          let(:raw_value) { value.to_s }
+
+          it "should cast boolean correctly" do
+            result = subject.cast(:boolean)
+            expect(result).to eq(true)
+          end
+        end
+      end
+
+      Constants::FALSE_VALUES.each do |value|
+        context "with a false boolean value (#{value})" do
+          let(:raw_value) { value.to_s }
+
+          it "should cast boolean correctly" do
+            result = subject.cast(:boolean)
+
+            expect(result).to eq(false)
+          end
+        end
+      end
+
+      ["12", "101.5"].each do |value|
+        context "with an integer value (#{value})" do
+          let(:raw_value) { value }
+
+          it "should cast #{value} to integer correctly" do
+            result = subject.cast(:integer)
+
+            expect(result).to be_an(Integer)
+            expect(result).to eq(value.to_i)
+          end
+        end
+      end
+
+      ["12", "101.5"].each do |value|
+        context "with a float value (#{value})" do
+          let(:raw_value) { value }
+
+          it "should cast #{value} to float correctly" do
+            result = subject.cast(:float)
+
+            expect(result).to be_an(Float)
+            expect(result).to eq(value.to_f)
+          end
+        end
+      end
+
+      ["12", "101.5"].each do |value|
+        context "with a decimal value (#{value})" do
+          let(:raw_value) { value }
+
+          it "should cast #{value} to decimal correctly" do
+            result = subject.cast(:decimal)
+
+            expect(result).to be_a(BigDecimal)
+            expect(result).to eq(value.to_d)
+          end
+        end
+      end
+
+      ["12", "101.513"].each do |value|
+        context "with a money value (#{value})" do
+          let(:raw_value) { value }
+
+          it "should cast #{value} to money correctly" do
+            result = subject.cast(:money)
+
+            expect(result).to be_a(String)
+            expect(result).to eq(value.to_f.to_s)
+          end
+        end
+      end
+
+    end
+  end
+end