ransack 4.3.0 → 4.4.1

data/spec/factories/people.rb

@@ -0,0 +1,10 @@
+FactoryBot.define do
+  factory :person do
+    name { Faker::Name.name }
+    email { "test@example.com" }
+    sequence(:salary) { |n| 30000 + (n * 1000) }
+    only_sort { Faker::Lorem.words(number: 3).join(' ') }
+    only_search { Faker::Lorem.words(number: 3).join(' ') }
+    only_admin { Faker::Lorem.words(number: 3).join(' ') }
+  end
+end

data/spec/factories/tags.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :tag do
+    name { Faker::Lorem.words(number: 3).join(' ') }
+  end
+end

data/spec/polyamorous/join_association_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Polyamorous
   describe JoinAssociation do
-
     let(:join_dependency) { new_join_dependency Note, {} }
     let(:reflection) { Note.reflect_on_association(:notable) }
     let(:parent) { join_dependency.send(:join_root) }

data/spec/polyamorous/join_dependency_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Polyamorous
   describe JoinDependency do
-
     context 'with symbol joins' do
       subject { new_join_dependency Person, articles: :comments }
 

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

@@ -4,7 +4,6 @@ module Ransack
   module Adapters
     module ActiveRecord
       describe Base do
-
         subject { ::ActiveRecord::Base }
 
         it { should respond_to :ransack }
@@ -124,7 +123,6 @@ module Ransack
                 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
@@ -195,6 +193,41 @@ module Ransack
           end
         end
 
+        context 'negative conditions on related object with HABTM associations' do
+          let(:medieval) { Tag.create!(name: 'Medieval') }
+          let(:fantasy)  { Tag.create!(name: 'Fantasy') }
+          let(:arthur)   { Article.create!(title: 'King Arthur') }
+          let(:marco)    { Article.create!(title: 'Marco Polo') }
+          let(:comment_arthur)  { marco.comments.create!(body: 'King Arthur comment') }
+          let(:comment_marco)   { arthur.comments.create!(body: 'Marco Polo comment') }
+
+          before do
+            comment_arthur.tags << medieval
+            comment_marco.tags << fantasy
+          end
+
+          it 'removes redundant joins from top query' do
+            s = Article.ransack(comments_tags_name_not_eq: "Fantasy")
+            sql = s.result.to_sql
+            expect(sql).to include('LEFT OUTER JOIN')
+          end
+
+          it 'handles != for single values' do
+            s = Article.ransack(comments_tags_name_not_eq: "Fantasy")
+            articles = s.result.to_a
+            expect(articles).to include marco
+            expect(articles).to_not include arthur
+          end
+
+          it 'handles NOT IN for multiple attributes' do
+            s = Article.ransack(comments_tags_name_not_in: ["Fantasy", "Scifi"])
+            articles = s.result.to_a
+
+            expect(articles).to include marco
+            expect(articles).to_not include arthur
+          end
+        end
+
         context 'negative conditions on self-referenced associations' do
           let(:pop) { Person.create!(name: 'Grandpa') }
           let(:dad) { Person.create!(name: 'Father') }
@@ -378,6 +411,63 @@ module Ransack
             expect(s.result.to_a).to eq [p]
           end
 
