mini-fast-sys 0.0.1

data/ransack-4.4.1/spec/ransack/adapters/active_record/context_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      version = ::ActiveRecord::VERSION
+      AR_version = "#{version::MAJOR}.#{version::MINOR}"
+
+      describe Context do
+        subject { Context.new(Person) }
+
+        it 'has an Active Record alias tracker method' do
+          expect(subject.alias_tracker)
+          .to be_an ::ActiveRecord::Associations::AliasTracker
+        end
+
+        describe '#relation_for' do
+          it 'returns relation for given object' do
+            expect(subject.object).to be_an ::ActiveRecord::Relation
+          end
+        end
+
+        describe '#evaluate' do
+          it 'evaluates search objects' do
+            s = Search.new(Person, name_eq: 'Joe Blow')
+            result = subject.evaluate(s)
+
+            expect(result).to be_an ::ActiveRecord::Relation
+            expect(result.to_sql)
+            .to match /#{quote_column_name("name")} = 'Joe Blow'/
+          end
+
+          it 'SELECTs DISTINCT when distinct: true' do
+            s = Search.new(Person, name_eq: 'Joe Blow')
+            result = subject.evaluate(s, distinct: true)
+
+            expect(result).to be_an ::ActiveRecord::Relation
+            expect(result.to_sql).to match /SELECT DISTINCT/
+          end
+        end
+
+        describe '#build_correlated_subquery' do
+          it 'build correlated subquery for Root STI model' do
+            search = Search.new(Person, { articles_title_not_eq: 'some_title' }, 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 'build correlated subquery for Child STI model when predicate is not_eq' do
+            search = Search.new(Person, { story_articles_title_not_eq: 'some_title' }, 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 Child STI model when predicate is eq' do
+            search = Search.new(Person, { story_articles_title_not_eq: 'some_title' }, 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 multiple conditions (default scope)' do
+            search = Search.new(Person, { comments_body_not_eq: 'some_title' })
+
+            # Was
+            # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
+            #   SELECT "comments"."disabled" FROM "comments"
+            #   WHERE "comments"."disabled" = "people"."id"
+            #     AND NOT ("comments"."body" != 'some_title')
+            # ) ORDER BY "people"."id" DESC
+            # Should Be
+            # SELECT "people".* FROM "people" WHERE "people"."id" NOT IN (
+            #   SELECT "comments"."person_id" FROM "comments"
+            #   WHERE "comments"."person_id" = "people"."id"
+            #     AND NOT ("comments"."body" != 'some_title')
+            # ) ORDER BY "people"."id" DESC
+
+            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
+          let(:shared_context) { Context.for(Person) }
+
+          before do
+            Search.new(Person, { parent_name_eq: 'A' },
+              context: shared_context)
+            Search.new(Person, { children_name_eq: 'B' },
+              context: shared_context)
+          end
+
+          describe '#join_sources' do
+            it 'returns dependent arel join nodes for all searches run against
+            the context' do
+              parents, children = shared_context.join_sources
+              expect(children.left.name).to eq "children_people"
+              expect(parents.left.name).to eq "parents_people"
+            end
+
+            it 'can be rejoined to execute a valid query' do
+              parents, children = shared_context.join_sources
+
+              expect { Person.joins(parents).joins(children).to_a }
+              .to_not raise_error
+            end
+          end
+        end
+
+        it 'contextualizes strings to attributes' do
+          attribute = subject.contextualize 'children_children_parent_name'
+          expect(attribute).to be_a Arel::Attributes::Attribute
+          expect(attribute.name.to_s).to eq 'name'
+          expect(attribute.relation.table_alias).to eq 'parents_people'
+        end
+
+        it 'builds new associations if not yet built' do
+          attribute = subject.contextualize 'children_articles_title'
+          expect(attribute).to be_a Arel::Attributes::Attribute
+          expect(attribute.name.to_s).to eq 'title'
+          expect(attribute.relation.name).to eq 'articles'
+          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
+end

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

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+module Ransack
+  describe Configuration do
+    it 'yields Ransack on configure' do
+      Ransack.configure { |config| expect(config).to eq Ransack }
+    end
+
+    it 'adds predicates' do
+      Ransack.configure do |config|
+        config.add_predicate :test_predicate
+      end
+
+      expect(Ransack.predicates).to have_key 'test_predicate'
+      expect(Ransack.predicates).to have_key 'test_predicate_any'
+      expect(Ransack.predicates).to have_key 'test_predicate_all'
+    end
+
+    it 'avoids creating compound predicates if compounds: false' do
+      Ransack.configure do |config|
+        config.add_predicate(
+          :test_predicate_without_compound,
+          compounds: false
+          )
+      end
+      expect(Ransack.predicates)
+      .to have_key 'test_predicate_without_compound'
+      expect(Ransack.predicates)
+      .not_to have_key 'test_predicate_without_compound_any'
+      expect(Ransack.predicates)
+      .not_to have_key 'test_predicate_without_compound_all'
+    end
+
+    it 'should have default value for search key' do
+      expect(Ransack.options[:search_key]).to eq :q
+    end
+
+    it 'changes default search key parameter' do
+      default = Ransack.options.clone
+
+      Ransack.configure { |c| c.search_key = :query }
+
+      expect(Ransack.options[:search_key]).to eq :query
+
+      Ransack.options = default
+    end
+
+    it 'should have default value for strip_whitespace' do
+      expect(Ransack.options[:strip_whitespace]).to eq true
+    end
+
+    it 'changes default search key parameter' do
+      default = Ransack.options.clone
+
+      Ransack.configure { |c| c.strip_whitespace = false }
+
+      expect(Ransack.options[:strip_whitespace]).to eq false
+
+      Ransack.options = default
+    end
+
+    it 'should have default values for arrows' do
+      expect(Ransack.options[:up_arrow]).to eq '▼'
+      expect(Ransack.options[:down_arrow]).to eq '▲'
+      expect(Ransack.options[:default_arrow]).to eq nil
+    end
+
+    it 'changes the default value for the up arrow only' do
+      default, new_up_arrow = Ransack.options.clone, 'U+02191'
+
+      Ransack.configure { |c| c.custom_arrows = { up_arrow: new_up_arrow } }
+
+      expect(Ransack.options[:down_arrow]).to eq default[:down_arrow]
+      expect(Ransack.options[:up_arrow]).to eq new_up_arrow
+
+      Ransack.options = default
+    end
+
+    it 'changes the default value for the down arrow only' do
+      default, new_down_arrow  = Ransack.options.clone, '<i class="down"></i>'
+
+      Ransack.configure { |c| c.custom_arrows = { down_arrow: new_down_arrow } }
+
+      expect(Ransack.options[:up_arrow]).to eq default[:up_arrow]
+      expect(Ransack.options[:down_arrow]).to eq new_down_arrow
+
+      Ransack.options = default
+    end
+
+    it 'changes the default value for the default arrow only' do
+      default, new_default_arrow  = Ransack.options.clone, '<i class="default"></i>'
+
+      Ransack.configure { |c| c.custom_arrows = { default_arrow: new_default_arrow } }
+
+      expect(Ransack.options[:up_arrow]).to eq default[:up_arrow]
+      expect(Ransack.options[:down_arrow]).to eq default[:down_arrow]
+      expect(Ransack.options[:default_arrow]).to eq new_default_arrow
+
+      Ransack.options = default
+    end
+
+    it 'changes the default value for all arrows' do
+      default        = Ransack.options.clone
+      new_up_arrow   = '<i class="fa fa-long-arrow-up"></i>'
+      new_down_arrow = 'U+02193'
+      new_default_arrow = 'defaultarrow'
+
+      Ransack.configure do |c|
+        c.custom_arrows = { up_arrow: new_up_arrow, down_arrow: new_down_arrow, default_arrow: new_default_arrow }
+      end
+
+      expect(Ransack.options[:up_arrow]).to eq new_up_arrow
+      expect(Ransack.options[:down_arrow]).to eq new_down_arrow
+      expect(Ransack.options[:default_arrow]).to eq new_default_arrow
+
+      Ransack.options = default
+    end
+
+    it 'consecutive arrow customizations respect previous customizations' do
+      default = Ransack.options.clone
+
+      Ransack.configure { |c| c.custom_arrows = { up_arrow: 'up' } }
+      expect(Ransack.options[:down_arrow]).to eq default[:down_arrow]
+
+      Ransack.configure { |c| c.custom_arrows = { down_arrow: 'DOWN' } }
+      expect(Ransack.options[:up_arrow]).to eq 'up'
+
+      Ransack.configure { |c| c.custom_arrows = { up_arrow: '<i>U-Arrow</i>' } }
+      expect(Ransack.options[:down_arrow]).to eq 'DOWN'
+
+      Ransack.configure { |c| c.custom_arrows = { down_arrow: 'down arrow-2' } }
+      expect(Ransack.options[:up_arrow]).to eq '<i>U-Arrow</i>'
+
+      Ransack.options = default
+    end
+
+    it 'adds predicates that take arrays, overriding compounds' do
+      Ransack.configure do |config|
+        config.add_predicate(
+          :test_array_predicate,
+          wants_array: true,
+          compounds: true
+          )
+      end
+
+      expect(Ransack.predicates['test_array_predicate'].wants_array).to eq true
+      expect(Ransack.predicates).not_to have_key 'test_array_predicate_any'
+      expect(Ransack.predicates).not_to have_key 'test_array_predicate_all'
+    end
+
+    describe '`wants_array` option takes precedence over Arel predicate' do
+      it 'implicitly wants an array for in/not in predicates' do
+        Ransack.configure do |config|
+          config.add_predicate(
+            :test_in_predicate,
+            arel_predicate: 'in'
+          )
+          config.add_predicate(
+            :test_not_in_predicate,
+            arel_predicate: 'not_in'
+          )
+        end
+
+        expect(Ransack.predicates['test_in_predicate'].wants_array)
+        .to eq true
+        expect(Ransack.predicates['test_not_in_predicate'].wants_array)
+        .to eq true
+      end
+
+      it 'explicitly does not want array for in/not_in predicates' do
+        Ransack.configure do |config|
+          config.add_predicate(
+            :test_in_predicate_no_array,
+            arel_predicate: 'in',
+            wants_array: false
+          )
+          config.add_predicate(
+            :test_not_in_predicate_no_array,
+            arel_predicate: 'not_in',
+            wants_array: false
+          )
+        end
+
+        expect(Ransack.predicates['test_in_predicate_no_array'].wants_array)
+        .to eq false
+        expect(Ransack.predicates['test_not_in_predicate_no_array'].wants_array)
+        .to eq false
+      end
+    end
+
+    it "PG's sort option", if: ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" do
+      default = Ransack.options.clone
+
+      Ransack.configure { |c| c.postgres_fields_sort_option = :nulls_first }
+
+      expect(Ransack.options[:postgres_fields_sort_option]).to eq :nulls_first
+
+      Ransack.options = default
+    end
+  end
+end

data/ransack-4.4.1/spec/ransack/helpers/form_builder_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+module Ransack
+  module Helpers
+    describe FormBuilder do
+      router = ActionDispatch::Routing::RouteSet.new
+      router.draw do
+        resources :people, :comments, :notes
+      end
+
+      include router.url_helpers
+
+      # FIXME: figure out a cleaner way to get this behavior
+      before do
+        @controller = ActionView::TestCase::TestController.new
+        @controller.instance_variable_set(:@_routes, router)
+        @controller.class_eval { include router.url_helpers }
+        @controller.view_context_class.class_eval { include router.url_helpers }
+        @s = Person.ransack
+        @controller.view_context.search_form_for(@s) { |f| @f = f }
+      end
+
+      it 'selects previously-entered time values with datetime_select' do
+        date_values = %w(2011 1 2 03 04 05)
+      # @s.created_at_eq = date_values # This works in Rails 4.x but not 3.x
+        @s.created_at_eq = [2011, 1, 2, 3, 4, 5] # so we have to do this
+        html = @f.datetime_select(
+          :created_at_eq, use_month_numbers: true, include_seconds: true
+          )
+        date_values.each { |val| expect(html).to include date_select_html(val) }
+      end
+
+      describe '#label' do
+        context 'with direct model attributes' do
+          it 'localizes attribute names' do
+            test_label(@f, :name_cont, /Full Name contains/)
+            test_label(@f, :only_admin_start, /admin uSer Only starts with/)
+            test_label(@f, :salary_gt, /wages greater than/)
+            test_label(@f, :awesome_true, /ransack is really awesome is true/)
+          end
+          it 'falls back to `attribute_name.capitalize` when no translation' do
+            test_label(@f, :email_cont, /Email contains/)
+            test_label(@f, :only_sort_start, /Only sort starts with/)
+            test_label(@f, :only_search_eq, /Only search equals/)
+          end
+        end
+        context 'with `has_many` association attributes' do
+          it 'localizes :"#{pluralized model}_#{attribute name}_#{predicate}"' do
+            test_label(@f, :articles_body_start, /Article maiN BoDy starts with/)
+          end
+          it 'falls back to `model_name.capitalize + attribute_name.capitalize` when no translation' do
+            test_label(@f, :articles_title_cont, /Article Title contains/)
+            test_label(@f, :articles_subject_header_start, /Article Subject header starts with/)
+          end
+        end
+        context 'with `belongs_to` association attributes' do
+          before do
+            @controller.view_context.search_form_for(Comment.ransack) { |f| @f = f }
+          end
+          it 'localizes :"#{singularized model}_#{attribute name}_#{predicate}"' do
+            test_label(@f, :article_body_start, /Article maiN BoDy starts with/)
+          end
+          it 'falls back to `model_name.capitalize + attribute_name.capitalize` when no translation' do
+            test_label(@f, :article_title_eq, /Article Title equals/)
+            test_label(@f, :article_subject_header_end, /Article Subject header ends with/)
+          end
+        end
+      end
+
+      describe '#sort_link' do
+        it 'sort_link for ransack attribute' do
+          sort_link = @f.sort_link :name, controller: 'people'
+          expect(sort_link).to match /people\?q(%5B|\[)s(%5D|\])=name\+asc/
+          expect(sort_link).to match /sort_link/
+          expect(sort_link).to match /Full Name<\/a>/
+        end
+        it 'sort_link for common attribute' do
+          sort_link = @f.sort_link :id, controller: 'people'
+          expect(sort_link).to match /id<\/a>/
+        end
+      end
+
+      describe '#submit' do
+        it 'localizes :search when no default value given' do
+          html = @f.submit
+          expect(html).to match /"Search"/
+        end
+      end
+
+      describe '#attribute_select' do
+        it 'returns ransackable attributes' do
+          html = @f.attribute_select
+          expect(html.split(/\n/).size).to eq(Person.ransackable_attributes.size + 1)
+          Person.ransackable_attributes.each do |attribute|
+            expect(html).to match /<option value="#{attribute}">/
+          end
+        end
+        it 'returns ransackable attributes for associations with :associations' do
+          attributes = Person.ransackable_attributes +
+            Article.ransackable_attributes.map { |a| "articles_#{a}" }
+          html = @f.attribute_select(associations: ['articles'])
+          expect(html.split(/\n/).size).to eq(attributes.size)
+          attributes.each do |attribute|
+            expect(html).to match /<option value="#{attribute}">/
+          end
+        end
+        it 'returns option groups for base and associations with :associations' do
+          html = @f.attribute_select(associations: ['articles'])
+          [Person, Article].each do |model|
+            expect(html).to match /<optgroup label="#{model}">/
+          end
+        end
+      end
+
+      describe '#predicate_select' do
+        it 'returns predicates with predicate_select' do
+          html = @f.predicate_select
+          Predicate.names.each do |key|
+            expect(html).to match /<option value="#{key}">/
+          end
+        end
+        it 'filters predicates with single-value :only' do
+          html = @f.predicate_select only: 'eq'
+          Predicate.names.reject { |k| k =~ /^eq/ }.each do |key|
+            expect(html).not_to match /<option value="#{key}">/
+          end
+        end
+        it 'filters predicates with multi-value :only' do
+          html = @f.predicate_select only: [:eq, :lt]
+          Predicate.names.reject { |k| k =~ /^(eq|lt)/ }.each do |key|
+            expect(html).not_to match /<option value="#{key}">/
+          end
+        end
+        it 'excludes compounds when compounds: false' do
+          html = @f.predicate_select compounds: false
+          Predicate.names.select { |k| k =~ /_(any|all)$/ }.each do |key|
+            expect(html).not_to match /<option value="#{key}">/
+          end
+        end
+      end
+
+      context 'fields used in polymorphic relations as search attributes in form' do
+        before do
+          @controller.view_context.search_form_for(Note.ransack) { |f| @f = f }
+        end
+        it 'accepts poly_id field' do
+          html = @f.text_field(:notable_id_eq)
+          expect(html).to match /id=\"q_notable_id_eq\"/
+        end
+        it 'accepts poly_type field' do
+          html = @f.text_field(:notable_type_eq)
+          expect(html).to match /id=\"q_notable_type_eq\"/
+        end
+      end
+
+      private
+
+        def test_label(f, query, expected)
+          expect(f.label query).to match expected
+        end
+
+        # Starting from Rails 4.2, the date_select html attributes are no longer
+        # `sort`ed (for a speed gain), so the tests have to be different:
+        def date_select_html(val)
+          %(<option value="#{val}" selected="selected">#{val}</option>)
+        end
+    end
+  end
+end