ransack 2.4.2 → 4.0.0

data/spec/ransack/predicate_spec.rb

@@ -35,6 +35,13 @@ module Ransack
         @s.awesome_eq = nil
         expect(@s.result.to_sql).not_to match /WHERE/
       end
+
+      it 'generates a = condition with a huge integer value' do
+        val = 123456789012345678901
+        @s.salary_eq = val
+        field = "#{quote_table_name("people")}.#{quote_column_name("salary")}"
+        expect(@s.result.to_sql).to match /#{field} = #{val}/
+      end
     end
 
     describe 'lteq' do
@@ -56,6 +63,13 @@ module Ransack
         @s.salary_lteq = nil
         expect(@s.result.to_sql).not_to match /WHERE/
       end
+
+      it 'generates a <= condition with a huge integer value' do
+        val = 123456789012345678901
+        @s.salary_lteq = val
+        field = "#{quote_table_name("people")}.#{quote_column_name("salary")}"
+        expect(@s.result.to_sql).to match /#{field} <= #{val}/
+      end
     end
 
     describe 'lt' do
@@ -77,6 +91,13 @@ module Ransack
         @s.salary_lt = nil
         expect(@s.result.to_sql).not_to match /WHERE/
       end
+
+      it 'generates a = condition with a huge integer value' do
+        val = 123456789012345678901
+        @s.salary_lt = val
+        field = "#{quote_table_name("people")}.#{quote_column_name("salary")}"
+        expect(@s.result.to_sql).to match /#{field} < #{val}/
+      end
     end
 
     describe 'gteq' do
@@ -98,6 +119,13 @@ module Ransack
         @s.salary_gteq = nil
         expect(@s.result.to_sql).not_to match /WHERE/
       end
+
+      it 'generates a >= condition with a huge integer value' do
+        val = 123456789012345678901
+        @s.salary_gteq = val
+        field = "#{quote_table_name("people")}.#{quote_column_name("salary")}"
+        expect(@s.result.to_sql).to match /#{field} >= #{val}/
+      end
     end
 
     describe 'gt' do
@@ -119,6 +147,13 @@ module Ransack
         @s.salary_gt = nil
         expect(@s.result.to_sql).not_to match /WHERE/
       end
+
+      it 'generates a > condition with a huge integer value' do
+        val = 123456789012345678901
+        @s.salary_gt = val
+        field = "#{quote_table_name("people")}.#{quote_column_name("salary")}"
+        expect(@s.result.to_sql).to match /#{field} > #{val}/
+      end
     end
 
     describe 'cont' do
@@ -368,7 +403,7 @@ module Ransack
         expect(@s.result.to_sql).to match /#{field} IS NULL/
       end
 
-      describe 'with association qeury' do
+      describe 'with association query' do
         it 'generates a value IS NOT NULL query' do
           @s.comments_id_not_null = true
           sql = @s.result.to_sql

data/spec/ransack/search_spec.rb

@@ -20,10 +20,42 @@ module Ransack
         Search.new(Person, name_eq: 'foobar')
       end
 
-      it 'strip leading & trailing whitespace before building' do
-        expect_any_instance_of(Search).to receive(:build)
-        .with({ 'name_eq' => 'foobar' })
-        Search.new(Person, name_eq: '   foobar     ')
+      context 'whitespace stripping' do
+        context 'when whitespace_strip option is true' do
+          before do
+            Ransack.configure { |c| c.strip_whitespace = true }
+          end
+
+          it 'strips leading & trailing whitespace before building' do
+            expect_any_instance_of(Search).to receive(:build)
+            .with({ 'name_eq' => 'foobar' })
+            Search.new(Person, name_eq: '   foobar     ')
+          end
+        end
+
+        context 'when whitespace_strip option is false' do
+          before do
+            Ransack.configure { |c| c.strip_whitespace = false }
+          end
+
+          it 'doesn\'t strip leading & trailing whitespace before building' do
+            expect_any_instance_of(Search).to receive(:build)
+            .with({ 'name_eq' => '   foobar     ' })
+            Search.new(Person, name_eq: '   foobar     ')
+          end
+        end
+
+        it 'strips leading & trailing whitespace when strip_whitespace search parameter is true' do
+          expect_any_instance_of(Search).to receive(:build)
+          .with({ 'name_eq' => 'foobar' })
+          Search.new(Person, { name_eq: '   foobar     ' }, { strip_whitespace: true })
+        end
+
+        it 'doesn\'t strip leading & trailing whitespace when strip_whitespace search parameter is false' do
+          expect_any_instance_of(Search).to receive(:build)
+          .with({ 'name_eq' => '   foobar     ' })
+          Search.new(Person, { name_eq: '   foobar     ' }, { strip_whitespace: false })
+        end
       end
 
       it 'removes empty suffixed conditions before building' do
