ransack 1.8.3 → 2.3.0

data/lib/ransack/adapters/mongoid/ransack/visitor.rb

@@ -1,24 +0,0 @@
-module Ransack
-  class Visitor
-    def visit_and(object)
-      nodes = object.values.map { |o| accept(o) }.compact
-      return nil unless nodes.size > 0
-
-      if nodes.size > 1
-        nodes.inject(&:and)
-      else
-        nodes.first
-      end
-    end
-
-    def quoted?(object)
-      case object
-      when Arel::Nodes::SqlLiteral, Bignum, Fixnum
-        false
-      else
-        true
-      end
-    end
-
-  end
-end

data/lib/ransack/adapters/mongoid/table.rb

@@ -1,35 +0,0 @@
-module Ransack
-  module Adapters
-    module Mongoid
-      class Table
-        attr_accessor :name
-
-        alias :table_name :name
-
-        def initialize(object, engine = nil)
-          @object  = object
-          @name    = object.collection.name
-          @engine  = engine
-          @columns = nil
-          @aliases = []
-          @table_alias = nil
-          @primary_key = nil
-
-          if Hash === engine
-            # @engine  = engine[:engine] || Table.engine
-
-            # Sometime AR sends an :as parameter to table, to let the table know
-            # that it is an Alias.  We may want to override new, and return a
-            # TableAlias node?
-            # @table_alias = engine[:as] unless engine[:as].to_s == @name
-          end
-        end
-
-        def [](name)
-          Ransack::Adapters::Mongoid::Attribute.new self, name
-        end
-
-      end
-    end
-  end
-end

data/lib/ransack/adapters/mongoid.rb

@@ -1,15 +0,0 @@
-require 'ransack/adapters/mongoid/base'
-::Mongoid::Document.send :include, Ransack::Adapters::Mongoid::Base
-
-require 'ransack/adapters/mongoid/attributes/attribute'
-require 'ransack/adapters/mongoid/table'
-require 'ransack/adapters/mongoid/inquiry_hash'
-
-case ::Mongoid::VERSION
-when /^3\.2\./
-  require 'ransack/adapters/mongoid/3.2/context'
-else
-  require 'ransack/adapters/mongoid/context'
-end
-
-Ransack::SUPPORTS_ATTRIBUTE_ALIAS = false

data/spec/mongoid/adapters/mongoid/base_spec.rb

