ransack 1.1.0 → 1.2.0

data/spec/ransack/helpers/form_helper_spec.rb

@@ -26,10 +26,11 @@ module Ransack
       end
 
       describe '#sort_link with default search_key' do
-        subject {
-          @controller.view_context.sort_link(
-            [:main_app, Person.search(:sorts => ['name desc'])],
-            :name, :controller => 'people'
+        subject { @controller.view_context.
+          sort_link(
+            [:main_app, Person.search(sorts: ['name desc'])],
+            :name,
+            controller: 'people'
           )
         }
         it { should match(
@@ -75,7 +76,6 @@ module Ransack
         } 
       end
 
-
       context 'view has existing parameters' do
         before do
           @controller.view_context.params.merge!({ :exist => 'existing' })

data/spec/ransack/predicate_spec.rb

@@ -22,14 +22,17 @@ module Ransack
     describe 'eq' do
       it 'generates an equality condition for boolean true' do
         @s.awesome_eq = true
-        field = "#{quote_table_name("people")}.#{quote_column_name("awesome")}"
-        @s.result.to_sql.should match /#{field} = #{ActiveRecord::Base.connection.quoted_true}/
+        field = "#{quote_table_name("people")}.#{
+          quote_column_name("awesome")}"
+        @s.result.to_sql.should match /#{field} = #{
+          ActiveRecord::Base.connection.quoted_true}/
       end
 
       it 'generates an equality condition for boolean false' do
         @s.awesome_eq = false
         field = "#{quote_table_name("people")}.#{quote_column_name("awesome")}"
-        @s.result.to_sql.should match /#{field} = #{ActiveRecord::Base.connection.quoted_false}/
+        @s.result.to_sql.should match /#{field} = #{
+          ActiveRecord::Base.connection.quoted_false}/
       end
 
       it 'does not generate a condition for nil' do

data/spec/ransack/search_spec.rb

@@ -3,9 +3,15 @@ require 'spec_helper'
 module Ransack
   describe Search do
 
+    describe '#initialize' do
+      it 'does not raise exception for string :params argument' do
+        lambda { Search.new(Person, '') }.should_not raise_error
+      end
+    end
+
     describe '#build' do
-      it 'creates Conditions for top-level attributes' do
-        search = Search.new(Person, :name_eq => 'Ernie')
+      it 'creates conditions for top-level attributes' do
+        search = Search.new(Person, name_eq: 'Ernie')
         condition = search.base[:name_eq]
         condition.should be_a Nodes::Condition
         condition.predicate.name.should eq 'eq'
@@ -13,8 +19,8 @@ module Ransack
         condition.value.should eq 'Ernie'
       end
 
-      it 'creates Conditions for association attributes' do
-        search = Search.new(Person, :children_name_eq => 'Ernie')
+      it 'creates conditions for association attributes' do
+        search = Search.new(Person, children_name_eq: 'Ernie')
         condition = search.base[:children_name_eq]
         condition.should be_a Nodes::Condition
         condition.predicate.name.should eq 'eq'
@@ -22,8 +28,8 @@ module Ransack
         condition.value.should eq 'Ernie'
       end
 
-      it 'creates Conditions for polymorphic belongs_to association attributes' do
-        search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
+      it 'creates conditions for polymorphic belongs_to association attributes' do
+        search = Search.new(Note, notable_of_Person_type_name_eq: 'Ernie')
         condition = search.base[:notable_of_Person_type_name_eq]
         condition.should be_a Nodes::Condition
         condition.predicate.name.should eq 'eq'
@@ -31,9 +37,9 @@ module Ransack
         condition.value.should eq 'Ernie'
       end
 
-      it 'creates Conditions for multiple polymorphic belongs_to association attributes' do
+      it 'creates conditions for multiple polymorphic belongs_to association attributes' do
         search = Search.new(Note,
-          :notable_of_Person_type_name_or_notable_of_Article_type_title_eq => 'Ernie')
+          notable_of_Person_type_name_or_notable_of_Article_type_title_eq: 'Ernie')
         condition = search.
           base[:notable_of_Person_type_name_or_notable_of_Article_type_title_eq]
         condition.should be_a Nodes::Condition
@@ -44,16 +50,16 @@ module Ransack
       end
 
       it 'discards empty conditions' do