@@ -280,6 +312,29 @@ module Ransack
         expect { Search.new(Person, params) }.not_to change { params }
       end
 
+      context "ransackable_scope" do
+        around(:each) do |example|
+          Person.define_singleton_method(:name_eq) do |name|
+            self.where(name: name)
+          end
+
+          begin
+            example.run
+          ensure
+            Person.singleton_class.undef_method :name_eq
+          end
+        end
+
+        it "is prioritized over base predicates" do
+          allow(Person).to receive(:ransackable_scopes)
+            .and_return(Person.ransackable_scopes + [:name_eq])
+
+          s = Search.new(Person, name_eq: "Johny")
+          expect(s.instance_variable_get(:@scope_args)["name_eq"]).to eq("Johny")
+          expect(s.base[:name_eq]).to be_nil
+        end
+      end
+
     end
 
     describe '#result' do
@@ -300,8 +355,6 @@ module Ransack
       end
 
       it 'use appropriate table alias' do
-        skip "Rails 6 regressed here, but it's fixed in 6-0-stable since https://github.com/rails/rails/commit/f9ba52477ca288e7effa5f6794ae3df3f4e982bc" if ENV["RAILS"] == "v6.0.3"
-
         s = Search.new(Person, {
           name_eq: "person_name_query",
           articles_title_eq: "person_article_title_query",
@@ -451,82 +504,109 @@ module Ransack
         expect(sort.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes/directions in array format' do
-        @s.sorts = ['id desc', { name: 'name', dir: 'asc' }]
+      it 'creates sorts based on a single alias/direction' do
+        @s.sorts = 'daddy desc'
+        expect(@s.sorts.size).to eq(1)
+        sort = @s.sorts.first
+        expect(sort).to be_a Nodes::Sort
+        expect(sort.name).to eq 'parent_name'
+        expect(sort.dir).to eq 'desc'
+      end
+
+      it 'creates sorts based on a single alias and uppercase direction' do
+        @s.sorts = 'daddy DESC'
+        expect(@s.sorts.size).to eq(1)
+        sort = @s.sorts.first
+        expect(sort).to be_a Nodes::Sort
+        expect(sort.name).to eq 'parent_name'
+        expect(sort.dir).to eq 'desc'
+      end
+
+      it 'creates sorts based on a single alias and without direction' do
+        @s.sorts = 'daddy'
+        expect(@s.sorts.size).to eq(1)
+        sort = @s.sorts.first
+        expect(sort).to be_a Nodes::Sort
+        expect(sort.name).to eq 'parent_name'
+        expect(sort.dir).to eq 'asc'
+      end
+
+      it 'creates sorts based on attributes, alias and directions in array format' do
+        @s.sorts = ['id desc', { name: 'daddy', dir: 'asc' }]
         expect(@s.sorts.size).to eq(2)
         sort1, sort2 = @s.sorts
         expect(sort1).to be_a Nodes::Sort
         expect(sort1.name).to eq 'id'
         expect(sort1.dir).to eq 'desc'
         expect(sort2).to be_a Nodes::Sort
-        expect(sort2.name).to eq 'name'
+        expect(sort2.name).to eq 'parent_name'
         expect(sort2.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and uppercase directions in array format' do
-        @s.sorts = ['id DESC', { name: 'name', dir: 'ASC' }]
+      it 'creates sorts based on attributes, alias and uppercase directions in array format' do
+        @s.sorts = ['id DESC', { name: 'daddy', dir: 'ASC' }]
         expect(@s.sorts.size).to eq(2)
         sort1, sort2 = @s.sorts
         expect(sort1).to be_a Nodes::Sort
         expect(sort1.name).to eq 'id'
         expect(sort1.dir).to eq 'desc'
         expect(sort2).to be_a Nodes::Sort
-        expect(sort2.name).to eq 'name'
+        expect(sort2.name).to eq 'parent_name'
         expect(sort2.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and different directions
+      it 'creates sorts based on attributes, alias and different directions
         in array format' do
-        @s.sorts = ['id DESC', { name: 'name', dir: nil }]
+        @s.sorts = ['id DESC', { name: 'daddy', dir: nil }]
         expect(@s.sorts.size).to eq(2)
         sort1, sort2 = @s.sorts
         expect(sort1).to be_a Nodes::Sort
         expect(sort1.name).to eq 'id'
         expect(sort1.dir).to eq 'desc'
         expect(sort2).to be_a Nodes::Sort
-        expect(sort2.name).to eq 'name'
+        expect(sort2.name).to eq 'parent_name'
         expect(sort2.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes/directions in hash format' do
+      it 'creates sorts based on attributes, alias and directions in hash format' do
         @s.sorts = {
           '0' => { name: 'id', dir: 'desc' },
-          '1' => { name: 'name', dir: 'asc' }
+          '1' => { name: 'daddy', dir: 'asc' }
         }
         expect(@s.sorts.size).to eq(2)
         expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
         id_sort = @s.sorts.detect { |s| s.name == 'id' }
-        name_sort = @s.sorts.detect { |s| s.name == 'name' }
+        daddy_sort = @s.sorts.detect { |s| s.name == 'parent_name' }
         expect(id_sort.dir).to eq 'desc'
-        expect(name_sort.dir).to eq 'asc'
+        expect(daddy_sort.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and uppercase directions
+      it 'creates sorts based on attributes, alias and uppercase directions
         in hash format' do
         @s.sorts = {
           '0' => { name: 'id', dir: 'DESC' },
-          '1' => { name: 'name', dir: 'ASC' }
+          '1' => { name: 'daddy', dir: 'ASC' }
         }
         expect(@s.sorts.size).to eq(2)
         expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
         id_sort = @s.sorts.detect { |s| s.name == 'id' }
-        name_sort = @s.sorts.detect { |s| s.name == 'name' }
+        daddy_sort = @s.sorts.detect { |s| s.name == 'parent_name' }
         expect(id_sort.dir).to eq 'desc'
-        expect(name_sort.dir).to eq 'asc'
+        expect(daddy_sort.dir).to eq 'asc'
       end
 
-      it 'creates sorts based on multiple attributes and different directions
+      it 'creates sorts based on attributes, alias and different directions
         in hash format' do
         @s.sorts = {
           '0' => { name: 'id', dir: 'DESC' },
-          '1' => { name: 'name', dir: nil }
+          '1' => { name: 'daddy', dir: nil }
         }
         expect(@s.sorts.size).to eq(2)
         expect(@s.sorts).to be_all { |s| Nodes::Sort === s }
         id_sort = @s.sorts.detect { |s| s.name == 'id' }
-        name_sort = @s.sorts.detect { |s| s.name == 'name' }
+        daddy_sort = @s.sorts.detect { |s| s.name == 'parent_name' }
         expect(id_sort.dir).to eq 'desc'
-        expect(name_sort.dir).to eq 'asc'
+        expect(daddy_sort.dir).to eq 'asc'
       end
 
       it 'overrides existing sort' do
@@ -554,6 +634,39 @@ module Ransack
 
         Ransack.options = default
       end
+
+      it "PG's sort option with double name", if: ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" do
+        default = Ransack.options.clone
+
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_first }
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC NULLS FIRST"
+        s = Search.new(Person, s: 'doubled_name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" DESC NULLS LAST"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_last }
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC NULLS LAST"
+        s = Search.new(Person, s: 'doubled_name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" DESC NULLS FIRST"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_always_first }
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC NULLS FIRST"
+        s = Search.new(Person, s: 'doubled_name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" DESC NULLS FIRST"
+
+        Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_always_last }
+        s = Search.new(Person, s: 'doubled_name asc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" ASC NULLS LAST"
+        s = Search.new(Person, s: 'doubled_name desc')
+        expect(s.result.to_sql).to eq "SELECT \"people\".* FROM \"people\" ORDER BY \"people\".\"name\" || \"people\".\"name\" DESC NULLS LAST"
+
+        Ransack.options = default
+      end
     end
 
     describe '#method_missing' do

data/spec/ransack/translate_spec.rb

@@ -8,7 +8,7 @@ module Ransack
         ar_translation = ::Namespace::Article.human_attribute_name(:title)
         ransack_translation = Ransack::Translate.attribute(
           :title,
-          :context => ::Namespace::Article.ransack.context
+          context: ::Namespace::Article.ransack.context
           )
         expect(ransack_translation).to eq ar_translation
       end

data/spec/support/schema.rb

@@ -28,7 +28,24 @@ else
   )
 end
 
-class Person < ActiveRecord::Base
+# This is just a test app with no sensitive data, so we explicitly allowlist all
+# attributes and associations for search. In general, end users should
+# explicitly authorize each model, but this shows a way to configure the
+# unrestricted default behavior of versions prior to Ransack 4.
+#
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  def self.ransackable_attributes(auth_object = nil)
+    authorizable_ransackable_attributes
+  end
+
+  def self.ransackable_associations(auth_object = nil)
+    authorizable_ransackable_associations
+  end
+end
+
+class Person < ApplicationRecord
   default_scope { order(id: :desc) }
   belongs_to :parent, class_name: 'Person', foreign_key: :parent_id
   has_many   :children, class_name: 'Person', foreign_key: :parent_id
@@ -111,9 +128,9 @@ class Person < ActiveRecord::Base
 
   def self.ransackable_attributes(auth_object = nil)
     if auth_object == :admin
-      super - ['only_sort']
+      authorizable_ransackable_attributes - ['only_sort']
     else
-      super - ['only_sort', 'only_admin']
+      authorizable_ransackable_attributes - ['only_sort', 'only_admin']
     end
   end
 
@@ -129,7 +146,7 @@ end
 class Musician < Person
 end
 
-class Article < ActiveRecord::Base
+class Article < ApplicationRecord
   belongs_to :person
   has_many :comments
   has_and_belongs_to_many :tags
@@ -138,12 +155,51 @@ class Article < ActiveRecord::Base
   alias_attribute :content, :body
 
   default_scope { where("'default_scope' = 'default_scope'") }
+  scope :latest_comment_cont, lambda { |msg|
+    join = <<-SQL
+      (LEFT OUTER JOIN (
+          SELECT
+            comments.*,
+            row_number() OVER (PARTITION BY comments.article_id ORDER BY comments.id DESC) AS rownum
+          FROM comments
+        ) AS latest_comment
+        ON latest_comment.article_id = article.id
+        AND latest_comment.rownum = 1
+      )
+    SQL
+    .squish
+
+    joins(join).where("latest_comment.body ILIKE ?", "%#{msg}%")
+  }
+
+  ransacker :title_type, formatter: lambda { |tuples|
+    title, type = JSON.parse(tuples)
+    Arel::Nodes::Grouping.new(
+      [
+        Arel::Nodes.build_quoted(title),
+        Arel::Nodes.build_quoted(type)
+      ]
+    )
+  } do |_parent|
+    articles = Article.arel_table
+    Arel::Nodes::Grouping.new(
+      %i[title type].map do |field|
+        Arel::Nodes::NamedFunction.new(
+          'COALESCE',
+          [
+            Arel::Nodes::NamedFunction.new('TRIM', [articles[field]]),
+            Arel::Nodes.build_quoted('')
+          ]
+        )
+      end
+    )
+  end
 end
 
 class StoryArticle < Article
 end
 
-class Recommendation < ActiveRecord::Base
+class Recommendation < ApplicationRecord
   belongs_to :person
   belongs_to :target_person, class_name: 'Person'
   belongs_to :article
@@ -161,21 +217,26 @@ module Namespace
   end
 end
 
-class Comment < ActiveRecord::Base
+class Comment < ApplicationRecord
   belongs_to :article
   belongs_to :person
 
   default_scope { where(disabled: false) }
 end
 
-class Tag < ActiveRecord::Base
+class Tag < ApplicationRecord
   has_and_belongs_to_many :articles
 end
 
-class Note < ActiveRecord::Base
+class Note < ApplicationRecord
   belongs_to :notable, polymorphic: true
 end
 
+class Account < ApplicationRecord
+  belongs_to :agent_account, class_name: "Account"
+  belongs_to :trade_account, class_name: "Account"
+end
+
 module Schema
   def self.create
     ActiveRecord::Migration.verbose = false
@@ -234,6 +295,11 @@ module Schema
         t.integer  :target_person_id
         t.integer  :article_id
       end
+
+      create_table :accounts, force: true do |t|
+        t.belongs_to :agent_account
+        t.belongs_to :trade_account
+      end
     end
 
     10.times do
@@ -259,7 +325,7 @@ module Schema
 end
 
 module SubDB
-  class Base < ActiveRecord::Base
+  class Base < ApplicationRecord
     self.abstract_class = true
     establish_connection(
       adapter: 'sqlite3',