@@ -1,314 +0,0 @@
-require 'mongoid_spec_helper'
-
-module Ransack
-  module Adapters
-    module Mongoid
-      describe Base do
-
-        subject { Person }
-
-        it { should respond_to :ransack }
-        it { should respond_to :search }
-
-        describe '#search' do
-          subject { Person.search }
-
-          it { should be_a Search }
-          it 'has a Mongoid::Criteria as its object' do
-            expect(subject.object).to be_an ::Mongoid::Criteria
-          end
-
-          context 'with scopes' do
-            before do
-              allow(Person)
-              .to receive(:ransackable_scopes)
-              .and_return([:active, :over_age])
-            end
-
-            it "applies true scopes" do
-              search =  Person.search('active' => true)
-              expect(search.result.selector).to eq({ 'active' => 1 })
-            end
-
-            it "ignores unlisted scopes" do
-              search =  Person.search('restricted' => true)
-              expect(search.result.selector).to_not eq({ 'restricted' => 1})
-            end
-
-            it "ignores false scopes" do
-              search = Person.search('active' => false)
-              expect(search.result.selector).to_not eq({ 'active' => 1 })
-            end
-
-            it "passes values to scopes" do
-              search = Person.search('over_age' => 18)
-              expect(search.result.selector).to eq({ 'age' => { '$gt' => 18 } })
-            end
-
-            it "chains scopes" do
-              search = Person.search('over_age' => 18, 'active' => true)
-              expect(search.result.selector).to eq({ 'age' => { '$gt' => 18 }, 'active' => 1 })
-            end
-          end
-        end
-
-        describe '#ransack_alias' do
-          it 'translates an alias to the correct attributes' do
-            p = Person.create!(name: 'Meatloaf', email: 'babies@example.com')
-
-            s = Person.ransack(term_cont: 'atlo')
-            expect(s.result.to_a).to eq [p]
-
-            s = Person.ransack(term_cont: 'babi')
-            expect(s.result.to_a).to eq [p]
-
-            s = Person.ransack(term_cont: 'nomatch')
-            expect(s.result.to_a).to eq []
-          end
-
-          it 'makes aliases available to subclasses' do
-            yngwie = Musician.create!(name: 'Yngwie Malmsteen')
-
-            musicians = Musician.ransack(term_cont: 'ngw').result
-            expect(musicians).to eq([yngwie])
-          end
-
-          it 'handles naming collisions gracefully' do
-            frank = Person.create!(name: 'Frank Stallone')
-
-            people = Person.ransack(term_cont: 'allon').result
-            expect(people).to eq([frank])
-
-            Class.new(Article) do
-              ransack_alias :term, :title
-            end
-
-            people = Person.ransack(term_cont: 'allon').result
-            expect(people).to eq([frank])
-          end
-        end
-
-        describe '#ransacker' do
-          # For infix tests
-          def self.sane_adapter?
-            case ::Mongoid::Document.connection.adapter_name
-            when "SQLite3", "PostgreSQL"
-              true
-            else
-              false
-            end
-          end
-          # # in schema.rb, class Person:
-          # ransacker :reversed_name, formatter: proc { |v| v.reverse } do |parent|
-          #   parent.table[:name]
-          # end
-
-          # ransacker :doubled_name do |parent|
-          #   Arel::Nodes::InfixOperation.new(
-          #     '||', parent.table[:name], parent.table[:name]
-          #   )
-          # end
-
-          it 'creates ransack attributes' do
-            s = Person.search(:reversed_name_eq => 'htimS cirA')
-            expect(s.result.size).to eq(Person.where(name: 'Aric Smith').count)
-
-            expect(s.result.first).to eq Person.where(name: 'Aric Smith').first
-          end
-
-          context 'with joins' do
-            before { pending 'not implemented for mongoid' }
-
-            it 'can be accessed through associations' do
-              s = Person.search(:children_reversed_name_eq => 'htimS cirA')
-              expect(s.result.to_sql).to match(
-                /#{quote_table_name("children_people")}.#{
-                   quote_column_name("name")} = 'Aric Smith'/
-              )
-            end
-
-            it "should keep proper key value pairs in the params hash" do
-              s = Person.search(:children_reversed_name_eq => 'Testing')
-              expect(s.result.to_sql).to match /LEFT OUTER JOIN/
-            end
-
-          end
-
-          it 'allows an "attribute" to be an InfixOperation' do
-            s = Person.search(:doubled_name_eq => 'Aric SmithAric Smith')
-            expect(s.result.first).to eq Person.where(name: 'Aric Smith').first
-          end if defined?(Arel::Nodes::InfixOperation) && sane_adapter?
-
-          it "doesn't break #count if using InfixOperations" do
-            s = Person.search(:doubled_name_eq => 'Aric SmithAric Smith')
-            expect(s.result.count).to eq 1
-          end if defined?(Arel::Nodes::InfixOperation) && sane_adapter?
-
-          it "should remove empty key value pairs from the params hash" do
-            s = Person.search(:reversed_name_eq => '')
-            expect(s.result.selector).to eq({})
-          end
-
-          it "should function correctly when nil is passed in" do
-            s = Person.search(nil)
-          end
-
-          it "should function correctly when a blank string is passed in" do
-            s = Person.search('')
-          end
-
-          it "should function correctly when using fields with dots in them" do
-            s = Person.search(:email_cont => "example.com")
-            expect(s.result.exists?).to be true
-
-            s = Person.search(:email_cont => "example.co.")
-            expect(s.result.exists?).not_to be true
-          end
-
-          it "should function correctly when using fields with % in them" do
-            Person.create!(:name => "110%-er")
-            s = Person.search(:name_cont => "10%")
-            expect(s.result.exists?).to be true
-          end
-
-          it "should function correctly when using fields with backslashes in them" do
-            Person.create!(:name => "\\WINNER\\")
-            s = Person.search(:name_cont => "\\WINNER\\")
-            expect(s.result.exists?).to be true
-          end
-
-          it 'allows sort by "only_sort" field' do
-            pending "it doesn't work :("
-            s = Person.search(
-              "s" => { "0" => { "dir" => "desc", "name" => "only_sort" } }
-            )
-            expect(s.result.to_sql).to match(
-              /ORDER BY #{quote_table_name("people")}.#{
-                quote_column_name("only_sort")} ASC/
-            )
-          end
-
-          it "doesn't sort by 'only_search' field" do
-            pending "it doesn't work :("
-            s = Person.search(
-              "s" => { "0" => { "dir" => "asc", "name" => "only_search" } }
-            )
-            expect(s.result.to_sql).not_to match(
-              /ORDER BY #{quote_table_name("people")}.#{
-                quote_column_name("only_search")} ASC/
-            )
-          end
-
-          it 'allows search by "only_search" field' do
-            s = Person.search(:only_search_eq => 'htimS cirA')
-            expect(s.result.selector).to eq({'only_search' => 'htimS cirA'})
-          end
-
-          it "can't be searched by 'only_sort'" do
-            s = Person.search(:only_sort_eq => 'htimS cirA')
-            expect(s.result.selector).not_to eq({'only_sort' => 'htimS cirA'})
-          end
-
-          it 'allows sort by "only_admin" field, if auth_object: :admin' do
-            s = Person.search(
-              { "s" => { "0" => { "dir" => "asc", "name" => "only_admin" } } },
-              { auth_object: :admin }
-            )
-            expect(s.result.options).to eq({ sort: { '_id' => -1, 'only_admin' => 1 } })
-          end
-
-          it "doesn't sort by 'only_admin' field, if auth_object: nil" do
-            s = Person.search(
-              "s" => { "0" => { "dir" => "asc", "name" => "only_admin" } }
-            )
-            expect(s.result.options).to eq({ sort: {'_id' => -1}})
-          end
-
-          it 'allows search by "only_admin" field, if auth_object: :admin' do
-            s = Person.search(
-              { :only_admin_eq => 'htimS cirA' },
-              { :auth_object => :admin }
-            )
-            expect(s.result.selector).to eq({ 'only_admin' => 'htimS cirA' })
-          end
-
-          it "can't be searched by 'only_admin', if auth_object: nil" do
-            s = Person.search(:only_admin_eq => 'htimS cirA')
-            expect(s.result.selector).to eq({})
-          end
-
-          it 'searches by id' do
-            ids = ['some_bson_id', 'another_bson_id']
-            s = Person.search(:id_in => ids)
-            expect(s.result.selector).to eq({ '_id' => { '$in' => ids } })
-          end
-        end
-
-        describe '#ransackable_attributes' do
-          context 'when auth_object is nil' do
-            subject { Person.ransackable_attributes }
-
-            it { should include 'name' }
-            it { should include 'reversed_name' }
-            it { should include 'doubled_name' }
-            it { should include 'term' }
-            it { should include 'only_search' }
-            it { should_not include 'only_sort' }
-            it { should_not include 'only_admin' }
-          end
-
-          context 'with auth_object :admin' do
-            subject { Person.ransackable_attributes(:admin) }
-
-            it { should include 'name' }
-            it { should include 'reversed_name' }
-            it { should include 'doubled_name' }
-            it { should include 'term' }
-            it { should include 'only_search' }
-            it { should_not include 'only_sort' }
-            it { should include 'only_admin' }
-          end
-        end
-
-        describe '#ransortable_attributes' do
-          context 'when auth_object is nil' do
-            subject { Person.ransortable_attributes }
-
-            it { should include 'name' }
-            it { should include 'reversed_name' }
-            it { should include 'doubled_name' }
-            it { should include 'only_sort' }
-            it { should_not include 'only_search' }
-            it { should_not include 'only_admin' }
-          end
-
-          context 'with auth_object :admin' do
-            subject { Person.ransortable_attributes(:admin) }
-
-            it { should include 'name' }
-            it { should include 'reversed_name' }
-            it { should include 'doubled_name' }
-            it { should include 'only_sort' }
-            it { should_not include 'only_search' }
-            it { should include 'only_admin' }
-          end
-        end
-
-        describe '#ransackable_associations' do
-          subject { Person.ransackable_associations }
-
-          it { should include 'parent' }
-          it { should include 'children' }
-          it { should include 'articles' }
-        end
-
-        describe '#ransackable_scopes' do
-          subject { Person.ransackable_scopes }
-
-          it { should eq [] }
-        end
-
-      end
-    end
-  end
-end

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