ransack 1.8.10 → 2.0.0

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

@@ -1,23 +0,0 @@
-module Ransack
-  module Adapters
-    module Mongoid
-      class InquiryHash < Hash
-
-        def or(other)
-          { '$or' => [ self, other] }.to_inquiry
-        end
-
-        def and(other)
-          { '$and' => [ self, other] }.to_inquiry
-        end
-
-      end
-    end
-  end
-end
-
-class Hash
-  def to_inquiry
-    ::Ransack::Adapters::Mongoid::InquiryHash[self]
-  end
-end

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

@@ -1,88 +0,0 @@
-module Ransack
-  module Constants
-    DERIVED_PREDICATES = [
-      [CONT, {
-        :arel_predicate => 'matches',
-        :formatter => proc { |v| "#{escape_regex(v)}" }
-        }
-      ],
-      ['not_cont', {
-        :arel_predicate => 'does_not_match',
-        :formatter => proc { |v| "#{escape_regex(v)}" }
-        }
-      ],
-      ['start', {
-        :arel_predicate => 'matches',
-        :formatter => proc { |v| "\\A#{escape_regex(v)}" }
-        }
-      ],
-      ['not_start', {
-        :arel_predicate => 'does_not_match',
-        :formatter => proc { |v| "\\A#{escape_regex(v)}" }
-        }
-      ],
-      ['end', {
-        :arel_predicate => 'matches',
-        :formatter => proc { |v| "#{escape_regex(v)}\\Z" }
-        }
-      ],
-      ['not_end', {
-        :arel_predicate => 'does_not_match',
-        :formatter => proc { |v| "#{escape_regex(v)}\\Z" }
-        }
-      ],
-      ['true', {
-        :arel_predicate => 'eq',
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| TRUE_VALUES.include?(v) }
-        }
-      ],
-      ['false', {
-        :arel_predicate => 'eq',
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| TRUE_VALUES.include?(v) },
-        :formatter => proc { |v| !v }
-        }
-      ],
-      ['present', {
-        :arel_predicate => proc { |v| v ? 'not_eq_all' : 'eq_any' },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| [nil, ''] }
-        }
-      ],
-      ['blank', {
-        :arel_predicate => proc { |v| v ? 'eq_any' : 'not_eq_all' },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| [nil, ''] }
-        }
-      ],
-      ['null', {
-        :arel_predicate => proc { |v| v ? 'eq' : 'not_eq' },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v)},
-        :formatter => proc { |v| nil }
-        }
-      ],
-      ['not_null', {
-        :arel_predicate => proc { |v| v ? 'not_eq' : 'eq' },
-        :compounds => false,
-        :type => :boolean,
-        :validator => proc { |v| BOOLEAN_VALUES.include?(v) },
-        :formatter => proc { |v| nil } }
-      ]
-    ]
-
-  module_function
-    # does nothing
-    def escape_regex(unescaped)
-      Regexp.escape(unescaped)
-    end
-  end
-end

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

@@ -1,59 +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
-    end
-
-    def bind_pair_for(key)
-      @bind_pairs ||= {}
-
-      @bind_pairs[key] ||= begin
-        parent, attr_name = get_parent_and_attribute_name(key.to_s)
-        [parent, attr_name] if parent && attr_name
-      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,22 +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 && combinator == 'and'
-          Arel::Nodes::Grouping.new(Arel::Nodes::And.new(predicates))
-        else
-          predicates.inject(&:or)
-        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,18 +0,0 @@
-module Ransack
-  class Visitor
-    def visit_and(object)
-      nodes = object.values.map { |o| accept(o) }.compact
-      nodes.inject(&:and)
-    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/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