ransack 1.8.10 → 2.0.0

data/spec/mongoid/adapters/mongoid/context_spec.rb

@@ -1,56 +0,0 @@
-require 'mongoid_spec_helper'
-
-module Ransack
-  module Adapters
-    module Mongoid
-      describe Context do
-        subject { Context.new(Person) }
-
-        describe '#relation_for' do
-          before { pending "not implemented for mongoid" }
-          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
-            search = Search.new(Person, :name_eq => 'Joe Blow')
-            result = subject.evaluate(search)
-
-            expect(result).to be_an ::Mongoid::Criteria
-            expect(result.selector).to eq({ 'name' => 'Joe Blow' })
-          end
-
-          it 'SELECTs DISTINCT when distinct: true' do
-            pending "distinct doesn't work"
-
-            search = Search.new(Person, :name_eq => 'Joe Blow')
-            result = subject.evaluate(search, :distinct => true)
-
-            expect(result).to be_an ::ActiveRecord::Relation
-            expect(result.to_sql).to match /SELECT DISTINCT/
-          end
-        end
-
-        it 'contextualizes strings to attributes' do
-          attribute = subject.contextualize 'name'
-          expect(attribute).to be_a ::Ransack::Adapters::Mongoid::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
-          pending "not implemented for mongoid"
-
-          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
-
-      end
-    end
-  end
-end

data/spec/mongoid/configuration_spec.rb

@@ -1,162 +0,0 @@
-require 'mongoid_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 values for arrows' do
-      expect(Ransack.options[:up_arrow]).to eq '▼'
-      expect(Ransack.options[:down_arrow]).to eq '▲'
-    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 both arrows' do
-      default        = Ransack.options.clone
-      new_up_arrow   = '<i class="fa fa-long-arrow-up"></i>'
-      new_down_arrow = 'U+02193'
-
-      Ransack.configure do |c|
-        c.custom_arrows = { up_arrow: new_up_arrow, down_arrow: new_down_arrow }
-      end
-
-      expect(Ransack.options[:up_arrow]).to eq new_up_arrow
-      expect(Ransack.options[:down_arrow]).to eq new_down_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
-  end
-end

data/spec/mongoid/dependencies_spec.rb

@@ -1,8 +0,0 @@
-unless ::ActiveSupport::VERSION::STRING >= '4'
-  describe 'Ransack' do
-    it 'can be required without errors' do
-      output = `bundle exec ruby -e "require 'ransack'" 2>&1`
-      expect(output).to be_empty
-    end
-  end
-end

data/spec/mongoid/helpers/ransack_helper.rb

@@ -1,11 +0,0 @@
-module RansackHelper
-  def quote_table_name(table)
-    # ActiveRecord::Base.connection.quote_table_name(table)
-    table
-  end
-
-  def quote_column_name(column)
-    # ActiveRecord::Base.connection.quote_column_name(column)
-    column
-  end
-end

data/spec/mongoid/nodes/condition_spec.rb

@@ -1,49 +0,0 @@
-require 'mongoid_spec_helper'
-
-module Ransack
-  module Nodes
-    describe Condition do
-
-      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
-
-      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 { |config| config.ignore_unknown_conditions = false }
-          end
-
-          specify { expect { subject }.to raise_error ArgumentError }
-        end
-
-        context "when ignore_unknown_conditions is true" do
-          before do
-            Ransack.configure { |config| config.ignore_unknown_conditions = true }
-          end
-
-          specify { expect(subject).to be_nil }
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/nodes/grouping_spec.rb

@@ -1,13 +0,0 @@
-require 'mongoid_spec_helper'
-
-module Ransack
-  module Nodes
-    describe Grouping do
-      before do
-        @g = 1
-      end
-
-
-    end
-  end
-end

data/spec/mongoid/predicate_spec.rb

