ransack 4.3.0 → 4.4.0

data/spec/ransack/nodes/condition_spec.rb

@@ -99,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

data/spec/ransack/search_spec.rb

@@ -178,7 +178,6 @@ module Ransack
         #     AND "articles"."title" = 'Test' AND "articles"."published" = 't' AND ('default_scope' = 'default_scope')
         # ) ORDER BY "people"."id" DESC
 
-        pending("spec should pass, but I do not know how/where to fix lib code")
         s = Search.new(Person, published_articles_title_not_eq: 'Test')
         expect(s.result.to_sql).to include 'default_scope'
         expect(s.result.to_sql).to include 'published'
@@ -337,18 +336,90 @@ module Ransack
         end
       end
 
+      context "ransackable_scope with array arguments" do
+        around(:each) do |example|
+          Person.define_singleton_method(:domestic) do |countries|
+            self.where(name: countries)
+          end
+
+          Person.define_singleton_method(:flexible_scope) do |*args|
+            self.where(id: args)
+          end
+
+          Person.define_singleton_method(:two_param_scope) do |param1, param2|
+            self.where(name: param1, id: param2)
+          end
+
+          begin
+            example.run
+          ensure
+            Person.singleton_class.undef_method :domestic
+            Person.singleton_class.undef_method :flexible_scope
+            Person.singleton_class.undef_method :two_param_scope
+          end
+        end
+
+        it "handles scopes that take arrays as single arguments (arity 1)" do
+          allow(Person).to receive(:ransackable_scopes)
+            .and_return(Person.ransackable_scopes + [:domestic])
+
+          # This should not raise ArgumentError
+          expect {
+            s = Search.new(Person, domestic: ['US', 'JP'])
+            s.result # This triggers the actual scope call
+          }.not_to raise_error
+
+          s = Search.new(Person, domestic: ['US', 'JP'])
+          expect(s.instance_variable_get(:@scope_args)["domestic"]).to eq("US")
+        end
+
+        it "handles scopes with flexible arity (negative arity)" do
+          allow(Person).to receive(:ransackable_scopes)
+            .and_return(Person.ransackable_scopes + [:flexible_scope])
+
+          expect {
+            s = Search.new(Person, flexible_scope: ['US', 'JP'])
+            s.result
+          }.not_to raise_error
+        end
+
+        it "handles scopes with arity > 1" do
+          allow(Person).to receive(:ransackable_scopes)
+            .and_return(Person.ransackable_scopes + [:two_param_scope])
+
+          expect {
+            s = Search.new(Person, two_param_scope: ['param1', 'param2'])
+            s.result
+          }.not_to raise_error
+        end
+
+        it "still supports the workaround with nested arrays" do
+          allow(Person).to receive(:ransackable_scopes)
+            .and_return(Person.ransackable_scopes + [:domestic])
+
+          # The workaround from the issue should still work
+          expect {
+            s = Search.new(Person, domestic: [['US', 'JP']])
+            s.result
+          }.not_to raise_error
+        end
+      end
     end
 
     describe '#result' do
       let(:people_name_field) {
         "#{quote_table_name("people")}.#{quote_column_name("name")}"
       }
+      let(:people_temperament_field) {
+        "#{quote_table_name("people")}.#{quote_column_name("temperament")}"
+      }
       let(:children_people_name_field) {
         "#{quote_table_name("children_people")}.#{quote_column_name("name")}"
       }
       let(:notable_type_field) {
         "#{quote_table_name("notes")}.#{quote_column_name("notable_type")}"
       }
+
       it 'evaluates conditions contextually' do
         s = Search.new(Person, children_name_eq: 'Ernie')
         expect(s.result).to be_an ActiveRecord::Relation
@@ -356,6 +427,36 @@ module Ransack
           children_people_name_field} = 'Ernie'/
       end
 
