ransack 4.1.1 → 4.4.0

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/nodes/condition_spec.rb

@@ -64,6 +64,7 @@ module Ransack
           end
 
           specify { expect { subject }.to raise_error ArgumentError }
+          specify { expect { subject }.to raise_error InvalidSearchError }
         end
 
         context "when ignore_unknown_conditions is true" do
@@ -98,6 +99,235 @@ module Ransack
           specify { expect(subject).to eq Condition.extract(Context.for(Person), 'full_name_eq', Person.first.name) }
         end
       end
+
+      context 'with wildcard string values' do
+        it 'properly quotes values with wildcards for LIKE predicates' do
+          ransack_hash = { name_cont: 'test%' }
+          sql = Person.ransack(ransack_hash).result.to_sql
+
+          # The % should be properly quoted in the SQL
+          case ActiveRecord::Base.connection.adapter_name
+          when "Mysql2"
+            expect(sql).to include("LIKE '%test\\\\%%'")
+            expect(sql).not_to include("NOT LIKE '%test\\\\%%'")
+          when "PostGIS", "PostgreSQL"
+            expect(sql).to include("ILIKE '%test\\%%'")
+            expect(sql).not_to include("NOT ILIKE '%test\\%%'")
+          else
+            expect(sql).to include("LIKE '%test%%'")
+            expect(sql).not_to include("NOT LIKE '%test%%'")
+          end
+        end
+
+        it 'properly quotes values with wildcards for NOT LIKE predicates' do
+          ransack_hash = { name_not_cont: 'test%' }
+          sql = Person.ransack(ransack_hash).result.to_sql
+
+          # The % should be properly quoted in the SQL
+          case ActiveRecord::Base.connection.adapter_name
+          when "Mysql2"
+            expect(sql).to include("NOT LIKE '%test\\\\%%'")
+          when "PostGIS", "PostgreSQL"
+            expect(sql).to include("NOT ILIKE '%test\\%%'")
+          else
+            expect(sql).to include("NOT LIKE '%test%%'")
+          end
+        end
+      end
+
+      context 'with negative conditions on associations' do
+        it 'handles not_null predicate with true value correctly' do
+          ransack_hash = { comments_id_not_null: true }
+          sql = Person.ransack(ransack_hash).result.to_sql
+
+          # Should generate an IN query with IS NOT NULL condition
+          expect(sql).to include('IN (')
+          expect(sql).to include('IS NOT NULL')
+          expect(sql).not_to include('IS NULL')
+        end
+
+        it 'handles not_null predicate with false value correctly' do
+          ransack_hash = { comments_id_not_null: false }
+          sql = Person.ransack(ransack_hash).result.to_sql
+
+          # Should generate a NOT IN query with IS NULL condition
+          expect(sql).to include('NOT IN (')
+          expect(sql).to include('IS NULL')
+          expect(sql).not_to include('IS NOT NULL')
+        end
+
+        it 'handles not_cont predicate correctly' do
+          ransack_hash = { comments_body_not_cont: 'test' }
+          sql = Person.ransack(ransack_hash).result.to_sql
+
+          # Should generate a NOT IN query with LIKE condition (not NOT LIKE)
+          expect(sql).to include('NOT IN (')
+          expect(sql).to include("LIKE '%test%'")
+          expect(sql).not_to include("NOT LIKE '%test%'")
+        end
+      end
+
+      context 'with nested conditions' do
+        it 'correctly identifies non-nested conditions' do
+          condition = Condition.extract(
+            Context.for(Person), 'name_eq', 'Test'
+          )
+
+          # Create a mock parent table
+          parent_table = Person.arel_table
+
+          # Get the attribute name and make sure it starts with the table name
+          attribute = condition.attributes.first
+          expect(attribute.name).to eq('name')
+          expect(parent_table.name).to eq('people')
+
+          # The method should return false because 'name' doesn't start with 'people'
+          result = condition.send(:not_nested_condition, attribute, parent_table)
+          expect(result).to be false
+        end
+
+        it 'correctly identifies truly non-nested conditions when attribute name starts with table name' do
+          # Create a condition with an attribute that starts with the table name
+          condition = Condition.extract(
+            Context.for(Person), 'name_eq', 'Test'
+          )
+
+          # Modify the attribute name to start with the table name for testing purposes
+          attribute = condition.attributes.first
+          allow(attribute).to receive(:name).and_return('people_name')
+
+          # Create a parent table
+          parent_table = Person.arel_table
+
+          # Now the method should return true because 'people_name' starts with 'people'
+          result = condition.send(:not_nested_condition, attribute, parent_table)
+          expect(result).to be true
+        end
+
+        it 'correctly identifies nested conditions' do
+          condition = Condition.extract(
+            Context.for(Person), 'articles_title_eq', 'Test'
+          )
+
+          # Create a mock table alias
+          parent_table = Arel::Nodes::TableAlias.new(
+            Article.arel_table,
+            Article.arel_table
+          )
+
+          # Access the private method using send
+          result = condition.send(:not_nested_condition, condition.attributes.first, parent_table)
+
+          # Should return false for nested condition
+          expect(result).to be false
+        end
+      end
+
+      context 'with polymorphic associations and not_in predicate' do
+        before do
+          # Define test models for polymorphic associations
+          class ::TestTask < ActiveRecord::Base
+            self.table_name = 'tasks'
+            has_many :follows, primary_key: :uid, inverse_of: :followed, foreign_key: :followed_uid, class_name: 'TestFollow'
+            has_many :users, through: :follows, source: :follower, source_type: 'TestUser'
+
+            # Add ransackable_attributes method
+            def self.ransackable_attributes(auth_object = nil)
+              ["created_at", "id", "name", "uid", "updated_at"]
+            end
+
+            # Add ransackable_associations method
+            def self.ransackable_associations(auth_object = nil)
+              ["follows", "users"]
+            end
+          end
+
+          class ::TestFollow < ActiveRecord::Base
+            self.table_name = 'follows'
+            belongs_to :follower, polymorphic: true, foreign_key: :follower_uid, primary_key: :uid
+            belongs_to :followed, polymorphic: true, foreign_key: :followed_uid, primary_key: :uid
+
+            # Add ransackable_attributes method
+            def self.ransackable_attributes(auth_object = nil)
+              ["created_at", "followed_type", "followed_uid", "follower_type", "follower_uid", "id", "updated_at"]
+            end
+
+            # Add ransackable_associations method
+            def self.ransackable_associations(auth_object = nil)
+              ["followed", "follower"]
+            end
+          end
+
+          class ::TestUser < ActiveRecord::Base
+            self.table_name = 'users'
+            has_many :follows, primary_key: :uid, inverse_of: :follower, foreign_key: :follower_uid, class_name: 'TestFollow'
+            has_many :tasks, through: :follows, source: :followed, source_type: 'TestTask'
+
+            # Add ransackable_attributes method
+            def self.ransackable_attributes(auth_object = nil)
+              ["created_at", "id", "name", "uid", "updated_at"]
+            end
+
+            # Add ransackable_associations method
+            def self.ransackable_associations(auth_object = nil)
+              ["follows", "tasks"]
+            end
+          end
+
+          # Create tables if they don't exist
+          ActiveRecord::Base.connection.create_table(:tasks, force: true) do |t|
+            t.string :uid
+            t.string :name
+            t.timestamps null: false
+          end
+
+          ActiveRecord::Base.connection.create_table(:follows, force: true) do |t|
+            t.string :followed_uid, null: false
+            t.string :followed_type, null: false
+            t.string :follower_uid, null: false
+            t.string :follower_type, null: false
+            t.timestamps null: false
+            t.index [:followed_uid, :followed_type]
+            t.index [:follower_uid, :follower_type]
+          end
+
+          ActiveRecord::Base.connection.create_table(:users, force: true) do |t|
+            t.string :uid
+            t.string :name
+            t.timestamps null: false
+          end
+        end
+
+        after do
+          # Clean up test models and tables
+          Object.send(:remove_const, :TestTask)
+          Object.send(:remove_const, :TestFollow)
+          Object.send(:remove_const, :TestUser)
+
+          ActiveRecord::Base.connection.drop_table(:tasks, if_exists: true)
+          ActiveRecord::Base.connection.drop_table(:follows, if_exists: true)
+          ActiveRecord::Base.connection.drop_table(:users, if_exists: true)
+        end
+
+        it 'correctly handles not_in predicate with polymorphic associations' do
+          # Create the search
+          search = TestTask.ransack(users_uid_not_in: ['uid_example'])
+          sql = search.result.to_sql
+
+          # Verify the SQL contains the expected NOT IN clause
+          expect(sql).to include('NOT IN')
+          expect(sql).to include("follower_uid")
+          expect(sql).to include("followed_uid")
+          expect(sql).to include("'uid_example'")
+
+          # The SQL should include a reference to tasks.uid
+          expect(sql).to include("tasks")
+          expect(sql).to include("uid")
+
+          # The SQL should include a reference to follows table
+          expect(sql).to include("follows")
+        end
+      end
     end
   end
 end