-        search = Search.new(Person, :children_name_eq => '')
+        search = Search.new(Person, children_name_eq: '')
         condition = search.base[:children_name_eq]
         condition.should be_nil
       end
 
       it 'accepts arrays of groupings' do
         search = Search.new(Person,
-          :g => [
-            { :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' },
-            { :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert' },
+          g: [
+            { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
+            { m: 'or', name_eq: 'Bert',  children_name_eq: 'Bert' },
           ]
         )
         ors = search.groupings
@@ -67,9 +73,9 @@ module Ransack
 
       it 'accepts "attributes" hashes for groupings' do
         search = Search.new(Person,
-          :g => {
-            '0' => { :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' },
-            '1' => { :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert' },
+          g: {
+            '0' => { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' },
+            '1' => { m: 'or', name_eq: 'Bert',  children_name_eq: 'Bert' },
           }
         )
         ors = search.groupings
@@ -85,20 +91,22 @@ module Ransack
         search = Search.new(Person,
           :c => {
             '0' => { :a => ['name'], :p => 'eq', :v => ['Ernie'] },
-            '1' => { :a => ['children_name', 'parent_name'], :p => 'eq', :v => ['Ernie'], :m => 'or' }
-          }
+            '1' => { :a => ['children_name', 'parent_name'],
+                     :p => 'eq', :v => ['Ernie'], :m => 'or' }
+            }
         )
         conditions = search.base.conditions
         conditions.should have(2).items
-        conditions.map {|c| c.class}.should eq [Nodes::Condition, Nodes::Condition]
+        conditions.map { |c| c.class }
+        .should eq [Nodes::Condition, Nodes::Condition]
       end
 
-      it 'creates Conditions for custom predicates that take arrays' do
+      it 'creates conditions for custom predicates that take arrays' do
         Ransack.configure do |config|
           config.add_predicate 'ary_pred', :wants_array => true
         end
 
-        search = Search.new(Person, :name_ary_pred => ['Ernie', 'Bert'])
+        search = Search.new(Person, name_ary_pred: ['Ernie', 'Bert'])
         condition = search.base[:name_ary_pred]
         condition.should be_a Nodes::Condition
         condition.predicate.name.should eq 'ary_pred'
@@ -107,56 +115,59 @@ module Ransack
       end
 
       it 'does not evaluate the query on #inspect' do
-        search = Search.new(Person, :children_id_in => [1, 2, 3])
+        search = Search.new(Person, children_id_in: [1, 2, 3])
         search.inspect.should_not match /ActiveRecord/
       end
     end
 
     describe '#result' do
-      let(:people_name_field) { "#{quote_table_name("people")}.#{quote_column_name("name")}" }
-      let(:children_people_name_field) { "#{quote_table_name("children_people")}.#{quote_column_name("name")}" }
+      let(:people_name_field) {
+        "#{quote_table_name("people")}.#{quote_column_name("name")}"
+      }
+      let(:children_people_name_field) {
+        "#{quote_table_name("children_people")}.#{quote_column_name("name")}"
+      }
       it 'evaluates conditions contextually' do
-        search = Search.new(Person, :children_name_eq => 'Ernie')
+        search = Search.new(Person, children_name_eq: 'Ernie')
         search.result.should be_an ActiveRecord::Relation
         where = search.result.where_values.first
         where.to_sql.should match /#{children_people_name_field} = 'Ernie'/
       end
 
       it 'evaluates compound conditions contextually' do
-        search = Search.new(Person, :children_name_or_name_eq => 'Ernie')
+        search = Search.new(Person, children_name_or_name_eq: 'Ernie')
         search.result.should be_an ActiveRecord::Relation
         where = search.result.where_values.first
-        where.to_sql.should match /#{children_people_name_field} = 'Ernie' OR #{people_name_field} = 'Ernie'/
+        where.to_sql.should match /#{children_people_name_field
+          } = 'Ernie' OR #{people_name_field} = 'Ernie'/
       end
 
       it 'evaluates polymorphic belongs_to association conditions contextually' do
-        search = Search.new(Note, :notable_of_Person_type_name_eq => 'Ernie')
+        search = Search.new(Note, notable_of_Person_type_name_eq: 'Ernie')
         search.result.should be_an ActiveRecord::Relation
         where = search.result.where_values.first
         where.to_sql.should match /#{people_name_field} = 'Ernie'/
       end
 
       it 'evaluates nested conditions' do
-        search = Search.new(Person, :children_name_eq => 'Ernie',
-          :g => [
-            { :m => 'or',
-              :name_eq => 'Ernie',
-              :children_children_name_eq => 'Ernie'
-            }
+        search = Search.new(Person, children_name_eq: 'Ernie',
+          g: [
+            { m: 'or', name_eq: 'Ernie', children_children_name_eq: 'Ernie' }
           ]
         )
         search.result.should be_an ActiveRecord::Relation
         where = search.result.where_values.first
         where.to_sql.should match /#{children_people_name_field} = 'Ernie'/
         where.to_sql.should match /#{people_name_field} = 'Ernie'/
-        where.to_sql.should match /#{quote_table_name("children_people_2")}.#{quote_column_name("name")} = 'Ernie'/
+        where.to_sql.should match /#{quote_table_name("children_people_2")
+          }.#{quote_column_name("name")} = 'Ernie'/
       end
 
       it 'evaluates arrays of groupings' do
         search = Search.new(Person,
-          :g => [
-            { :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' },
-            { :m => 'or', :name_eq => 'Bert', :children_name_eq => 'Bert' },
+          g: [
+            { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie'},
+            { m: 'or', name_eq: 'Bert',  children_name_eq: 'Bert'},
           ]
         )
         search.result.should be_an ActiveRecord::Relation
@@ -169,26 +180,42 @@ module Ransack
         second.should match /#{children_people_name_field} = 'Bert'/
       end
 
-      it 'returns distinct records when passed :distinct => true' do
-        search = Search.new(
-          Person, :g => [
-            { :m => 'or',
-              :comments_body_cont => 'e',
-              :articles_comments_body_cont => 'e'
-            }
-          ]
-        )
-        if ActiveRecord::VERSION::MAJOR == 3
-          all_or_load, uniq_or_distinct = :all, :uniq
-        else
-          all_or_load, uniq_or_distinct = :load, :distinct
+      if ::ActiveRecord::VERSION::STRING >= "4"
+        it 'returns distinct records when passed distinct: true' do
+          search = Search.new(
+            Person, g: [
+              { m: 'or',
+                comments_body_cont: 'e',
+                articles_comments_body_cont: 'e'
+              }
+            ]
+          )
+          search.result.load.should have(9000).items
+          search.result(distinct: true).should have(10).items
+          search.result.load.uniq.should eq search.result(distinct: true).load
+        end
+      else
+        it 'returns distinct records when passed :distinct => true' do
+          search = Search.new(
+            Person, :g => [
+              { :m => 'or',
+                :comments_body_cont => 'e',
+                :articles_comments_body_cont => 'e'
+              }
+            ]
+          )
+          if ActiveRecord::VERSION::MAJOR == 3
+            all_or_load, uniq_or_distinct = :all, :uniq
+          else
+            all_or_load, uniq_or_distinct = :load, :distinct
+          end
+          search.result.send(all_or_load).
+            should have(9000).items
+          search.result(:distinct => true).
+            should have(10).items
+          search.result.send(all_or_load).send(uniq_or_distinct).
+            should eq search.result(:distinct => true).send(all_or_load)
         end
-        search.result.send(all_or_load).
-          should have(920).items
-        search.result(:distinct => true).
-          should have(330).items
-        search.result.send(all_or_load).send(uniq_or_distinct).
-          should eq search.result(:distinct => true).send(all_or_load)
       end
     end
 
@@ -225,7 +252,7 @@ module Ransack
       end
 
       it 'creates sorts based on multiple attributes/directions in array format' do
-        @s.sorts = ['id desc', 'name asc']
+        @s.sorts = ['id desc', { name: 'name', dir: 'asc' }]
         @s.sorts.should have(2).items
         sort1, sort2 = @s.sorts
         sort1.should be_a Nodes::Sort
@@ -237,7 +264,7 @@ module Ransack
       end
 
       it 'creates sorts based on multiple attributes and uppercase directions in array format' do
-        @s.sorts = ['id DESC', 'name ASC']
+        @s.sorts = ['id DESC', { name: 'name', dir: 'ASC' }]
         @s.sorts.should have(2).items
         sort1, sort2 = @s.sorts
         sort1.should be_a Nodes::Sort
@@ -249,7 +276,7 @@ module Ransack
       end
 
       it 'creates sorts based on multiple attributes and different directions in array format' do
-        @s.sorts = ['id DESC', 'name']
+        @s.sorts = ['id DESC', { name: 'name', dir: nil }]
         @s.sorts.should have(2).items
         sort1, sort2 = @s.sorts
         sort1.should be_a Nodes::Sort
@@ -262,8 +289,8 @@ module Ransack
 
       it 'creates sorts based on multiple attributes/directions in hash format' do
         @s.sorts = {
-          '0' => { :name => 'id', :dir => 'desc' },
-          '1' => { :name => 'name', :dir => 'asc' }
+          '0' => { name: 'id', dir: 'desc' },
+          '1' => { name: 'name', dir: 'asc' }
         }
         @s.sorts.should have(2).items
         @s.sorts.should be_all { |s| Nodes::Sort === s }
@@ -275,8 +302,8 @@ module Ransack
 
       it 'creates sorts based on multiple attributes and uppercase directions in hash format' do
         @s.sorts = {
-            '0' => { :name => 'id', :dir => 'DESC' },
-            '1' => { :name => 'name', :dir => 'ASC' }
+            '0' => { name: 'id', dir: 'DESC' },
+            '1' => { name: 'name', dir: 'ASC' }
         }
         @s.sorts.should have(2).items
         @s.sorts.should be_all { |s| Nodes::Sort === s }
@@ -288,8 +315,8 @@ module Ransack
 
       it 'creates sorts based on multiple attributes and different directions in hash format' do
         @s.sorts = {
-            '0' => { :name => 'id', :dir => 'DESC' },
-            '1' => { :name => 'name', :dir => nil }
+            '0' => { name: 'id', dir: 'DESC' },
+            '1' => { name: 'name', dir: nil }
         }
         @s.sorts.should have(2).items
         @s.sorts.should be_all { |s| Nodes::Sort === s }
@@ -320,16 +347,11 @@ module Ransack
       end
 
       it 'allows chaining to access nested conditions' do
-        @s.groupings = [{ :m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie' }]
+        @s.groupings = [
+          { m: 'or', name_eq: 'Ernie', children_name_eq: 'Ernie' }
+        ]
         @s.groupings.first.children_name_eq.should eq 'Ernie'
       end
     end
-
-    describe '#respond_to' do
-      it 'is aware of second argument' do
-        Search.new(Person).respond_to?(:name_eq, true).should be_true
-      end
-    end
-
   end
 end

data/spec/ransack/translate_spec.rb

@@ -0,0 +1,14 @@
+require '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)
+        ransack_translation.should eq ar_translation
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -6,17 +6,22 @@ require 'ransack'
 Time.zone = 'Eastern Time (US & Canada)'
 I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'support', '*.yml')]
 
-Dir[File.expand_path('../{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
+Dir[File.expand_path('../{helpers,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(' ') }
+  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|
@@ -25,7 +30,8 @@ RSpec.configure do |config|
   config.before(:suite) do
     puts '=' * 80
     connection_name = ActiveRecord::Base.connection.adapter_name
-    puts "Running specs against #{connection_name}, ActiveRecord #{ActiveRecord::VERSION::STRING} and ARel #{Arel::VERSION}..."
+    puts "Running specs against #{connection_name}, ActiveRecord #{
+      ActiveRecord::VERSION::STRING} and ARel #{Arel::VERSION}..."
     puts '=' * 80
     Schema.create
   end

data/spec/support/en.yml

@@ -5,3 +5,9 @@ en:
     attributes:
       person:
         name: Full Name
+  activerecord:
+    attributes:
+      namespace/article:
+        title: AR Namespaced Title
+      namespace_article:
+        title: Old Ransack Namespaced Title

data/spec/support/schema.rb

@@ -26,24 +26,56 @@ class Person < ActiveRecord::Base
   if ActiveRecord::VERSION::MAJOR == 3
     default_scope order('id DESC')
   else
-    default_scope { order('id DESC') }
-    # The new activerecord syntax "{ order(id: :desc) }" does not work
-    # with Ruby 1.8.7 which we still need to support for Rails 3
+    default_scope { order(id: :desc) }
   end
-  belongs_to :parent, :class_name => 'Person', :foreign_key => :parent_id
-  has_many   :children, :class_name => 'Person', :foreign_key => :parent_id
+  belongs_to :parent, class_name: 'Person', foreign_key: :parent_id
+  has_many   :children, class_name: 'Person', foreign_key: :parent_id
   has_many   :articles
   has_many   :comments
-  has_many   :authored_article_comments, :through => :articles,
-             :source => :comments, :foreign_key => :person_id
-  has_many   :notes, :as => :notable
+  has_many   :authored_article_comments, through: :articles,
+              source: :comments, foreign_key: :person_id
+  has_many   :notes, as: :notable
 
-  ransacker :reversed_name, :formatter => proc {|v| v.reverse} do |parent|
+  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])
+    Arel::Nodes::InfixOperation.new(
+      '||', parent.table[:name], parent.table[:name]
+      )
+  end
+
+  def self.ransackable_attributes(auth_object = nil)
+    if auth_object == :admin
+      column_names + _ransackers.keys - ['only_sort']
+    else
+      column_names + _ransackers.keys - ['only_sort', 'only_admin']
+    end
+  end
+
+  def self.ransortable_attributes(auth_object = nil)
+    if auth_object == :admin
+      column_names + _ransackers.keys - ['only_search']
+    else
+      column_names + _ransackers.keys - ['only_search', 'only_admin']
+    end
+  end
+
+  def self.ransackable_attributes(auth_object = nil)
+    if auth_object == :admin
+      column_names + _ransackers.keys - ['only_sort']
+    else
+      column_names + _ransackers.keys - ['only_sort', 'only_admin']
+    end
+  end
+
+  def self.ransortable_attributes(auth_object = nil)
+    if auth_object == :admin
+      column_names + _ransackers.keys - ['only_search']
+    else
+      column_names + _ransackers.keys - ['only_search', 'only_admin']
+    end
   end
 end
 
@@ -51,7 +83,19 @@ class Article < ActiveRecord::Base
   belongs_to              :person
   has_many                :comments
   has_and_belongs_to_many :tags
-  has_many   :notes, :as => :notable
+  has_many                :notes, as: :notable
+end
+
+module Namespace
+  class Article < ::Article
+
+  end
+end
+
+module Namespace
+  class Article < ::Article
+
+  end
 end
 
 class Comment < ActiveRecord::Base
@@ -64,7 +108,7 @@ class Tag < ActiveRecord::Base
 end
 
 class Note < ActiveRecord::Base
-  belongs_to :notable, :polymorphic => true
+  belongs_to :notable, polymorphic: true
 end
 
 module Schema
@@ -72,63 +116,64 @@ module Schema
     ActiveRecord::Migration.verbose = false
 
     ActiveRecord::Schema.define do
-      create_table :people, :force => true do |t|
+      create_table :people, force: true do |t|
         t.integer  :parent_id
         t.string   :name
         t.string   :email
+        t.string   :only_search
+        t.string   :only_sort
+        t.string   :only_admin
         t.integer  :salary
-        t.boolean  :awesome, :default => false
+        t.boolean  :awesome, default: false
         t.timestamps
       end
 
-      create_table :articles, :force => true do |t|
+      create_table :articles, force: true do |t|
         t.integer :person_id
         t.string  :title
         t.text    :body
       end
 
-      create_table :comments, :force => true do |t|
+      create_table :comments, force: true do |t|
         t.integer :article_id
         t.integer :person_id
-        t.text    :body
+        t.text :body
       end
 
-      create_table :tags, :force => true do |t|
+      create_table :tags, force: true do |t|
         t.string :name
       end
 
-      create_table :articles_tags, :force => true, :id => false do |t|
+      create_table :articles_tags, force: true, id: false do |t|
         t.integer :article_id
         t.integer :tag_id
       end
 
-      create_table :notes, :force => true do |t|
+      create_table :notes, force: true do |t|
         t.integer :notable_id
-        t.string  :notable_type
-        t.string  :note
+        t.string :notable_type
+        t.string :note
       end
 
     end
 
     10.times do
       person = Person.make
-      Note.make(:notable => person)
+      Note.make(notable: person)
       3.times do
-        article = Article.make(:person => person)
+        article = Article.make(person: person)
         3.times do
           article.tags = [Tag.make, Tag.make, Tag.make]
         end
-        Note.make(:notable => article)
+        Note.make(notable: article)
         10.times do
-          Comment.make(:article => article)
+          Comment.make(article: article, person: person)
         end
       end
-      2.times do
-        Comment.make(:person => person)
-      end
     end
 
-    Comment.make(:body => 'First post!', :article => Article.make(:title => 'Hello, world!'))
-
+    Comment.make(
+      body: 'First post!', article: Article.make(title: 'Hello, world!')
+      )
   end
 end