+          if ::ActiveRecord::VERSION::MAJOR >= 7 && ActiveRecord::Base.respond_to?(:normalizes)
+            context 'with ActiveRecord::normalizes' do
+              around(:each) do |example|
+                # Create a temporary model class with normalization for testing
+                test_class = Class.new(ActiveRecord::Base) do
+                  self.table_name = 'people'
+                  normalizes :name, with: ->(name) { name.gsub(/[^a-z0-9]/, '_') }
+
+                  def self.ransackable_attributes(auth_object = nil)
+                    Person.ransackable_attributes(auth_object)
+                  end
+
+                  def self.name
+                    'TestPersonWithNormalization'
+                  end
+                end
+
+                stub_const('TestPersonWithNormalization', test_class)
+                example.run
+              end
+
+              it 'should not apply normalization to LIKE wildcards for cont predicate' do
+                # Create a person with characters that would be normalized
+                p = TestPersonWithNormalization.create!(name: 'foo%bar')
+                expect(p.reload.name).to eq('foo_bar') # Verify normalization happened on storage
+
+                # Search should find the person using the original search term
+                s = TestPersonWithNormalization.ransack(name_cont: 'foo')
+                expect(s.result.to_a).to eq [p]
+
+                # Verify the SQL contains proper LIKE wildcards, not normalized ones
+                sql = s.result.to_sql
+                expect(sql).to include("LIKE '%foo%'")
+                expect(sql).not_to include("LIKE '_foo_'")
+              end
+
+              it 'should not apply normalization to LIKE wildcards for other LIKE predicates' do
+                p = TestPersonWithNormalization.create!(name: 'foo%bar')
+
+                # Test start predicate
+                s = TestPersonWithNormalization.ransack(name_start: 'foo')
+                expect(s.result.to_a).to eq [p]
+                expect(s.result.to_sql).to include("LIKE 'foo%'")
+
+                # Test end predicate  
+                s = TestPersonWithNormalization.ransack(name_end: 'bar')
+                expect(s.result.to_a).to eq [p]
+                expect(s.result.to_sql).to include("LIKE '%bar'")
+
+                # Test i_cont predicate
+                s = TestPersonWithNormalization.ransack(name_i_cont: 'FOO')
+                expect(s.result.to_a).to eq [p]
+                expect(s.result.to_sql).to include("LIKE '%foo%'")
+              end
+            end
+          end
+
           context 'searching by underscores' do
             # when escaping is supported right in LIKE expression without adding extra expressions
             def self.simple_escaping?
@@ -412,6 +502,15 @@ module Ransack
               expect(s.result.map(&:id)).to eq [3, 2, 1]
             end
 
+            it 'should function correctly with HABTM associations' do
+              article = Article.first
+              tag = article.tags.first
+              s = Person.ransack(article_tags_in: [tag.id])
+
+              expect(s.result.count).to be 1
+              expect(s.result.map(&:id)).to eq [article.person.id]
+            end
+
             it 'should function correctly when passing an array of strings' do
               a, b = Person.select(:id).order(:id).limit(2).map { |a| a.id.to_s }
 
@@ -630,6 +729,44 @@ module Ransack
             end
           end
 
+          context 'ransacker with different types' do
+            it 'handles string type ransacker correctly' do
+              s = Person.ransack(name_case_insensitive_eq: 'test')
+              expect(s.result.to_sql).to match(/LOWER\(.*\) = 'test'/)
+            end
+
+            it 'handles integer type ransacker correctly' do
+              s = Person.ransack(sql_literal_id_eq: 1)
+              expect(s.result.to_sql).to match(/people\.id = 1/)
+            end
+          end
+
+          context 'ransacker with formatter returning nil' do
+            it 'handles formatter returning nil gracefully' do
+              # This tests the edge case where a formatter might return nil
+              s = Person.ransack(article_tags_eq: 999999) # Non-existent tag ID
+              expect { s.result.to_sql }.not_to raise_error
+            end
+          end
+
+          context 'ransacker with array formatters' do
+            it 'handles array_people_ids formatter correctly' do
+              person1 = Person.create!(name: 'Test1')
+              person2 = Person.create!(name: 'Test2')
+              
+              s = Person.ransack(array_people_ids_eq: 'test')
+              expect { s.result }.not_to raise_error
+            end
+
+            it 'handles array_where_people_ids formatter correctly' do
+              person1 = Person.create!(name: 'Test1')
+              person2 = Person.create!(name: 'Test2')
+              
+              s = Person.ransack(array_where_people_ids_eq: [person1.id, person2.id])
+              expect { s.result }.not_to raise_error
+            end
+          end
+
           context 'regular sorting' do
             it 'allows sort by desc' do
               search = Person.ransack(sorts: ['name desc'])

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

@@ -97,6 +97,62 @@ module Ransack
 
             expect(search.result.to_sql).to match /.comments.\..person_id. = .people.\..id./
           end
