ransack 4.1.1 → 4.4.0

data/lib/ransack/nodes/condition.rb

@@ -1,3 +1,5 @@
+require 'ransack/invalid_search_error'
+
 module Ransack
   module Nodes
     class Condition < Node
@@ -38,7 +40,7 @@ module Ransack
             predicate = Predicate.named(name)
 
             unless predicate || Ransack.options[:ignore_unknown_conditions]
-              raise ArgumentError, "No valid predicate for #{key}"
+              raise InvalidSearchError, "No valid predicate for #{key}"
             end
 
             if context.present?
@@ -224,7 +226,7 @@ module Ransack
       end
 
       def casted_values_for_attribute(attr)
-        validated_values.map { |v| v.cast(predicate.type || attr.type) }
+        validated_values.map(&:cast_array)
       end
 
       def formatted_values_for_attribute(attr)
@@ -233,6 +235,9 @@ module Ransack
             val = attr.ransacker.formatter.call(val)
           end
           val = predicate.format(val)
+          if val.is_a?(String) && val.include?('%')
+            val = Arel::Nodes::Quoted.new(val)
+          end
           val
         end
         if predicate.wants_array
@@ -286,12 +291,24 @@ module Ransack
       def arel_predicate
         predicate = attributes.map { |attribute|
           association = attribute.parent
-          if negative? && attribute.associated_collection?
+          parent_table = association.table
+
+          if negative? && attribute.associated_collection? && not_nested_condition(attribute, parent_table)
             query = context.build_correlated_subquery(association)
             context.remove_association(association)
-            if self.predicate_name == 'not_null' && self.value
-              query.where(format_predicate(attribute))
-              Arel::Nodes::In.new(context.primary_key, Arel.sql(query.to_sql))
+
+            case self.predicate_name
+            when 'not_null'
+              if self.value
+                query.where(format_predicate(attribute))
+                Arel::Nodes::In.new(context.primary_key, Arel.sql(query.to_sql))
+              else
+                query.where(format_predicate(attribute).not)
+                Arel::Nodes::NotIn.new(context.primary_key, Arel.sql(query.to_sql))
+              end
+            when 'not_cont'
+              query.where(attribute.attr.matches(formatted_values_for_attribute(attribute)))
+              Arel::Nodes::NotIn.new(context.primary_key, Arel.sql(query.to_sql))
             else
               query.where(format_predicate(attribute).not)
               Arel::Nodes::NotIn.new(context.primary_key, Arel.sql(query.to_sql))
@@ -313,6 +330,10 @@ module Ransack
         predicate
       end
 
+      def not_nested_condition(attribute, parent_table)
+        parent_table.class != Arel::Nodes::TableAlias && attribute.name.starts_with?(parent_table.name)
+      end
+
       private
 
       def combinator_method
@@ -322,6 +343,13 @@ module Ransack
       def format_predicate(attribute)
         arel_pred = arel_predicate_for_attribute(attribute)
         arel_values = formatted_values_for_attribute(attribute)
+        
+        # For LIKE predicates, wrap the value in Arel::Nodes.build_quoted to prevent
+        # ActiveRecord normalization from affecting wildcard patterns
+        if like_predicate?(arel_pred)
+          arel_values = Arel::Nodes.build_quoted(arel_values)
+        end
+        
         predicate = attr_value_for_attribute(attribute).public_send(arel_pred, arel_values)
 
         if in_predicate?(predicate)
@@ -338,8 +366,12 @@ module Ransack
         predicate.class == Arel::Nodes::In || predicate.class == Arel::Nodes::NotIn
       end
 
+      def like_predicate?(arel_predicate)
+        arel_predicate == 'matches' || arel_predicate == 'does_not_match'
+      end
+
       def casted_array?(predicate)
-        predicate.value.is_a?(Array) && predicate.is_a?(Arel::Nodes::Casted)
+        predicate.is_a?(Arel::Nodes::Casted) && predicate.value.is_a?(Array)
       end
 
       def format_values_for(predicate)

data/lib/ransack/nodes/grouping.rb

@@ -53,7 +53,7 @@ module Ransack
       end
 
       def []=(key, value)
-        conditions.reject! { |c| c.key == key.to_s }
+        conditions.reject! { |c| c.key == key.to_s && c&.value == value&.value }
         self.conditions << value
       end
 

data/lib/ransack/nodes/sort.rb

@@ -8,7 +8,7 @@ module Ransack
 
       class << self
         def extract(context, str)
-          return unless str
+          return if str.blank?
           attr, direction = str.split(/\s+/, 2)
           self.new(context).build(name: attr, dir: direction)
         end

data/lib/ransack/nodes/value.rb

@@ -43,6 +43,14 @@ module Ransack
         end
       end
 
+      def cast_array
+        if value.is_a?(Array)
+          cast_to_date(value)
+        else
+          value
+        end
+      end
+
       def cast_to_date(val)
         if val.respond_to?(:to_date)
           val.to_date rescue nil
@@ -80,7 +88,7 @@ module Ransack
       end
 
       def cast_to_integer(val)
-        val.blank? ? nil : val.to_i
+        val.respond_to?(:to_i) && !val.blank? ? val.to_i : nil
       end
 
       def cast_to_float(val)

data/lib/ransack/search.rb

@@ -7,6 +7,7 @@ require 'ransack/nodes/sort'
 require 'ransack/nodes/grouping'
 require 'ransack/context'
 require 'ransack/naming'
+require 'ransack/invalid_search_error'
 
 module Ransack
   class Search
@@ -53,7 +54,7 @@ module Ransack
         elsif base.attribute_method?(key)
           base.send("#{key}=", value)
         elsif !Ransack.options[:ignore_unknown_conditions] || !@ignore_unknown_conditions
-          raise ArgumentError, "Invalid search term #{key}"
+          raise InvalidSearchError, "Invalid search term #{key}"
         end
       end
       self
@@ -68,7 +69,7 @@ module Ransack
           else
             sort = Nodes::Sort.extract(@context, sort)
           end
-          self.sorts << sort
+          self.sorts << sort if sort
         end
       when Hash
         args.each do |index, attrs|
@@ -78,7 +79,7 @@ module Ransack
       when String
         self.sorts = [args]
       else
-        raise ArgumentError,
+        raise InvalidSearchError,
         "Invalid argument (#{args.class}) supplied to sorts="
       end
     end

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = '4.1.1'
+  VERSION = '4.4.0'
 end

data/lib/ransack.rb

@@ -1,3 +1,11 @@
+require 'active_support/dependencies/autoload'
+require 'active_support/deprecation'
+require 'active_support/version'
+
+if ::ActiveSupport.version >= ::Gem::Version.new("7.1")
+  require 'active_support/deprecator'
+end
+
 require 'active_support/core_ext'
 require 'ransack/configuration'
 require 'polyamorous/polyamorous'
@@ -21,6 +29,7 @@ require 'ransack/ransacker'
 require 'ransack/translate'
 require 'ransack/active_record'
 require 'ransack/context'
+require 'ransack/version'
 
 ActiveSupport.on_load(:action_controller) do
   require 'ransack/helpers'

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,17 +123,20 @@ 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
             expect { Person.ransack('') }.to_not raise_error
           end
 
-          it 'raises exception if ransack! called with unknown condition' do
+          it 'raises ArgumentError exception if ransack! called with unknown condition' do
             expect { Person.ransack!(unknown_attr_eq: 'Ernie') }.to raise_error(ArgumentError)
           end
 
+          it 'raises InvalidSearchError exception if ransack! called with unknown condition' do
+            expect { Person.ransack!(unknown_attr_eq: 'Ernie') }.to raise_error(InvalidSearchError)
+          end
+
           it 'does not modify the parameters' do
             params = { name_eq: '' }
             expect { Person.ransack(params) }.not_to change { params }
@@ -191,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') }
@@ -374,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?
@@ -408,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 }
 

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