mini-fast-sys 0.0.1

data/ransack-4.4.1/spec/ransack/invalid_search_error_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Ransack
+  describe InvalidSearchError do
+    it 'inherits from ArgumentError' do
+      expect(InvalidSearchError.superclass).to eq(ArgumentError)
+    end
+
+    it 'can be instantiated with a message' do
+      error = InvalidSearchError.new('Test error message')
+      expect(error.message).to eq('Test error message')
+    end
+
+    it 'can be instantiated without a message' do
+      error = InvalidSearchError.new
+      expect(error.message).to eq('Ransack::InvalidSearchError')
+    end
+
+    it 'can be raised and caught' do
+      expect { raise InvalidSearchError.new('Test') }.to raise_error(InvalidSearchError, 'Test')
+    end
+
+    it 'can be raised and caught as ArgumentError' do
+      expect { raise InvalidSearchError.new('Test') }.to raise_error(ArgumentError, 'Test')
+    end
+  end
+end

data/ransack-4.4.1/spec/ransack/nodes/condition_spec.rb

@@ -0,0 +1,333 @@
+require 'spec_helper'
+
+module Ransack
+  module Nodes
+    describe Condition do
+      context 'bug report #1245' do
+        it 'preserves tuple behavior' do
+          ransack_hash = {
+              m: 'and',
+              g: [
+                { title_type_in: ['["title 1", ""]'] }
+              ]
+            }
+
+          sql = Article.ransack(ransack_hash).result.to_sql
+          expect(sql).to include("IN (('title 1', ''))")
+        end
+      end
+
+      context 'with an alias' do
+        subject {
+          Condition.extract(
+            Context.for(Person), 'term_start', Person.first(2).map(&:name)
+          )
+        }
+
+        specify { expect(subject.combinator).to eq 'or' }
+        specify { expect(subject.predicate.name).to eq 'start' }
+
+        it 'converts the alias to the correct attributes' do
+          expect(subject.attributes.map(&:name)).to eq(['name', 'email'])
+        end
+      end
+
+      context 'with multiple values and an _any predicate' do
+        subject {
+          Condition.extract(
+            Context.for(Person), 'name_eq_any', Person.first(2).map(&:name)
+          )
+        }
+
+        specify { expect(subject.values.size).to eq(2) }
+      end
+
+      describe '#negative?' do
+        let(:context) { Context.for(Person) }
+        let(:eq)      { Condition.extract(context, 'name_eq', 'A') }
+        let(:not_eq)  { Condition.extract(context, 'name_not_eq', 'A') }
+
+        specify { expect(not_eq.negative?).to be true }
+        specify { expect(eq.negative?).to be false }
+      end
+
+      context 'with an invalid predicate' do
+        subject {
+          Condition.extract(
+            Context.for(Person), 'name_invalid', Person.first.name
+          )
+        }
+
+        context "when ignore_unknown_conditions is false" do
+          before do
+            Ransack.configure { |c| c.ignore_unknown_conditions = false }
+          end
+
+          specify { expect { subject }.to raise_error ArgumentError }
+          specify { expect { subject }.to raise_error InvalidSearchError }
+        end
+
+        context "when ignore_unknown_conditions is true" do
+          before do
+            Ransack.configure { |c| c.ignore_unknown_conditions = true }
+          end
+
+          specify { expect(subject).to be_nil }
+        end
+      end
+
+      context 'with an empty predicate' do
+        subject {
+          Condition.extract(
+            Context.for(Person), 'full_name', Person.first.name
+          )
+        }
+
+        context "when default_predicate = nil" do
+          before do
+            Ransack.configure { |c| c.default_predicate = nil }
+          end
+
+          specify { expect(subject).to be_nil }
+        end
+
+        context "when default_predicate = 'eq'" do
+          before do
+            Ransack.configure { |c| c.default_predicate = 'eq' }
+          end
+
+          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/ransack-4.4.1/spec/ransack/nodes/grouping_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+module Ransack
+  module Nodes
+    describe Grouping do
+      before do
+        @g = 1
+      end
+
+      let(:context) { Context.for(Person) }
+
+      subject { described_class.new(context) }
+
+      describe '#attribute_method?' do
+        context 'for attributes of the context' do
+          it 'is true' do
+            expect(subject.attribute_method?('name')).to be true
+          end
+
+          context "when the attribute contains '_and_'" do
+            it 'is true' do
+              expect(subject.attribute_method?('terms_and_conditions')).to be true
+            end
+          end
+
+          context "when the attribute contains '_or_'" do
+            it 'is true' do
+              expect(subject.attribute_method?('true_or_false')).to be true
+            end
+          end
+
+          context "when the attribute ends with '_start'" do
+            it 'is true' do
+              expect(subject.attribute_method?('life_start')).to be true
+            end
+          end
+
+          context "when the attribute ends with '_end'" do
+            it 'is true' do
+              expect(subject.attribute_method?('stop_end')).to be true
+            end
+          end
+        end
+
+        context 'for unknown attributes' do
+          it 'is false' do
+            expect(subject.attribute_method?('not_an_attribute')).to be false
+          end
+        end
+      end
+
+      describe '#conditions=' do
+        context 'when conditions are identical' do
+          let(:conditions) do
+            {
+              '0' => {
+                'a' => { '0'=> { 'name' => 'name', 'ransacker_args' => '' } },
+                'p' => 'cont',
+                'v' => { '0' => { 'value' => 'John' } }
+              },
+              '1' => {
+                'a' => { '0' => { 'name' => 'name', 'ransacker_args' => '' } },
+                'p' => 'cont',
+                'v' => { '0' => { 'value' => 'John' } }
+              }
+            }
+          end
+
+          before { subject.conditions = conditions }
+
+          it 'expect duplicates to be removed' do
+            expect(subject.conditions.count).to eq 1
+          end
+        end
+
+        context 'when conditions differ only by ransacker_args' do
+          let(:conditions) do
+            {
+              '0' => {
+                'a' => {
+                  '0' => {
+                    'name' => 'with_arguments',
+                    'ransacker_args' => [1, 2]
+                  }
+                },
+                'p' => 'eq',
+                'v' => { '0' => { 'value' => '10' } }
+              },
+              '1' => {
+                'a' => {
+                  '0' => {
+                    'name' => 'with_arguments',
+                    'ransacker_args' => [3, 4]
+                  }
+                },
+                'p' => 'eq',
+                'v' => { '0' => { 'value' => '10' } }
+              }
+            }
+          end
+
+          before { subject.conditions = conditions }
+
+          it 'expect them to be parsed as different and not as duplicates' do
+            expect(subject.conditions.count).to eq 2
+          end
+        end
+      end
+    end
+  end
+end