data/spec/ransack/nodes/grouping_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 module Ransack
   module Nodes
     describe Grouping do
-
       before do
         @g = 1
       end
@@ -66,6 +65,7 @@ module Ransack
               }
             }
           end
+
           before { subject.conditions = conditions }
 
           it 'expect duplicates to be removed' do
@@ -98,6 +98,7 @@ module Ransack
               }
             }
           end
+
           before { subject.conditions = conditions }
 
           it 'expect them to be parsed as different and not as duplicates' do
@@ -105,7 +106,6 @@ module Ransack
           end
         end
       end
-
     end
   end
 end

data/spec/ransack/nodes/value_spec.rb

@@ -71,6 +71,18 @@ module Ransack
         end
       end
 
+      [[], ["12"], ["101.5"]].each do |value|
+        context "with an array value (#{value.inspect})" do
+          let(:raw_value) { value }
+
+          it "should cast to integer as nil" do
+            result = subject.cast(:integer)
+
+            expect(result).to be nil
+          end
+        end
+      end
+
       ["12", "101.5"].each do |value|
         context "with a float value (#{value})" do
           let(:raw_value) { value }
@@ -109,7 +121,6 @@ module Ransack
           end
         end
       end
-
     end
   end
 end

data/spec/ransack/predicate_spec.rb

