ransack 4.1.1 → 4.4.1

data/spec/ransack/ransacker_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Ransack
+  describe Ransacker do
+    let(:klass) { Person }
+    let(:name) { :test_ransacker }
+    let(:opts) { {} }
+
+    describe '#initialize' do
+      context 'with minimal options' do
+        subject { Ransacker.new(klass, name, opts) }
+
+        it 'sets the name' do
+          expect(subject.name).to eq(name)
+        end
+
+        it 'sets default type to string' do
+          expect(subject.type).to eq(:string)
+        end
+
+        it 'sets default args to [:parent]' do
+          expect(subject.args).to eq([:parent])
+        end
+      end
+
+      context 'with custom options' do
+        let(:opts) { { type: :integer, args: [:parent, :custom_arg], formatter: proc { |v| v.to_i } } }
+
+        subject { Ransacker.new(klass, name, opts) }
+
+        it 'sets the custom type' do
+          expect(subject.type).to eq(:integer)
+        end
+
+        it 'sets the custom args' do
+          expect(subject.args).to eq([:parent, :custom_arg])
+        end
+
+        it 'sets the formatter' do
+          expect(subject.formatter).to eq(opts[:formatter])
+        end
+      end
+
+      context 'with callable option' do
+        let(:callable) { proc { |parent| parent.table[:id] } }
+        let(:opts) { { callable: callable } }
+
+        subject { Ransacker.new(klass, name, opts) }
+
+        it 'initializes successfully' do
+          expect(subject).to be_a(Ransacker)
+        end
+      end
+    end
+
+    describe 'basic functionality' do
+      subject { Ransacker.new(klass, name, opts) }
+
+      it 'responds to required methods' do
+        expect(subject).to respond_to(:name)
+        expect(subject).to respond_to(:type)
+        expect(subject).to respond_to(:args)
+        expect(subject).to respond_to(:formatter)
+        expect(subject).to respond_to(:attr_from)
+        expect(subject).to respond_to(:call)
+      end
+    end
+  end
+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'
@@ -270,6 +269,7 @@ module Ransack
           end
 
           specify { expect { subject }.to raise_error ArgumentError }
+          specify { expect { subject }.to raise_error InvalidSearchError }
         end
 
         context 'when ignore_unknown_conditions configuration option is true' do
@@ -300,6 +300,7 @@ module Ransack
 
         context 'when ignore_unknown_conditions search parameter is false' do
           specify { expect { with_ignore_unknown_conditions_false }.to raise_error ArgumentError }
+          specify { expect { with_ignore_unknown_conditions_false }.to raise_error InvalidSearchError }
         end
 
         context 'when ignore_unknown_conditions search parameter is true' do
@@ -312,6 +313,46 @@ module Ransack
         expect { Search.new(Person, params) }.not_to change { params }
       end
 
+      context 'with empty search parameters' do
+        it 'handles completely empty parameters' do
+          search = Search.new(Person, {})
+          expect(search.result.to_sql).not_to match(/WHERE/)
+        end
+
+        it 'handles nil parameters' do
+          search = Search.new(Person, nil)
+          expect(search.result.to_sql).not_to match(/WHERE/)
+        end
+      end
+
+      context 'with whitespace-only values' do
+        before do
+          Ransack.configure { |c| c.strip_whitespace = true }
+        end
+
+        it 'removes whitespace-only values' do
+          expect_any_instance_of(Search).to receive(:build).with({})
+          Search.new(Person, name_eq: '   ')
+        end
+
+        it 'keeps values with content after whitespace stripping' do
+          expect_any_instance_of(Search).to receive(:build).with({ 'name_eq' => 'test' })
+          Search.new(Person, name_eq: '  test  ')
+        end
+      end
+
+      context 'with special characters in values' do
+        it 'handles values with special regex characters' do
+          search = Search.new(Person, name_cont: 'test[(){}^$|?*+.\\')
+          expect { search.result }.not_to raise_error
+        end
+
+        it 'handles values with SQL injection attempts' do
+          search = Search.new(Person, name_cont: "'; DROP TABLE people; --")
+          expect { search.result }.not_to raise_error
+        end
+      end
+
       context "ransackable_scope" do
         around(:each) do |example|
           Person.define_singleton_method(:name_eq) do |name|
@@ -335,6 +376,74 @@ 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
@@ -347,6 +456,7 @@ module Ransack
       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
@@ -453,7 +563,7 @@ module Ransack
 
         all_or_load, uniq_or_distinct = :load, :distinct
         expect(s.result.send(all_or_load).size)
-        .to eq(9000)
+        .to eq(8998)
         expect(s.result(distinct: true).size)
         .to eq(10)
         expect(s.result.send(all_or_load).send(uniq_or_distinct))
@@ -477,6 +587,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)
@@ -614,6 +729,18 @@ module Ransack
         expect(@s.result.first.id).to eq 1
       end
 