data/ransack-4.4.1/spec/ransack/nodes/value_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+module Ransack
+  module Nodes
+    describe Value do
+      let(:context) { Context.for(Person) }
+
+      subject do
+        Value.new(context, raw_value)
+      end
+
+      context "with a date value" do
+        let(:raw_value) { "2022-05-23" }
+
+        [:date].each do |type|
+          it "should cast #{type} correctly" do
+            result = subject.cast(type)
+
+            expect(result).to be_a_kind_of(Date)
+            expect(result).to eq(Date.parse(raw_value))
+          end
+        end
+      end
+
+      context "with a timestamp value" do
+        let(:raw_value) { "2022-05-23 10:40:02 -0400" }
+
+        [:datetime, :timestamp, :time, :timestamptz].each do |type|
+          it "should cast #{type} correctly" do
+            result = subject.cast(type)
+
+            expect(result).to be_a_kind_of(Time)
+            expect(result).to eq(Time.zone.parse(raw_value))
+          end
+        end
+      end
+
+      Constants::TRUE_VALUES.each do |value|
+        context "with a true boolean value (#{value})" do
+          let(:raw_value) { value.to_s }
+
+          it "should cast boolean correctly" do
+            result = subject.cast(:boolean)
+            expect(result).to eq(true)
+          end
+        end
+      end
+
+      Constants::FALSE_VALUES.each do |value|
+        context "with a false boolean value (#{value})" do
+          let(:raw_value) { value.to_s }
+
+          it "should cast boolean correctly" do
+            result = subject.cast(:boolean)
+
+            expect(result).to eq(false)
+          end
+        end
+      end
+
+      ["12", "101.5"].each do |value|
+        context "with an integer value (#{value})" do
+          let(:raw_value) { value }
+
+          it "should cast #{value} to integer correctly" do
+            result = subject.cast(:integer)
+
+            expect(result).to be_an(Integer)
+            expect(result).to eq(value.to_i)
+          end
+        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 }
+
+          it "should cast #{value} to float correctly" do
+            result = subject.cast(:float)
+
+            expect(result).to be_an(Float)
+            expect(result).to eq(value.to_f)
+          end
+        end
+      end
+
+      ["12", "101.5"].each do |value|
+        context "with a decimal value (#{value})" do
+          let(:raw_value) { value }
+
+          it "should cast #{value} to decimal correctly" do
+            result = subject.cast(:decimal)
+
+            expect(result).to be_a(BigDecimal)
+            expect(result).to eq(value.to_d)
+          end
+        end
+      end
+
+      ["12", "101.513"].each do |value|
+        context "with a money value (#{value})" do
+          let(:raw_value) { value }
+
+          it "should cast #{value} to money correctly" do
+            result = subject.cast(:money)
+
+            expect(result).to be_a(String)
+            expect(result).to eq(value.to_f.to_s)
+          end
+        end
+      end
+    end
+  end
+end