@@ -1,155 +0,0 @@
-require 'mongoid_spec_helper'
-
-module Ransack
-  describe Predicate do
-
-    before do
-      @s = Search.new(Person)
-    end
-
-    shared_examples 'wildcard escaping' do |method, value|
-      it 'automatically converts integers to strings' do
-        subject.parent_id_cont = 1
-        expect { subject.result }.to_not raise_error
-      end
-
-      it "escapes '%', '.' and '\\\\' in value" do
-        subject.send(:"#{method}=", '%._\\')
-        expect(subject.result.selector).to eq(value)
-      end
-    end
-
-    describe 'eq' do
-      it 'generates an equality condition for boolean true' do
-        @s.awesome_eq = true
-        expect(@s.result.selector).to eq({ "awesome" => true })
-      end
-
-      it 'generates an equality condition for boolean false' do
-        @s.awesome_eq = false
-        expect(@s.result.selector).to eq({ "awesome" => false })
-      end
-
-      it 'does not generate a condition for nil' do
-        @s.awesome_eq = nil
-        expect(@s.result.selector).to eq({ })
-      end
-    end
-
-    describe 'cont' do
-      it_has_behavior 'wildcard escaping', :name_cont, { 'name' => /%\._\\/i } do
-        subject { @s }
-      end
-
-      it 'generates a regex query' do
-        @s.name_cont = 'ric'
-        expect(@s.result.selector).to eq({ 'name' => /ric/i })
-      end
-    end
-
-    describe 'not_cont' do
-      it_has_behavior 'wildcard escaping', :name_not_cont, { "$not" => { 'name' => /%\._\\/i } } do
-        subject { @s }
-      end
-
-      it 'generates a regex query' do
-        @s.name_not_cont = 'ric'
-        expect(@s.result.selector).to eq({ "$not" => { 'name' => /ric/i } })
-      end
-    end
-
-    describe 'null' do
-      it 'generates a value IS NULL query' do
-        @s.name_null = true
-        expect(@s.result.selector).to eq({ 'name' => nil })
-      end
-
-      it 'generates a value IS NOT NULL query when assigned false' do
-        @s.name_null = false
-        expect(@s.result.selector).to eq( { 'name' => { '$ne' => nil } })
-      end
-    end
-
-    describe 'not_null' do
-      it 'generates a value IS NOT NULL query' do
-        @s.name_not_null = true
-        expect(@s.result.selector).to eq({ 'name' => { '$ne' => nil } })
-      end
-
-      it 'generates a value IS NULL query when assigned false' do
-        @s.name_not_null = false
-        expect(@s.result.selector).to eq({ 'name' => nil })
-      end
-    end
-
-    describe 'present' do
-      it %q[generates a value IS NOT NULL AND value != '' query] do
-        @s.name_present = true
-        expect(@s.result.selector).to eq({ '$and' => [ { 'name' => { '$ne' => nil } }, { 'name' => { '$ne' => '' } } ] })
-      end
-
-      it %q[generates a value IS NULL OR value = '' query when assigned false] do
-        @s.name_present = false
-        expect(@s.result.selector).to eq({ '$or' => [ { 'name' => nil }, { 'name' => '' } ] })
-      end
-    end
-
-    describe 'blank' do
-      it %q[generates a value IS NULL OR value = '' query] do
-        @s.name_blank = true
-        expect(@s.result.selector).to eq({ '$or' => [ { 'name' => nil}, { 'name' => '' } ] })
-      end
-
-      it %q[generates a value IS NOT NULL AND value != '' query when assigned false] do
-        @s.name_blank = false
-        expect(@s.result.selector).to eq({ '$and' => [ { 'name' => { '$ne' => nil}}, { 'name' => { '$ne' => '' }} ] })
-      end
-    end
-
-    describe 'gt' do
-      it 'generates an greater than for time' do
-        time = Time.now
-        @s.created_at_gt = time
-        expect(@s.result.selector).to eq({ "created_at" => { '$gt' => time } })
-      end
-    end
-
-    describe 'lt' do
-      it 'generates an greater than for time' do
-        time = Time.now
-        @s.created_at_lt = time
-        expect(@s.result.selector).to eq({ "created_at" => { '$lt' => time } })
-      end
-    end
-
-    describe 'gteq' do
-      it 'generates an greater than for time' do
-        time = Time.now
-        @s.created_at_gteq = time
-        expect(@s.result.selector).to eq({ "created_at" => { '$gte' => time } })
-      end
-    end
-
-    describe 'lteq' do
-      it 'generates an greater than for time' do
-        time = Time.now
-        @s.created_at_lteq = time
-        expect(@s.result.selector).to eq({ "created_at" => { '$lte' => time } })
-      end
-    end
-
-    describe 'starts_with' do
-      it 'generates an starts_with' do
-        @s.name_start = 'ric'
-        expect(@s.result.selector).to eq({ "name" => /\Aric/i })
-      end
-    end
-
-    describe 'ends_with' do
-      it 'generates an ends_with' do
-        @s.name_end = 'ric'
-        expect(@s.result.selector).to eq({ "name" => /ric\Z/i })
-      end
-    end
-  end
-end