ransack 1.1.0 → 1.2.0

data/ransack.gemspec

@@ -8,25 +8,35 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Ernie Miller", "Ryan Bigg"]
   s.email       = ["ernie@erniemiller.org", "radarlistener@gmail.com"]
-  s.homepage    = "https://github.com/ernie/ransack"
+  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.license     = 'MIT'
 
   s.rubyforge_project = "ransack"
 
-  s.add_dependency 'activerecord', '>= 3.0'
   s.add_dependency 'actionpack', '>= 3.0'
-  s.add_dependency 'polyamorous', '~> 0.6.0'
+  s.add_dependency 'activerecord', '>= 3.0'
+  s.add_dependency 'activesupport', '>= 3.0'
+  s.add_dependency 'i18n'
+#  s.add_dependency 'polyamorous', '~> 0.6.0'
   s.add_development_dependency 'rspec', '~> 2.8.0'
   s.add_development_dependency 'machinist', '~> 1.0.6'
   s.add_development_dependency 'faker', '~> 0.9.5'
   s.add_development_dependency 'sqlite3', '~> 1.3.3'
   s.add_development_dependency 'pg', '0.17.0'
-  s.add_development_dependency 'mysql2', '0.3.13'
+  s.add_development_dependency 'mysql2', '0.3.14'
   s.add_development_dependency 'pry', '0.9.12.2'
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files         = `git ls-files`
+                    .split("\n")
+
+  s.test_files    = `git ls-files -- {test,spec,features}/*`
+                    .split("\n")
+
+  s.executables   = `git ls-files -- bin/*`
+                    .split("\n")
+                    .map { |f| File.basename(f) }
+
   s.require_paths = ["lib"]
 end

data/spec/blueprints/notes.rb

@@ -1,3 +1,5 @@
 Note.blueprint do
   note
+  notable_type { "Article" }
+  notable_id
 end

data/spec/blueprints/people.rb

@@ -2,4 +2,7 @@ Person.blueprint do
   name
   email { "test@example.com" }
   salary
-end
+  only_sort
+  only_search
+  only_admin
+end

data/spec/console.rb

@@ -4,7 +4,8 @@ require 'sham'
 require 'faker'
 require 'ransack'
 
