ransack 1.5.1 → 1.6.0

data/spec/mongoid/support/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: ransack_mongoid_test
+      hosts:
+        - localhost:27017

data/spec/mongoid/support/schema.rb

@@ -0,0 +1,128 @@
+require 'mongoid'
+
+Mongoid.load!(File.expand_path("../mongoid.yml", __FILE__), :test)
+
+class Person
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  field :name, type: String
+  field :email, type: String
+  field :only_search, type: String
+  field :only_sort, type: String
+  field :only_admin, type: String
+  field :salary, type: Integer
+  field :awesome, type: Boolean, default: false
+
+  belongs_to :parent, :class_name => 'Person', inverse_of: :children
+  has_many   :children, :class_name => 'Person', inverse_of: :parent
+
+  has_many   :articles
+  has_many   :comments
+
+  # has_many   :authored_article_comments, :through => :articles,
+             # :source => :comments, :foreign_key => :person_id
+
+  has_many   :notes, :as => :notable
+
+  default_scope -> { order(id: :desc) }
+
+  scope :restricted,  lambda { where(restricted: 1) }
+  scope :active,      lambda { where(active: 1) }
+  scope :over_age,    lambda { |y| where(:age.gt => y) }
+
+  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]
+    #   )
+    parent.table[:name]
+  end
+
+  def self.ransackable_attributes(auth_object = nil)
+    if auth_object == :admin
+      all_ransackable_attributes - ['only_sort']
+    else
+      all_ransackable_attributes - ['only_sort', 'only_admin']
+    end
+  end
+
+  def self.ransortable_attributes(auth_object = nil)
+    if auth_object == :admin
+      all_ransackable_attributes - ['only_search']
+    else
+      all_ransackable_attributes - ['only_search', 'only_admin']
+    end
+  end
+end
+
+class Article
+  include Mongoid::Document
+
+  field :title, type: String
+  field :body, type: String
+
+  belongs_to :person
+  has_many :comments
+  # has_and_belongs_to_many :tags
+  has_many :notes, :as => :notable
+end
+
+module Namespace
+  class Article < ::Article
+
+  end
+end
+
+class Comment
+  include Mongoid::Document
+
+  field :body, type: String
+
+
+  belongs_to :article
+  belongs_to :person
+end
+
+class Tag
+  include Mongoid::Document
+
+  field :name, type: String
+
+  # has_and_belongs_to_many :articles
+end
+
+class Note
+  include Mongoid::Document
+
+  field :note, type: String
+
+  belongs_to :notable, :polymorphic => true
+end
+
+module Schema
+  def self.create
+    10.times do
+      person = Person.make.save!
+      Note.make.save!(:notable => person)
+      3.times do
+        article = Article.create!(:person => person)
+        3.times do
+          # article.tags = [Tag.make.save!, Tag.make.save!, Tag.make.save!]
+        end
+        Note.create.save!(:notable => article)
+        10.times do
+          Comment.create.save!(:article => article, :person => person)
+        end
+      end
+    end
+
+    Comment.create!(
+      :body => 'First post!',
+      :article => Article.create!(:title => 'Hello, world!')
+      )
+  end
+end

data/spec/mongoid/translate_spec.rb

@@ -0,0 +1,14 @@
+require 'mongoid_spec_helper'
+
+module Ransack
+  describe Translate do
+
+    describe '.attribute' do
+      it 'translate namespaced attribute like AR does' do
+        ar_translation = ::Namespace::Article.human_attribute_name(:title)
+        ransack_translation = Ransack::Translate.attribute(:title, :context => ::Namespace::Article.search.context)
+        expect(ransack_translation).to eq ar_translation
+      end
+    end
+  end
+end

data/spec/mongoid_spec_helper.rb