@@ -5,7 +5,6 @@ module Ransack
   FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
 
   describe Predicate do
-
     before do
       @s = Search.new(Person)
     end
@@ -158,9 +157,10 @@ module Ransack
 
     describe 'cont' do
       it_has_behavior 'wildcard escaping', :name_cont,
-        (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+        (case ActiveRecord::Base.connection.adapter_name
+        when "PostGIS", "PostgreSQL"
           /"people"."name" ILIKE '%\\%\\.\\_\\\\%'/
-        elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
+        when "Mysql2"
           /`people`.`name` LIKE '%\\\\%.\\\\_\\\\\\\\%'/
         else
          /"people"."name" LIKE '%%._\\%'/
@@ -177,9 +177,10 @@ module Ransack
 
     describe 'not_cont' do
       it_has_behavior 'wildcard escaping', :name_not_cont,
-        (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+        (case ActiveRecord::Base.connection.adapter_name
+        when "PostGIS", "PostgreSQL"
           /"people"."name" NOT ILIKE '%\\%\\.\\_\\\\%'/
-        elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
+        when  "Mysql2"
           /`people`.`name` NOT LIKE '%\\\\%.\\\\_\\\\\\\\%'/
         else
          /"people"."name" NOT LIKE '%%._\\%'/
@@ -196,9 +197,12 @@ module Ransack
 
     describe 'i_cont' do
       it_has_behavior 'wildcard escaping', :name_i_cont,
-        (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+        (case ActiveRecord::Base.connection.adapter_name
+        when "PostGIS"
+          /LOWER\("people"."name"\) ILIKE '%\\%\\.\\_\\\\%'/
+        when "PostgreSQL"
           /"people"."name" ILIKE '%\\%\\.\\_\\\\%'/
-        elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
+        when "Mysql2"
           /LOWER\(`people`.`name`\) LIKE '%\\\\%.\\\\_\\\\\\\\%'/
         else
          /LOWER\("people"."name"\) LIKE '%%._\\%'/
@@ -215,9 +219,12 @@ module Ransack
 
     describe 'not_i_cont' do
       it_has_behavior 'wildcard escaping', :name_not_i_cont,
-        (if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+        (case ActiveRecord::Base.connection.adapter_name
+        when "PostGIS"
+          /LOWER\("people"."name"\) NOT ILIKE '%\\%\\.\\_\\\\%'/
+        when "PostgreSQL"
           /"people"."name" NOT ILIKE '%\\%\\.\\_\\\\%'/
-        elsif ActiveRecord::Base.connection.adapter_name == "Mysql2"
+        when "Mysql2"
           /LOWER\(`people`.`name`\) NOT LIKE '%\\\\%.\\\\_\\\\\\\\%'/
         else
          /LOWER\("people"."name"\) NOT LIKE '%%._\\%'/