ransack 1.5.1 → 1.6.0

data/lib/ransack/nodes/sort.rb

@@ -8,6 +8,7 @@ module Ransack
 
       class << self
         def extract(context, str)
+          return unless str
           attr, direction = str.split(/\s+/,2)
           self.new(context).build(name: attr, dir: direction)
         end
@@ -37,10 +38,10 @@ module Ransack
       def dir=(dir)
         dir = dir.downcase if dir
         @dir =
-          if Ransack::Constants::ASC_DESC.include?(dir)
+          if Constants::ASC_DESC.include?(dir)
             dir
           else
-            Ransack::Constants::ASC
+            Constants::ASC
           end
       end
 

data/lib/ransack/nodes/value.rb

@@ -14,8 +14,7 @@ module Ransack
       end
 
       def eql?(other)
-        self.class == other.class &&
-        self.value == other.value
+        self.class == other.class && self.value == other.value
       end
       alias :== :eql?
 

data/lib/ransack/predicate.rb

@@ -19,7 +19,7 @@ module Ransack
 
       def detect_and_strip_from_string!(str)
         if p = detect_from_string(str)
-          str.sub! /_#{p}$/, Ransack::Constants::EMPTY
+          str.sub! /_#{p}$/, Constants::EMPTY
           p
         end
       end
@@ -49,7 +49,7 @@ module Ransack
         lambda { |v| v.respond_to?(:empty?) ? !v.empty? : !v.nil? }
       @compound = opts[:compound]
       @wants_array = opts[:wants_array] == true || @compound ||
-        Ransack::Constants::IN_NOT_IN.include?(@arel_predicate)
+        Constants::IN_NOT_IN.include?(@arel_predicate)
     end
 
     def eql?(other)
@@ -71,7 +71,7 @@ module Ransack
     end
 
     def validate(vals, type = @type)
-      vals.select { |v| validator.call(type ? v.cast(type) : v.value) }.any?
+      vals.any? { |v| validator.call(type ? v.cast(type) : v.value) }
     end
 
   end

data/lib/ransack/search.rb

@@ -1,5 +1,14 @@
 require 'ransack/nodes'
 require 'ransack/context'
+
+if defined?(::ActiveRecord::Base)
+  require 'ransack/adapters/active_record/ransack/context'
+end
+
+if defined?(::Mongoid)
+  require 'ransack/adapters/mongoid/ransack/context'
+end
+
 require 'ransack/naming'
 
 module Ransack
@@ -23,10 +32,10 @@ module Ransack
       @context = options[:context] || Context.for(object, options)
       @context.auth_object = options[:auth_object]
       @base = Nodes::Grouping.new(
-        @context,
-        options[:grouping] || Ransack::Constants::AND
+        @context, options[:grouping] || Constants::AND
         )
       @scope_args = {}
+      @sorts ||= []
       build(params.with_indifferent_access)
     end
 
@@ -36,7 +45,7 @@ module Ransack
 
     def build(params)
       collapse_multiparameter_attributes!(params).each do |key, value|
-        if Ransack::Constants::S_SORTS.include?(key)
+        if Constants::S_SORTS.include?(key)
           send("#{key}=", value)
         elsif base.attribute_method?(key)
           base.send("#{key}=", value)
@@ -75,7 +84,7 @@ module Ransack
     alias :s= :sorts=
 
     def sorts
-      @sorts ||= []
+      @sorts
     end
     alias :s :sorts
 
@@ -91,7 +100,7 @@ module Ransack
 
     def method_missing(method_id, *args)
       method_name = method_id.to_s
-      getter_name = method_name.sub(/=$/, Ransack::Constants::EMPTY)
+      getter_name = method_name.sub(/=$/, Constants::EMPTY)
       if base.attribute_method?(getter_name)
         base.send(method_id, *args)
       elsif @context.ransackable_scope?(getter_name, @context.object)
@@ -111,8 +120,9 @@ module Ransack
         ([:scope, @scope_args] if @scope_args.present?),
         [:base, base.inspect]
       ]
-      .compact.map { |d| d.join(': '.freeze) }
-      .join(Ransack::Constants::COMMA_SPACE)
+      .compact
+      .map { |d| d.join(Constants::COLON_SPACE) }
+      .join(Constants::COMMA_SPACE)
 
       "Ransack::Search<#{details}>"
     end
@@ -123,22 +133,45 @@ module Ransack
       if @context.scope_arity(key) == 1
         @scope_args[key] = args.is_a?(Array) ? args[0] : args
       else