@@ -0,0 +1,59 @@
+require 'machinist/object'
+require 'sham'
+require 'faker'
+require 'pry'
+require 'mongoid'
+require 'ransack'
+
+I18n.enforce_available_locales = false
+Time.zone = 'Eastern Time (US & Canada)'
+I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'support', '*.yml')]
+
+Dir[File.expand_path('../{mongoid/helpers,mongoid/support,blueprints}/*.rb', __FILE__)]
+.each do |f|
+  require f
+end
+
+Sham.define do
+  name        { Faker::Name.name }
+  title       { Faker::Lorem.sentence }
+  body        { Faker::Lorem.paragraph }
+  salary      { |index| 30000 + (index * 1000) }
+  tag_name    { Faker::Lorem.words(3).join(' ') }
+  note        { Faker::Lorem.words(7).join(' ') }
+  only_admin  { Faker::Lorem.words(3).join(' ') }
+  only_search { Faker::Lorem.words(3).join(' ') }
+  only_sort   { Faker::Lorem.words(3).join(' ') }
+  notable_id  { |id| id }
+end
+
+RSpec.configure do |config|
+  config.alias_it_should_behave_like_to :it_has_behavior, 'has behavior'
+
+  config.before(:suite) do
+    puts '=' * 80
+    connection_name = Mongoid.default_session.inspect
+    puts "Running specs against #{connection_name}, Mongoid #{
+      Mongoid::VERSION}, Moped #{Moped::VERSION} and Origin #{Origin::VERSION}..."
+    puts '=' * 80
+    Schema.create
+  end
+
+  config.before(:all)   { Sham.reset(:before_all) }
+  config.before(:each)  { Sham.reset(:before_each) }
+
+  config.include RansackHelper
+end
+
+RSpec::Matchers.define :be_like do |expected|
+  match do |actual|
+    actual.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip ==
+      expected.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip
+  end
+end
+
+RSpec::Matchers.define :have_attribute_method do |expected|
+  match do |actual|
+    actual.attribute_method?(expected)
+  end
+end

data/spec/ransack/adapters/active_record/base_spec.rb

@@ -11,7 +11,7 @@ module Ransack
         it { should respond_to :search }
 
         describe '#search' do
-          subject { Person.search }
+          subject { Person.ransack }
 
           it { should be_a Search }
           it 'has a Relation as its object' do
@@ -20,43 +20,63 @@ module Ransack
 
           context 'with scopes' do
             before do
-              Person.stub :ransackable_scopes => [:active, :over_age]
+              Person.stub :ransackable_scopes => [:active, :over_age, :of_age]
             end
 
             it "applies true scopes" do
-              search = Person.search('active' => true)
+              search = Person.ransack('active' => true)
               search.result.to_sql.should include "active = 1"
             end
 
+            it "applies stringy true scopes" do
+              search = Person.ransack('active' => 'true')
+              search.result.to_sql.should include "active = 1"
+            end
+
+            it "applies stringy boolean scopes with true value in an array" do
+              search = Person.ransack('of_age' => ['true'])
+              search.result.to_sql.should include "age >= 18"
+            end
+
+            it "applies stringy boolean scopes with false value in an array" do
+              search = Person.ransack('of_age' => ['false'])
+              search.result.to_sql.should include "age < 18"
+            end
+
             it "ignores unlisted scopes" do
-              search = Person.search('restricted' => true)
+              search = Person.ransack('restricted' => true)
               search.result.to_sql.should_not include "restricted"
             end
 
             it "ignores false scopes" do
-              search = Person.search('active' => false)
+              search = Person.ransack('active' => false)
+              search.result.to_sql.should_not include "active"
+            end
+
+            it "ignores stringy false scopes" do
+              search = Person.ransack('active' => 'false')
               search.result.to_sql.should_not include "active"
             end
 
             it "passes values to scopes" do
-              search = Person.search('over_age' => 18)
+              search = Person.ransack('over_age' => 18)
               search.result.to_sql.should include "age > 18"
             end
 
             it "chains scopes" do
-              search = Person.search('over_age' => 18, 'active' => true)
+              search = Person.ransack('over_age' => 18, 'active' => true)
               search.result.to_sql.should include "age > 18"
               search.result.to_sql.should include "active = 1"
             end
           end
 
           it 'does not raise exception for string :params argument' do
