ransack 1.8.4 → 3.2.1

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