-        @scope_args[key] = args
+        @scope_args[key] = args.is_a?(Array) ? sanitized_scope_args(args) : args
+      end
+      @context.chain_scope(key, sanitized_scope_args(args))
+    end
+
+    def sanitized_scope_args(args)
+      if args.is_a?(Array)
+        args = args.map(&method(:sanitized_scope_args))
+      end
+
+      if Constants::TRUE_VALUES.include? args
+        true
+      elsif Constants::FALSE_VALUES.include? args
+        false
+      else
+        args
       end
-      @context.chain_scope(key, args)
     end
 
     def collapse_multiparameter_attributes!(attrs)
-      attrs.keys.each do |k|
-        if k.include?('('.freeze)
+      attrs.each_key do |k|
+        if k.include?(Constants::LEFT_PARENTHESIS)
           real_attribute, position = k.split(/\(|\)/)
-          cast = %w(a s i).freeze.include?(position.last) ? position.last : nil
+          cast =
+          if Constants::A_S_I.include?(position.last)
+            position.last
+          else
+            nil
+          end
           position = position.to_i - 1
           value = attrs.delete(k)
           attrs[real_attribute] ||= []
           attrs[real_attribute][position] =
           if cast
-            value.blank? && cast == 'i'.freeze ? nil : value.send("to_#{cast}")
+            if value.blank? && cast == Constants::I
+              nil
+            else
+              value.send("to_#{cast}")
+            end
           else
             value
           end

data/lib/ransack/translate.rb

@@ -25,8 +25,7 @@ module Ransack
         |x| x.respond_to?(:model_name)
       }
       predicate = Predicate.detect_from_string(original_name)
-      attributes_str = original_name
-        .sub(/_#{predicate}$/, Ransack::Constants::EMPTY)
+      attributes_str = original_name.sub(/_#{predicate}$/, Constants::EMPTY)
       attribute_names = attributes_str.split(/_and_|_or_/)
       combinator = attributes_str.match(/_and_/) ? :and : :or
       defaults = base_ancestors.map do |klass|
@@ -74,7 +73,7 @@ module Ransack
     def self.attribute_name(context, name, include_associations = nil)
       @context, @name = context, name
       @assoc_path = context.association_path(name)
-      @attr_name = @name.sub(/^#{@assoc_path}_/, Ransack::Constants::EMPTY)
+      @attr_name = @name.sub(/^#{@assoc_path}_/, Constants::EMPTY)
       associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
       @include_associated = include_associations && associated_class
 
@@ -150,11 +149,12 @@ module Ransack
     end
 
     def self.i18n_key(klass)
-      if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
-        klass.model_name.i18n_key.to_s.tr('.'.freeze, '/'.freeze)
-      else
-        klass.model_name.i18n_key.to_s
-      end
+      # 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
+      raise "not implemented"
     end
   end
 end

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = "1.5.1"
+  VERSION = "1.6.0"
 end

data/lib/ransack/visitor.rb

@@ -18,7 +18,7 @@ module Ransack
     end
 
     def visit_Ransack_Nodes_Grouping(object)
-      if object.combinator == Ransack::Constants::OR
+      if object.combinator == Constants::OR
         visit_or(object)
       else
         visit_and(object)
@@ -26,14 +26,7 @@ module Ransack
     end
 
     def visit_and(object)
-      nodes = object.values.map { |o| accept(o) }.compact
-      return nil unless nodes.size > 0
-
-      if nodes.size > 1
-        Arel::Nodes::Grouping.new(Arel::Nodes::And.new(nodes))
-      else
-        nodes.first
-      end
+      raise "not implemented"
     end
 
     def visit_or(object)
@@ -52,12 +45,7 @@ module Ransack
     end
 
     def quoted?(object)
-      case object
-      when Arel::Nodes::SqlLiteral, Bignum, Fixnum
-        false
-      else
-        true
-      end
+      raise "not implemented"
     end
 
     def visit(object)
@@ -66,7 +54,7 @@ module Ransack
 
     DISPATCH = Hash.new do |hash, klass|
       hash[klass] = "visit_#{
-        klass.name.gsub('::'.freeze, Ransack::Constants::UNDERSCORE)
+        klass.name.gsub(Constants::TWO_COLONS, Constants::UNDERSCORE)
         }"
     end
 

data/ransack.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/activerecord-hackery/ransack"
   s.summary     = %q{Object-based searching for ActiveRecord (currently).}
   s.description = %q{Ransack is the successor to the MetaSearch gem. It improves and expands upon MetaSearch's functionality, but does not have a 100%-compatible API.}
+  s.required_ruby_version = '>= 1.9'
   s.license     = 'MIT'
 
   s.rubyforge_project = "ransack"

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

@@ -0,0 +1,276 @@
+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