ransack 1.7.0 → 2.4.1

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

@@ -1,60 +0,0 @@
-require 'ransack/visitor'
-
-module Ransack
-  class Context
-    # attr_reader :arel_visitor
-
-    class << self
-
-      def for_class(klass, options = {})
-        if klass.ancestors.include?(::Mongoid::Document)
-          Adapters::Mongoid::Context.new(klass, options)
-        end
-      end
-
-      def for_object(object, options = {})
-        case object
-        when ActiveRecord::Relation
-          Adapters::ActiveRecord::Context.new(object.klass, options)
-        end
-      end
-
-    end # << self
-
-    def initialize(object, options = {})
-      @object = relation_for(object)
-      @klass = @object.klass
-      # @join_dependency = join_dependency(@object)
-      # @join_type = options[:join_type] || Arel::OuterJoin
-      @search_key = options[:search_key] || Ransack.options[:search_key]
-
-      @base = @object.klass
-      # @engine = @base.arel_engine
-
-      # @default_table = Arel::Table.new(
-      #   @base.table_name, :as => @base.aliased_table_name, :engine => @engine
-      #   )
-      @bind_pairs = Hash.new do |hash, key|
-        parent, attr_name = get_parent_and_attribute_name(key.to_s)
-        if parent && attr_name
-          hash[key] = [parent, attr_name]
-        end
-      end
-    end
-
-    def klassify(obj)
-      if Class === obj && ::ActiveRecord::Base > obj
-        obj
-      elsif obj.respond_to? :klass
-        obj.klass
-      elsif obj.respond_to? :active_record  # Rails 3
-        obj.active_record
-      elsif obj.respond_to? :base_klass     # Rails 4
-        obj.base_klass
-      else
-        raise ArgumentError, "Don't know how to klassify #{obj.inspect}"
-      end
-    end
-
-  end
-end

data/lib/ransack/adapters/mongoid/ransack/nodes/condition.rb

@@ -1,27 +0,0 @@
-module Ransack
-  module Nodes
-    class Condition
-
-      def arel_predicate
-        predicates = attributes.map do |attr|
-          attr.attr.send(
-            arel_predicate_for_attribute(attr),
-            formatted_values_for_attribute(attr)
-          )
-        end
-
-        if predicates.size > 1
-          case combinator
-          when 'and'
-            Arel::Nodes::Grouping.new(Arel::Nodes::And.new(predicates))
-          when 'or'
-            predicates.inject(&:or)
-          end
-        else
-          predicates.first
-        end
-      end
-
-    end # Condition
-  end
-end

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

@@ -1,13 +0,0 @@
-module Ransack
-  module Translate
-
-    def self.i18n_key(klass)
-      # if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
-      #   klass.model_name.i18n_key.to_s.tr('.', '/')
-      # else
-      #   klass.model_name.i18n_key.to_s
-      # end
-      klass.model_name.i18n_key.to_s
-    end
-  end
-end

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,13 +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

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

@@ -1,276 +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
-              Person.stub :ransackable_scopes => [: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 '#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 '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 '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
-          before { pending "not implemented for mongoid" }
-
-          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,102 +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
-      # store original state so we can restore it later
-      before = Ransack.options.clone
-
-      Ransack.configure do |config|
-        config.search_key = :query
-      end
-
-      expect(Ransack.options[:search_key]).to eq :query
-
-      # restore original state so we don't break other tests
-      Ransack.options = before
-    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,34 +0,0 @@
-require 'mongoid_spec_helper'
-
-module Ransack
-  module Nodes
-    describe Condition do
-
-      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