-Dir[File.expand_path('../../spec/{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
+Dir[File.expand_path('../../spec/{helpers,support,blueprints}/*.rb', __FILE__)]
+.each do |f|
   require f
 end
 
@@ -12,10 +13,9 @@ Sham.define do
   name     { Faker::Name.name }
   title    { Faker::Lorem.sentence }
   body     { Faker::Lorem.paragraph }
-  salary   {|index| 30000 + (index * 1000)}
+  salary   { |index| 30000 + (index * 1000) }
   tag_name { Faker::Lorem.words(3).join(' ') }
   note     { Faker::Lorem.words(7).join(' ') }
 end
 
 Schema.create
-

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

@@ -23,42 +23,69 @@ module Ransack
           # For infix tests
           def self.sane_adapter?
             case ::ActiveRecord::Base.connection.adapter_name
-              when "SQLite3" || "PostgreSQL"
-                true
-              else
-                false
+            when "SQLite3", "PostgreSQL"
+              true
+            else
+              false
             end
           end
           # in schema.rb, class Person:
-          # 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])
           # end
+
           it 'creates ransack attributes' do
-            s = Person.search(:reversed_name_eq => 'htimS cirA')
+            s = Person.search(reversed_name_eq: 'htimS cirA')
             s.result.should have(1).person
-            s.result.first.should eq Person.find_by_name('Aric Smith')
+
+            if ::ActiveRecord::VERSION::STRING >= "4"
+              s.result.first.should eq Person.find_by(name: 'Aric Smith')
+            else
+              s.result.first.should eq Person.find_by_name('Aric Smith')
+            end
           end
 
           it 'can be accessed through associations' do
-            s = Person.search(:children_reversed_name_eq => 'htimS cirA')
-
-            s.result.to_sql.should match /#{quote_table_name("children_people")}.#{quote_column_name("name")} = 'Aric Smith'/
+            s = Person.search(children_reversed_name_eq: 'htimS cirA')
+            s.result.to_sql.should match(
+              /#{quote_table_name("children_people")}.#{quote_column_name("name")} = 'Aric Smith'/
+            )
           end
 
           it 'allows an "attribute" to be an InfixOperation' do
-            s = Person.search(:doubled_name_eq => 'Aric SmithAric Smith')
-            s.result.first.should eq Person.find_by_name('Aric Smith')
+            s = Person.search(doubled_name_eq: 'Aric SmithAric Smith')
+            if ::ActiveRecord::VERSION::STRING >= "4"
+              s.result.first.should eq Person.find_by(name: 'Aric Smith')
+            else
+              s.result.first.should eq Person.find_by_name('Aric Smith')
+            end
           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.search(doubled_name_eq: 'Aric SmithAric Smith')
             s.result.count.should eq 1
           end if defined?(Arel::Nodes::InfixOperation) && sane_adapter?
 
+          if ::ActiveRecord::VERSION::STRING >= "4"
+            it "should remove empty key value pairs from the params hash" do
+              s = Person.search(children_reversed_name_eq: '')
+              s.result.to_sql.should_not 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.result.to_sql.should match /LEFT OUTER JOIN/
+            end
+
+            it "should function correctly when nil is passed in" do
+              s = Person.search(nil)
+            end
+          end
+
           it "should function correctly when using fields with dots in them" do
             s = Person.search(email_cont: "example.com")
             s.result.exists?.should be_true
@@ -75,22 +102,122 @@ module Ransack
             s = Person.search(name_cont: "\\WINNER\\")
             s.result.exists?.should be_true
           end
+
+          it 'allows sort by "only_sort" field' do
+            s = Person.search(
+              "s" => { "0" => { "dir" => "asc", "name" => "only_sort" } }
+            )
+            s.result.to_sql.should match(
+              /ORDER BY #{quote_table_name("people")}.#{quote_column_name("only_sort")} ASC/
+            )
+          end
+
+          it "doesn't sort by 'only_search' field" do
+            s = Person.search(
+              "s" => { "0" => { "dir" => "asc", "name" => "only_search" } }
+            )
+            s.result.to_sql.should_not 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')
+            s.result.to_sql.should match(
+              /WHERE #{quote_table_name("people")}.#{quote_column_name("only_search")} = 'htimS cirA'/
+            )
+          end
+
+          it "can't be searched by 'only_sort'" do
+            s = Person.search(only_sort_eq: 'htimS cirA')
+            s.result.to_sql.should_not match(
+              /WHERE #{quote_table_name("people")}.#{quote_column_name("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 }
+            )
+            s.result.to_sql.should match(
+              /ORDER BY #{quote_table_name("people")}.#{quote_column_name("only_admin")} ASC/
+            )
+          end
+
+          it "doesn't sort by 'only_admin' field, if auth_object: nil" do
+            s = Person.search(
+              "s" => { "0" => { "dir" => "asc", "name" => "only_admin" } }
+            )
+            s.result.to_sql.should_not match(
+              /ORDER BY #{quote_table_name("people")}.#{quote_column_name("only_admin")} ASC/
+            )
+          end
+
+          it 'allows search by "only_admin" field, if auth_object: :admin' do
+            s = Person.search(
+              { only_admin_eq: 'htimS cirA' },
+              { auth_object: :admin }
+            )
+            s.result.to_sql.should match(
+              /WHERE #{quote_table_name("people")}.#{quote_column_name("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')
+            s.result.to_sql.should_not match(
+              /WHERE #{quote_table_name("people")}.#{quote_column_name("only_admin")} = 'htimS cirA'/
+            )
+          end
         end
 
         describe '#ransackable_attributes' do
-          subject { Person.ransackable_attributes }
+          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 '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
-          subject { Person.ransortable_attributes }
+          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
 
-          it { should include 'name' }
-          it { should include 'reversed_name' }
-          it { should include 'doubled_name' }
+          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
@@ -104,4 +231,4 @@ module Ransack
       end
     end
   end
-end
+end

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

@@ -14,16 +14,16 @@ module Ransack
 
         describe '#evaluate' do
           it 'evaluates search objects' do
-            search = Search.new(Person, :name_eq => 'Joe Blow')
+            search = Search.new(Person, name_eq: 'Joe Blow')
             result = subject.evaluate(search)
 
             result.should be_an ::ActiveRecord::Relation
             result.to_sql.should match /#{quote_column_name("name")} = 'Joe Blow'/
           end
 
-          it 'SELECTs DISTINCT when :distinct => true' do
-            search = Search.new(Person, :name_eq => 'Joe Blow')
-            result = subject.evaluate(search, :distinct => true)
+          it 'SELECTs DISTINCT when distinct: true' do
+            search = Search.new(Person, name_eq: 'Joe Blow')
+            result = subject.evaluate(search, distinct: true)
 
             result.should be_an ::ActiveRecord::Relation
             result.to_sql.should match /SELECT DISTINCT/
@@ -48,4 +48,4 @@ module Ransack
       end
     end
   end
-end
+end

data/spec/ransack/configuration_spec.rb

@@ -18,14 +18,19 @@ module Ransack
       Ransack.predicates.should have_key 'test_predicate_all'
     end
 
-    it 'avoids creating compound predicates if :compounds => false' do
+    it 'avoids creating compound predicates if compounds: false' do
       Ransack.configure do |config|
-        config.add_predicate :test_predicate_without_compound, :compounds => false
+        config.add_predicate(
+          :test_predicate_without_compound,
+          compounds: false
+          )
       end
-
-      Ransack.predicates.should have_key 'test_predicate_without_compound'
-      Ransack.predicates.should_not have_key 'test_predicate_without_compound_any'
-      Ransack.predicates.should_not have_key 'test_predicate_without_compound_all'
+      Ransack.predicates
+      .should have_key 'test_predicate_without_compound'
+      Ransack.predicates
+      .should_not have_key 'test_predicate_without_compound_any'
+      Ransack.predicates
+      .should_not have_key 'test_predicate_without_compound_all'
     end
 
     it 'should have default value for search key' do
@@ -48,7 +53,11 @@ module Ransack
 
     it 'adds predicates that take arrays, overriding compounds' do
       Ransack.configure do |config|
-        config.add_predicate :test_array_predicate, :wants_array => true, :compounds => true
+        config.add_predicate(
+          :test_array_predicate,
+          wants_array: true,
+          compounds: true
+          )
       end
 
       Ransack.predicates['test_array_predicate'].wants_array.should eq true
@@ -56,4 +65,4 @@ module Ransack
       Ransack.predicates.should_not have_key 'test_array_predicate_all'
     end
   end
-end
+end

data/spec/ransack/dependencies_spec.rb

@@ -0,0 +1,8 @@
+unless ::ActiveRecord::VERSION::STRING >= "4"
+  describe 'Ransack' do
+    it 'can be required without errors' do
+      output = `bundle exec ruby -e "require 'ransack'" 2>&1`
+      output.should be_empty
+    end
+  end
+end

data/spec/ransack/helpers/form_builder_spec.rb

@@ -7,6 +7,7 @@ module Ransack
       router = ActionDispatch::Routing::RouteSet.new
       router.draw do
         resources :people
+        resources :notes
         get ':controller(/:action(/:id(.:format)))'
       end
 
@@ -32,7 +33,11 @@ module Ransack
 
       it 'selects previously-entered time values with datetime_select' do
         @s.created_at_eq = [2011, 1, 2, 3, 4, 5]
-        html = @f.datetime_select :created_at_eq, :use_month_numbers => true, :include_seconds => true
+        html = @f.datetime_select(
+          :created_at_eq,
+          use_month_numbers: true,
+          include_seconds: true
+          )
         %w(2011 1 2 03 04 05).each do |val|
           html.should match /<option selected="selected" value="#{val}">#{val}<\/option>/
         end
@@ -49,7 +54,7 @@ module Ransack
 
       describe '#sort_link' do
         it 'sort_link for ransack attribute' do
-          sort_link = @f.sort_link :name, :controller => 'people'
+          sort_link = @f.sort_link :name, controller: 'people'
           if ActiveRecord::VERSION::STRING =~ /^3\.[1-2]\./ 
             sort_link.should match /people\?q%5Bs%5D=name\+asc/
           else
@@ -60,7 +65,7 @@ module Ransack
         end
 
         it 'sort_link for common attribute' do
-          sort_link = @f.sort_link :id, :controller => 'people'
+          sort_link = @f.sort_link :id, controller: 'people'
           sort_link.should match /id<\/a>/
         end
       end
@@ -78,15 +83,17 @@ module Ransack
 
         it 'returns ransackable attributes' do
           html = @f.attribute_select
-          html.split(/\n/).should have(Person.ransackable_attributes.size + 1).lines
+          html.split(/\n/).
+            should have(Person.ransackable_attributes.size + 1).lines
           Person.ransackable_attributes.each do |attribute|
             html.should match /<option value="#{attribute}">/
           end
         end
 
         it 'returns ransackable attributes for associations with :associations' do
-          attributes = Person.ransackable_attributes + Article.ransackable_attributes.map {|a| "articles_#{a}"}
-          html = @f.attribute_select :associations => ['articles']
+          attributes = Person.ransackable_attributes + Article.
+            ransackable_attributes.map { |a| "articles_#{a}" }
+          html = @f.attribute_select(associations: ['articles'])
           html.split(/\n/).should have(attributes.size).lines
           attributes.each do |attribute|
             html.should match /<option value="#{attribute}">/
@@ -94,7 +101,7 @@ module Ransack
         end
 
         it 'returns option groups for base and associations with :associations' do
-          html = @f.attribute_select :associations => ['articles']
+          html = @f.attribute_select(associations: ['articles'])
           [Person, Article].each do |model|
             html.should match /<optgroup label="#{model}">/
           end
@@ -112,26 +119,42 @@ module Ransack
         end
 
         it 'filters predicates with single-value :only' do
-          html = @f.predicate_select :only => 'eq'
-          Predicate.names.reject {|k| k =~ /^eq/}.each do |key|
+          html = @f.predicate_select only: 'eq'
+          Predicate.names.reject { |k| k =~ /^eq/ }.each do |key|
             html.should_not match /<option value="#{key}">/
           end
         end
 
         it 'filters predicates with multi-value :only' do
-          html = @f.predicate_select :only => [:eq, :lt]
-          Predicate.names.reject {|k| k =~ /^(eq|lt)/}.each do |key|
+          html = @f.predicate_select only: [:eq, :lt]
+          Predicate.names.reject { |k| k =~ /^(eq|lt)/ }.each do |key|
             html.should_not match /<option value="#{key}">/
           end
         end
 
-        it 'excludes compounds when :compounds => false' do
-          html = @f.predicate_select :compounds => false
-          Predicate.names.select {|k| k =~ /_(any|all)$/}.each do |key|
+        it 'excludes compounds when compounds: false' do
+          html = @f.predicate_select compounds: false
+          Predicate.names.select { |k| k =~ /_(any|all)$/ }.each do |key|
             html.should_not match /<option value="#{key}">/
           end
         end
       end
+
+      context 'fields used in polymorphic relations as search attributes in form' do
+        before do
+          @controller.view_context.search_form_for Note.search do |f|
+            @f = f
+          end
+        end
+        it 'accepts poly_id field' do
+          html = @f.text_field(:notable_id_eq)
+          html.should match /id=\"q_notable_id_eq\"/
+        end
+        it 'accepts poly_type field' do
+          html = @f.text_field(:notable_type_eq)
+          html.should match /id=\"q_notable_type_eq\"/
+        end
+      end
     end
   end
 end