-            lambda { Person.search('') }.should_not raise_error
+            lambda { Person.ransack('') }.should_not raise_error
           end
 
           it 'does not modify the parameters' do
             params = { :name_eq => '' }
-            expect { Person.search(params) }.not_to change { params }
+            expect { Person.ransack(params) }.not_to change { params }
           end
         end
 
@@ -82,14 +102,14 @@ module Ransack
           # end
 
           it 'creates ransack attributes' do
-            s = Person.search(:reversed_name_eq => 'htimS cirA')
+            s = Person.ransack(:reversed_name_eq => 'htimS cirA')
             expect(s.result.size).to eq(1)
 
             expect(s.result.first).to eq Person.where(name: 'Aric Smith').first
           end
 
           it 'can be accessed through associations' do
-            s = Person.search(:children_reversed_name_eq => 'htimS cirA')
+            s = Person.ransack(:children_reversed_name_eq => 'htimS cirA')
             expect(s.result.to_sql).to match(
               /#{quote_table_name("children_people")}.#{
                  quote_column_name("name")} = 'Aric Smith'/
@@ -97,80 +117,93 @@ module Ransack
           end
 
           it 'allows an "attribute" to be an InfixOperation' do
-            s = Person.search(:doubled_name_eq => 'Aric SmithAric Smith')
+            s = Person.ransack(: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')
+            s = Person.ransack(: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(:children_reversed_name_eq => '')
+            s = Person.ransack(:children_reversed_name_eq => '')
             expect(s.result.to_sql).not_to match /LEFT OUTER JOIN/
           end
 
           it "should keep proper key value pairs in the params hash" do
-            s = Person.search(:children_reversed_name_eq => 'Testing')
+            s = Person.ransack(:children_reversed_name_eq => 'Testing')
             expect(s.result.to_sql).to match /LEFT OUTER JOIN/
           end
 
           it "should function correctly when nil is passed in" do
-            s = Person.search(nil)
+            s = Person.ransack(nil)
           end
 
           it "should function correctly when a blank string is passed in" do
-            s = Person.search('')
+            s = Person.ransack('')
           end
 
           it "should function correctly when using fields with dots in them" do
-            s = Person.search(:email_cont => "example.com")
+            s = Person.ransack(:email_cont => "example.com")
             expect(s.result.exists?).to be true
           end
 
           it "should function correctly when using fields with % in them" do
             p = Person.create!(:name => "110%-er")
-            s = Person.search(:name_cont => "10%")
+            s = Person.ransack(:name_cont => "10%")
             expect(s.result.to_a).to eq [p]
           end
 
           it "should function correctly when using fields with backslashes in them" do
             p = Person.create!(:name => "\\WINNER\\")
-            s = Person.search(:name_cont => "\\WINNER\\")
+            s = Person.ransack(:name_cont => "\\WINNER\\")
             expect(s.result.to_a).to eq [p]
           end
 
+          context "search using an `in` predicate and an array passed to a ransacker" do
+            it "should function correctly when passing an array of ids" do
+              s = Person.ransack(array_users_in: true)
+              expect(s.result.length).to be > 0
+            end
+
+            it "should function correctly when passing an array of strings" do
+              p = Person.create!(name: Person.first.id.to_s)
+              s = Person.ransack(array_names_in: true)
+              expect(s.result.length).to be > 0
+            end
+          end
+
           it "should function correctly when an attribute name ends with '_start'" do
             p = Person.create!(:new_start => 'Bar and foo', :name => 'Xiang')
 
-            s = Person.search(:new_start_end => ' and foo')
+            s = Person.ransack(:new_start_end => ' and foo')
             expect(s.result.to_a).to eq [p]
 
-            s = Person.search(:name_or_new_start_start => 'Xia')
+            s = Person.ransack(:name_or_new_start_start => 'Xia')
             expect(s.result.to_a).to eq [p]
 
-            s = Person.search(:new_start_or_name_end => 'iang')
+            s = Person.ransack(:new_start_or_name_end => 'iang')
             expect(s.result.to_a).to eq [p]
           end
 
           it "should function correctly when an attribute name ends with '_end'" do
             p = Person.create!(:stop_end => 'Foo and bar', :name => 'Marianne')
 
-            s = Person.search(:stop_end_start => 'Foo and')
+            s = Person.ransack(:stop_end_start => 'Foo and')
             expect(s.result.to_a).to eq [p]
 
-            s = Person.search(:stop_end_or_name_end => 'anne')
+            s = Person.ransack(:stop_end_or_name_end => 'anne')
             expect(s.result.to_a).to eq [p]
 
-            s = Person.search(:name_or_stop_end_end => ' bar')
+            s = Person.ransack(:name_or_stop_end_end => ' bar')
             expect(s.result.to_a).to eq [p]
           end
 
           it "should function correctly when an attribute name has 'and' in it" do
           # FIXME: this test does not pass!
             p = Person.create!(:terms_and_conditions => true)
-            s = Person.search(:terms_and_conditions_eq => true)
+            s = Person.ransack(:terms_and_conditions_eq => true)
           # search is not detecting the attribute
             puts "
             FIXME: Search not detecting the `terms_and_conditions` attribute in
@@ -179,7 +212,7 @@ module Ransack
           end
 
           it 'allows sort by "only_sort" field' do
-            s = Person.search(
+            s = Person.ransack(
               "s" => { "0" => { "dir" => "asc", "name" => "only_sort" } }
             )
             expect(s.result.to_sql).to match(
@@ -189,7 +222,7 @@ module Ransack
           end
 
           it "doesn't sort by 'only_search' field" do
-            s = Person.search(
+            s = Person.ransack(
               "s" => { "0" => { "dir" => "asc", "name" => "only_search" } }
             )
             expect(s.result.to_sql).not_to match(
@@ -199,7 +232,7 @@ module Ransack
           end
 
           it 'allows search by "only_search" field' do
-            s = Person.search(:only_search_eq => 'htimS cirA')
+            s = Person.ransack(:only_search_eq => 'htimS cirA')
             expect(s.result.to_sql).to match(
               /WHERE #{quote_table_name("people")}.#{
                 quote_column_name("only_search")} = 'htimS cirA'/
@@ -207,7 +240,7 @@ module Ransack
           end
 
           it "can't be searched by 'only_sort'" do
-            s = Person.search(:only_sort_eq => 'htimS cirA')
+            s = Person.ransack(:only_sort_eq => 'htimS cirA')
             expect(s.result.to_sql).not_to match(
               /WHERE #{quote_table_name("people")}.#{
                 quote_column_name("only_sort")} = 'htimS cirA'/
@@ -215,7 +248,7 @@ module Ransack
           end
 
           it 'allows sort by "only_admin" field, if auth_object: :admin' do
-            s = Person.search(
+            s = Person.ransack(
               { "s" => { "0" => { "dir" => "asc", "name" => "only_admin" } } },
               { auth_object: :admin }
             )
@@ -226,7 +259,7 @@ module Ransack
           end
 
           it "doesn't sort by 'only_admin' field, if auth_object: nil" do
-            s = Person.search(
+            s = Person.ransack(
               "s" => { "0" => { "dir" => "asc", "name" => "only_admin" } }
             )
             expect(s.result.to_sql).not_to match(
@@ -236,7 +269,7 @@ module Ransack
           end
 
           it 'allows search by "only_admin" field, if auth_object: :admin' do
-            s = Person.search(
+            s = Person.ransack(
               { :only_admin_eq => 'htimS cirA' },
               { :auth_object => :admin }
             )
@@ -247,7 +280,7 @@ module Ransack
           end
 
           it "can't be searched by 'only_admin', if auth_object: nil" do
-            s = Person.search(:only_admin_eq => 'htimS cirA')
+            s = Person.ransack(:only_admin_eq => 'htimS cirA')
             expect(s.result.to_sql).not_to match(
               /WHERE #{quote_table_name("people")}.#{
                 quote_column_name("only_admin")} = 'htimS cirA'/