+      it 'raises ArgumentError when an invalid argument is sent' do
+        expect do
+          @s.sorts = 1234
+        end.to raise_error(ArgumentError,  "Invalid argument (Integer) supplied to sorts=")
+      end
+
+      it 'raises InvalidSearchError when an invalid argument is sent' do
+        expect do
+          @s.sorts = 1234
+        end.to raise_error(Ransack::InvalidSearchError,  "Invalid argument (Integer) supplied to sorts=")
+      end
+
       it "PG's sort option", if: ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" do
         default = Ransack.options.clone
 

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,38 +1,27 @@
-require 'machinist/active_record'
-require 'polyamorous/polyamorous'
-require 'sham'
-require 'faker'
 require 'ransack'
+require 'factory_bot'
+require 'faker'
 require 'action_controller'
 require 'ransack/helpers'
 require 'pry'
 require 'simplecov'
 require 'byebug'
+require 'rspec'
 
 SimpleCov.start
 I18n.enforce_available_locales = false
 Time.zone = 'Eastern Time (US & Canada)'
 I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'support', '*.yml')]
 
-Dir[File.expand_path('../{helpers,support,blueprints}/*.rb', __FILE__)]
+Dir[File.expand_path('../{helpers,support,factories}/*.rb', __FILE__)]
 .each { |f| require f }
 
 Faker::Config.random = Random.new(0)
-Sham.define do
-  name        { Faker::Name.name }
-  title       { Faker::Lorem.sentence }
-  body        { Faker::Lorem.paragraph }
-  salary      { |index| 30000 + (index * 1000) }
-  tag_name    { Faker::Lorem.words(number: 3).join(' ') }
-  note        { Faker::Lorem.words(number: 7).join(' ') }
-  only_admin  { Faker::Lorem.words(number: 3).join(' ') }
-  only_search { Faker::Lorem.words(number: 3).join(' ') }
-  only_sort   { Faker::Lorem.words(number: 3).join(' ') }
-  notable_id  { |id| id }
-end
 
 RSpec.configure do |config|
   config.alias_it_should_behave_like_to :it_has_behavior, 'has behavior'
+  
+  config.include FactoryBot::Syntax::Methods
 
   config.before(:suite) do
     message = "Running Ransack specs with #{
@@ -42,12 +31,9 @@ RSpec.configure do |config|
     line = '=' * message.length
     puts line, message, line
     Schema.create
-    SubDB::Schema.create
+    SubDB::Schema.create if defined?(SubDB)
   end
 
-  config.before(:all)   { Sham.reset(:before_all) }
-  config.before(:each)  { Sham.reset(:before_each) }
-
   config.include RansackHelper
   config.include PolyamorousHelper
 end

data/spec/support/schema.rb

@@ -1,4 +1,5 @@
 require 'active_record'
+require 'activerecord-postgis-adapter'
 
 case ENV['DB'].try(:downcase)
 when 'mysql', 'mysql2'
@@ -20,6 +21,17 @@ when 'pg', 'postgres', 'postgresql'
     host: ENV.fetch("DATABASE_HOST") { "localhost" },
     min_messages: 'warning'
   )
+when 'postgis'
+  # To test with PostGIS: `DB=postgis bundle exec rake spec`
+  ActiveRecord::Base.establish_connection(
+    adapter: 'postgis',
+    postgis_extension: 'postgis',
+    database: 'ransack',
+    username: ENV.fetch("DATABASE_USERNAME") { "postgres" },
+    password: ENV.fetch("DATABASE_PASSWORD") { "" },
+    host: ENV.fetch("DATABASE_HOST") { "localhost" },
+    min_messages: 'warning'
+  )
 else
   # Otherwise, assume SQLite3: `bundle exec rake spec`
   ActiveRecord::Base.establish_connection(
@@ -104,7 +116,7 @@ class Person < ApplicationRecord
       )
   end
 
-  ransacker :sql_literal_id do
+  ransacker :sql_literal_id, type: :integer do
     Arel.sql('people.id')
   end
 
@@ -126,6 +138,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']
@@ -151,6 +174,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
 
@@ -220,18 +244,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"
@@ -298,6 +332,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
@@ -331,23 +370,23 @@ module Schema
     end
 
     10.times do
-      person = Person.make
-      Note.make(notable: person)
+      person = FactoryBot.create(:person)
+      FactoryBot.create(:note, :for_person, notable: person)
       3.times do
-        article = Article.make(person: person)
+        article = FactoryBot.create(:article, person: person)
         3.times do
-          article.tags = [Tag.make, Tag.make, Tag.make]
+          article.tags = [FactoryBot.create(:tag), FactoryBot.create(:tag), FactoryBot.create(:tag)]
         end
-        Note.make(notable: article)
+        FactoryBot.create(:note, :for_article, notable: article)
         10.times do
-          Comment.make(article: article, person: person)
+          FactoryBot.create(:comment, article: article, person: person)
         end
       end
     end
 
-    Comment.make(
+    FactoryBot.create(:comment,
       body: 'First post!',
-      article: Article.make(title: 'Hello, world!')
+      article: FactoryBot.create(:article, title: 'Hello, world!')
     )
   end
 end