+      context 'when evaluating enums' do
+        before do
+          Person.take.update_attribute(:temperament, 'choleric')
+        end
+
+        it 'evaluates enum key correctly' do
+          s = Search.new(Person, temperament_eq: 'choleric')
+
+          expect(s.result.to_sql).not_to match /#{
+          people_temperament_field} = 0/
+
+          expect(s.result.to_sql).to match /#{
+          people_temperament_field} = #{Person.temperaments[:choleric]}/
+
+          expect(s.result).not_to be_empty
+        end
+
+        it 'evaluates enum value correctly' do
+          s = Search.new(Person, temperament_eq: Person.temperaments[:choleric])
+
+          expect(s.result.to_sql).not_to match /#{
+          people_temperament_field} = 0/
+
+          expect(s.result.to_sql).to match /#{
+          people_temperament_field} = #{Person.temperaments[:choleric]}/
+
+          expect(s.result).not_to be_empty
+        end
+      end
+
       it 'use appropriate table alias' do
         s = Search.new(Person, {
           name_eq: "person_name_query",
@@ -479,6 +580,11 @@ module Ransack
         @s = Search.new(Person)
       end
 
+      it 'doesn\'t creates sorts' do
+        @s.sorts = ''
+        expect(@s.sorts.size).to eq(0)
+      end
+
       it 'creates sorts based on a single attribute/direction' do
         @s.sorts = 'id desc'
         expect(@s.sorts.size).to eq(1)

data/spec/ransack/translate_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Ransack
   describe Translate do
-
     describe '.attribute' do
       it 'translate namespaced attribute like AR does' do
         ar_translation = ::Namespace::Article.human_attribute_name(:title)

data/spec/spec_helper.rb

@@ -1,13 +1,12 @@
-require 'machinist/active_record'
-require 'polyamorous/polyamorous'
+require 'ransack'
 require 'sham'
 require 'faker'
-require 'ransack'
 require 'action_controller'
 require 'ransack/helpers'
 require 'pry'
 require 'simplecov'
 require 'byebug'
+require 'machinist/active_record'
 
 SimpleCov.start
 I18n.enforce_available_locales = false

data/spec/support/schema.rb

@@ -81,6 +81,8 @@ class Person < ApplicationRecord
   scope :sort_by_reverse_name_asc, lambda { order(Arel.sql("REVERSE(name) ASC")) }
   scope :sort_by_reverse_name_desc, lambda { order("REVERSE(name) DESC") }
 
+  enum :temperament, { sanguine: 1, choleric: 2, melancholic: 3, phlegmatic: 4 }
+
   alias_attribute :full_name, :name
 
   ransack_alias :term, :name_or_email
@@ -138,6 +140,17 @@ class Person < ApplicationRecord
     Arel.sql(query)
   end
 
+  ransacker :article_tags, formatter: proc { |id|
+    if Tag.exists?(id)
+      joins(articles: :tags)
+        .where(tags: { id: id })
+        .distinct
+        .select(:id).arel
+    end
+  } do |parent|
+    parent.table[:id]
+  end
+
   def self.ransackable_attributes(auth_object = nil)
     if auth_object == :admin
       authorizable_ransackable_attributes - ['only_sort']
@@ -163,6 +176,7 @@ class Article < ApplicationRecord
   has_many :comments
   has_and_belongs_to_many :tags
   has_many :notes, as: :notable
+  has_many :recent_notes, as: :notable
 
   alias_attribute :content, :body
 
@@ -232,18 +246,28 @@ end
 class Comment < ApplicationRecord
   belongs_to :article
   belongs_to :person
+  has_and_belongs_to_many :tags
 
   default_scope { where(disabled: false) }
 end
 
 class Tag < ApplicationRecord
   has_and_belongs_to_many :articles
+  has_and_belongs_to_many :comments
 end
 
 class Note < ApplicationRecord
   belongs_to :notable, polymorphic: true
 end
 
+class RecentNote < ApplicationRecord
+  DEFAULT_NOTABLE_ID = 1
+  self.table_name = "notes"
+  default_scope { where(notable_id: DEFAULT_NOTABLE_ID) }
+
+  belongs_to :notable, polymorphic: true
+end
+
 class Account < ApplicationRecord
   belongs_to :agent_account, class_name: "Account"
   belongs_to :trade_account, class_name: "Account"
@@ -278,6 +302,7 @@ module Schema
         t.string   :new_start
         t.string   :stop_end
         t.integer  :salary
+        t.integer  :temperament
         t.date     :life_start
         t.boolean  :awesome, default: false
         t.boolean  :terms_and_conditions, default: false
@@ -310,6 +335,11 @@ module Schema
         t.integer  :tag_id
       end
 
+      create_table :comments_tags, force: true, id: false do |t|
+        t.integer  :comment_id
+        t.integer  :tag_id
+      end
+
       create_table :notes, force: true do |t|
         t.integer  :notable_id
         t.string   :notable_type