+
+          it 'handles Arel::Nodes::And with children' do
+            # Create a mock Arel::Nodes::And with children for testing
+            search = Search.new(Person, { articles_title_not_eq: 'some_title', articles_body_not_eq: 'some_body' }, 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 'correctly extracts correlated key from complex AND conditions' do
+            # Test with multiple nested conditions to ensure the children traversal works
+            search = Search.new(
+              Person,
+              {
+                articles_title_not_eq: 'title',
+                articles_body_not_eq: 'body',
+                articles_published_eq: true
+              },
+              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 polymorphic & default_scope when predicate is not_cont_all' do
+            search = Search.new(Article,
+             g: [
+               {
+                 m: "and",
+                 c: [
+                   {
+                     a: ["recent_notes_note"],
+                     p: "not_eq",
+                     v: ["some_note"],
+                   }
+                 ]
+               }
+             ],
+            )
+
+            expect(search.result.to_sql).to match /(.notes.\..note. != \'some_note\')/
+          end
         end
 
         describe 'sharing context across searches' do
@@ -141,6 +197,22 @@ module Ransack
           expect(attribute.relation.table_alias).to be_nil
         end
 
+        describe '#type_for' do
+          it 'returns nil when column does not exist instead of raising NoMethodError' do
+            # Create a mock attribute that references a non-existent column
+            mock_attr = double('attribute')
+            allow(mock_attr).to receive(:valid?).and_return(true)
+
+            mock_arel_attr = double('arel_attribute')
+            allow(mock_arel_attr).to receive(:relation).and_return(Person.arel_table)
+            allow(mock_arel_attr).to receive(:name).and_return('nonexistent_column')
+            allow(mock_attr).to receive(:arel_attribute).and_return(mock_arel_attr)
+            allow(mock_attr).to receive(:klass).and_return(Person)
+
+            # This should return nil instead of raising an error
+            expect(subject.type_for(mock_attr)).to be_nil
+          end
+        end
       end
     end
   end

data/spec/ransack/helpers/form_builder_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 module Ransack
   module Helpers
     describe FormBuilder do
-
       router = ActionDispatch::Routing::RouteSet.new
       router.draw do
         resources :people, :comments, :notes
@@ -165,7 +164,6 @@ module Ransack
         def date_select_html(val)
           %(<option value="#{val}" selected="selected">#{val}</option>)
         end
-
     end
   end
 end

data/spec/ransack/helpers/form_helper_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 module Ransack
   module Helpers
     describe FormHelper do
-
       router = ActionDispatch::Routing::RouteSet.new
       router.draw do
         resources :people, :notes
@@ -458,9 +457,7 @@ module Ransack
       end
 
       context 'view has existing parameters' do
-
         describe '#sort_link should not remove existing params' do
-
           before { @controller.view_context.params[:exist] = 'existing' }
 
           subject {
@@ -478,7 +475,6 @@ module Ransack
         end
 
         describe '#sort_url should not remove existing params' do
-
           before { @controller.view_context.params[:exist] = 'existing' }
 
           subject {
@@ -496,12 +492,12 @@ module Ransack
         end
 
         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' }
               ) }
+
             before { @controller.instance_variable_set(:@params, params) }
 
             it {
@@ -517,6 +513,7 @@ module Ransack
             let(:params) { ActionController::Parameters.new(
               { q: { name_eq: 'TEST' }, controller: 'people' }
               ) }
+
             before { @controller.instance_variable_set(:@params, params) }
 
             it {
@@ -533,6 +530,7 @@ module Ransack
               ActionController::Parameters.new(
                 { 'q' => { name_eq: 'Test2' }, controller: 'people' }
                 ) }
+
             before { @controller.instance_variable_set(:@params, params) }
 
             it {
@@ -549,6 +547,7 @@ module Ransack
               ActionController::Parameters.new(
                 { 'q' => { name_eq: 'Test2' }, controller: 'people' }
                 ) }
+
             before { @controller.instance_variable_set(:@params, params) }
 
             it {
@@ -850,12 +849,227 @@ module Ransack
         before do
           Ransack.configure { |c| c.search_key = :example }
         end
+        after do
+          Ransack.configure { |c| c.search_key = :q }
+        end
         subject {
           @controller.view_context
           .search_form_for(Person.ransack) { |f| f.text_field :name_eq }
         }
         it { should match /example_name_eq/ }
       end
+
+      describe '#search_form_with with default format' do
+        subject { @controller.view_context
+          .search_form_with(model: Person.ransack) {} }
+        it { should match /action="\/people"/ }
+      end
+
+      describe '#search_form_with with pdf format' do
+        subject {
+          @controller.view_context
+          .search_form_with(model: Person.ransack, format: :pdf) {}
+        }
+        it { should match /action="\/people.pdf"/ }
+      end
+
+      describe '#search_form_with with json format' do
+        subject {
+          @controller.view_context
+          .search_form_with(model: Person.ransack, format: :json) {}
+        }
+        it { should match /action="\/people.json"/ }
+      end
+
+      describe '#search_form_with with an array of routes' do
+        subject {
+          @controller.view_context
+          .search_form_with(model: [:admin, Comment.ransack]) {}
+        }
+        it { should match /action="\/admin\/comments"/ }
+      end
+
+      describe '#search_form_with with custom default search key' do
+        before do
+          Ransack.configure { |c| c.search_key = :example }
+        end
+        after do
+          Ransack.configure { |c| c.search_key = :q }
+        end
+        subject {
+          @controller.view_context
+          .search_form_with(model: Person.ransack) { |f| f.text_field :name_eq }
+        }
+        it { should match /example\[name_eq\]/ }
+      end
+
+      describe '#search_form_with without Ransack::Search object' do
+        it 'raises ArgumentError' do
+          expect {
+            @controller.view_context.search_form_with(model: "not a search object") {}
+          }.to raise_error(ArgumentError, 'No Ransack::Search object was provided to search_form_with!')
+        end
+      end
+
+      describe '#turbo_search_form_for with default options' do
+        subject {
+          @controller.view_context
+          .turbo_search_form_for(Person.ransack) {}
+        }
+        it { should match /action="\/people"/ }
+        it { should match /method="post"/ }
+        it { should match /data-turbo-action="advance"/ }
+      end
+
+      describe '#turbo_search_form_for with custom method' do
+        subject {
+          @controller.view_context
+          .turbo_search_form_for(Person.ransack, method: :patch) {}
+        }
+        it { should match /method="post"/ }
+        it { should match /name="_method" value="patch"/ }
+        it { should match /data-turbo-action="advance"/ }
+      end
+
+      describe '#turbo_search_form_for with turbo_frame' do
+        subject {
+          @controller.view_context
+          .turbo_search_form_for(Person.ransack, turbo_frame: 'search_results') {}
+        }
+        it { should match /data-turbo-frame="search_results"/ }
+      end
+
+      describe '#turbo_search_form_for with custom turbo_action' do
+        subject {
+          @controller.view_context
+          .turbo_search_form_for(Person.ransack, turbo_action: 'replace') {}
+        }
+        it { should match /data-turbo-action="replace"/ }
+      end
+
+      describe '#turbo_search_form_for with format' do
+        subject {
+          @controller.view_context
+          .turbo_search_form_for(Person.ransack, format: :json) {}
+        }
+        it { should match /action="\/people.json"/ }
+      end
+
+      describe '#turbo_search_form_for with array of routes' do
+        subject {
+          @controller.view_context
+          .turbo_search_form_for([:admin, Comment.ransack]) {}
+        }
+        it { should match /action="\/admin\/comments"/ }
+      end
+
+      describe '#turbo_search_form_for with custom search key' do
+        before do
+          Ransack.configure { |c| c.search_key = :example }
+        end
+        after do
+          Ransack.configure { |c| c.search_key = :q }
+        end
+        subject {
+          @controller.view_context
+          .turbo_search_form_for(Person.ransack) { |f| f.text_field :name_eq }
+        }
+        it { should match /example_name_eq/ }
+      end
+
+      describe '#turbo_search_form_for without Ransack::Search object' do
+        it 'raises ArgumentError' do
+          expect {
+            @controller.view_context.turbo_search_form_for("not a search object") {}
+          }.to raise_error(ArgumentError, 'No Ransack::Search object was provided to turbo_search_form_for!')
+        end
+      end
+
+      describe 'private helper methods' do
+        let(:helper) { @controller.view_context }
+        let(:search) { Person.ransack }
+
+        describe '#build_turbo_options' do
+          it 'builds turbo options with frame' do
+            options = { turbo_frame: 'results', turbo_action: 'replace' }
+            result = helper.send(:build_turbo_options, options)
+            expect(result).to eq({
+              data: {
+                turbo_frame: 'results',
+                turbo_action: 'replace'
+              }
+            })
+            expect(options).to be_empty
+          end
+
+          it 'builds turbo options without frame' do
+            options = { turbo_action: 'advance' }
+            result = helper.send(:build_turbo_options, options)
+            expect(result).to eq({ data: { turbo_action: 'advance' } })
+          end
+
+          it 'uses default turbo action' do
+            options = {}
+            result = helper.send(:build_turbo_options, options)
+            expect(result).to eq({ data: { turbo_action: 'advance' } })
+          end
+        end
+
+        describe '#build_html_options' do
+          it 'builds HTML options with correct method' do
+            options = { class: 'custom' }
+            result = helper.send(:build_html_options, search, options, :post)
+            expect(result[:method]).to eq(:post)
+            expect(result[:class]).to include('custom')
+          end
+        end
+
+        describe '#extract_search_and_set_url' do
+          it 'extracts search from Ransack::Search object' do
+            options = {}
+            result = helper.send(:extract_search_and_set_url, search, options, 'search_form_for')
+            expect(result).to eq(search)
+            expect(options[:url]).to match(/people/)
+          end
+
+          it 'extracts search from array with Search object' do
+            options = {}
+            comment_search = Comment.ransack
+            result = helper.send(:extract_search_and_set_url, [:admin, comment_search], options, 'search_form_for')
+            expect(result).to eq(comment_search)
+            expect(options[:url]).to match(/admin/)
+          end
+
+          it 'raises error for invalid record with correct method name' do
+            options = {}
+            expect {
+              helper.send(:extract_search_and_set_url, "invalid", options, 'turbo_search_form_for')
+            }.to raise_error(ArgumentError, 'No Ransack::Search object was provided to turbo_search_form_for!')
+          end
+
+          it 'extracts search from Ransack::Search object for search_form_with' do
+            options = {}
+            result = helper.send(:extract_search_and_set_url, search, options, 'search_form_with')
+            expect(result).to eq(search)
+            expect(options[:url]).to match(/people/)
+          end
+
+          it 'extracts search from array with Search object for search_form_with' do
+            options = {}
+            comment_search = Comment.ransack
+            result = helper.send(:extract_search_and_set_url, [:admin, comment_search], options, 'search_form_with')
+            expect(result).to eq(comment_search)
+            expect(options[:url]).to match(/admin/)
+          end
+
+          it 'raises error for invalid record with correct method name for search_form_with' do
+            options = {}
+            expect {
+              helper.send(:extract_search_and_set_url, "invalid", options, 'search_form_with')
+            }.to raise_error(ArgumentError, 'No Ransack::Search object was provided to search_form_with!')
+          end
+        end
+      end
     end
   end
 end

data/spec/ransack/invalid_search_error_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Ransack
+  describe InvalidSearchError do
+    it 'inherits from ArgumentError' do
+      expect(InvalidSearchError.superclass).to eq(ArgumentError)
+    end
+
+    it 'can be instantiated with a message' do
+      error = InvalidSearchError.new('Test error message')
+      expect(error.message).to eq('Test error message')
+    end
+
+    it 'can be instantiated without a message' do
+      error = InvalidSearchError.new
+      expect(error.message).to eq('Ransack::InvalidSearchError')
+    end
+
+    it 'can be raised and caught' do
+      expect { raise InvalidSearchError.new('Test') }.to raise_error(InvalidSearchError, 'Test')
+    end
+
+    it 'can be raised and caught as ArgumentError' do
+      expect { raise InvalidSearchError.new('Test') }.to raise_error(ArgumentError, 'Test')
+    end
+  end
+end