ransack 1.2.3 → 1.3.0

data/lib/ransack/version.rb

@@ -1,3 +1,3 @@
 module Ransack
-  VERSION = "1.2.3"
+  VERSION = "1.3.0"
 end

data/ransack.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.name        = "ransack"
   s.version     = Ransack::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Ernie Miller", "Ryan Bigg"]
-  s.email       = ["ernie@erniemiller.org", "radarlistener@gmail.com"]
+  s.authors     = ["Ernie Miller", "Ryan Bigg", "Jon Atack"]
+  s.email       = ["ernie@erniemiller.org", "radarlistener@gmail.com", "jonnyatack@gmail.com"]
   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.}
@@ -19,12 +19,12 @@ Gem::Specification.new do |s|
   s.add_dependency 'activerecord', '>= 3.0'
   s.add_dependency 'activesupport', '>= 3.0'
   s.add_dependency 'i18n'
-  s.add_dependency 'polyamorous', '~> 1.0.0'
-  s.add_development_dependency 'rspec', '~> 2.8.0'
+  s.add_dependency 'polyamorous', '~> 1.1'
+  s.add_development_dependency 'rspec', '~> 2.14.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 'pg'
   s.add_development_dependency 'mysql2', '0.3.14'
   s.add_development_dependency 'pry', '0.9.12.2'
 

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

@@ -15,8 +15,41 @@ module Ransack
 
           it { should be_a Search }
           it 'has a Relation as its object' do
-            subject.object.should be_an ::ActiveRecord::Relation
+            expect(subject.object).to be_an ::ActiveRecord::Relation
           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)
+              search.result.to_sql.should include "active = 1"
+            end
+
+            it "ignores unlisted scopes" do
+              search =  Person.search('restricted' => true)
+              search.result.to_sql.should_not include "restricted"
+            end
+
+            it "ignores false scopes" do
+              search = Person.search('active' => false)
+              search.result.to_sql.should_not include "active"
+            end
+
+            it "passes values to scopes" do
+              search = Person.search('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.result.to_sql.should include "age > 18"
+              search.result.to_sql.should include "active = 1"
+            end
+          end
+
         end
 
         describe '#ransacker' do
@@ -41,66 +74,70 @@ module Ransack
           # end
 
           it 'creates ransack attributes' do
-            s = Person.search(reversed_name_eq: 'htimS cirA')
-            s.result.should have(1).person
+            s = Person.search(:reversed_name_eq => 'htimS cirA')
+            expect(s.result.size).to eq(1)
 
-            s.result.first.should eq Person.where(name: 'Aric Smith').first
+            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.result.to_sql.should match(
+            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 'allows an "attribute" to be an InfixOperation' do
-            s = Person.search(doubled_name_eq: 'Aric SmithAric Smith')
-            s.result.first.should eq Person.where(name: 'Aric Smith').first
+            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')
-            s.result.count.should eq 1
+            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(children_reversed_name_eq: '')
-            s.result.to_sql.should_not match /LEFT OUTER JOIN/
+            s = Person.search(: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.result.to_sql.should match /LEFT OUTER JOIN/
+            s = Person.search(: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)
           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")
-            s.result.exists?.should be_true
+            s = Person.search(:email_cont => "example.com")
+            expect(s.result.exists?).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%")
-            s.result.exists?.should be_true
+            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\\")
-            s.result.exists?.should be_true
+            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
             s = Person.search(
               "s" => { "0" => { "dir" => "asc", "name" => "only_sort" } }
             )
-            s.result.to_sql.should match(
+            expect(s.result.to_sql).to match(
               /ORDER BY #{quote_table_name("people")}.#{
                 quote_column_name("only_sort")} ASC/
             )
@@ -110,23 +147,23 @@ module Ransack
             s = Person.search(
               "s" => { "0" => { "dir" => "asc", "name" => "only_search" } }
             )
-            s.result.to_sql.should_not match(
+            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')
-            s.result.to_sql.should match(
+            s = Person.search(:only_search_eq => 'htimS cirA')
+            expect(s.result.to_sql).to 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(
+            s = Person.search(: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'/
             )
@@ -137,7 +174,7 @@ module Ransack
               { "s" => { "0" => { "dir" => "asc", "name" => "only_admin" } } },
               { auth_object: :admin }
             )
-            s.result.to_sql.should match(
+            expect(s.result.to_sql).to match(
               /ORDER BY #{quote_table_name("people")}.#{
                 quote_column_name("only_admin")} ASC/
             )
@@ -147,7 +184,7 @@ module Ransack
             s = Person.search(
               "s" => { "0" => { "dir" => "asc", "name" => "only_admin" } }
             )
-            s.result.to_sql.should_not match(
+            expect(s.result.to_sql).not_to match(
               /ORDER BY #{quote_table_name("people")}.#{
                 quote_column_name("only_admin")} ASC/
             )
@@ -155,18 +192,18 @@ module Ransack
 
           it 'allows search by "only_admin" field, if auth_object: :admin' do
             s = Person.search(
-              { only_admin_eq: 'htimS cirA' },
-              { auth_object: :admin }
+              { :only_admin_eq => 'htimS cirA' },
+              { :auth_object => :admin }
             )
-            s.result.to_sql.should match(
+            expect(s.result.to_sql).to 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(
+            s = Person.search(: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'/
             )
@@ -229,6 +266,12 @@ module Ransack
           it { should include 'articles' }
         end
 
+        describe '#ransackable_scopes' do
+          subject { Person.ransackable_scopes }
+
+          it { should eq [] }
+        end
+
       end
     end
   end

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

@@ -6,43 +6,86 @@ module Ransack
       describe Context do
         subject { Context.new(Person) }
 
+        if ::ActiveRecord::VERSION::STRING >= "3.1"
+          its(:alias_tracker) { should be_a ::ActiveRecord::Associations::AliasTracker }
+        end
+
         describe '#relation_for' do
           it 'returns relation for given object' do
-            subject.object.should be_an ::ActiveRecord::Relation
+            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')
+            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'/
+            expect(result).to be_an ::ActiveRecord::Relation
+            expect(result.to_sql).to 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)
+            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
+
+        describe "sharing context across searches" do
+          let(:shared_context) { Context.for(Person) }
+
+          before do
+            Search.new(Person, {:parent_name_eq => 'A'}, context: shared_context)
+            Search.new(Person, {:children_name_eq => 'B'}, context: shared_context)
+          end
+
+          describe '#join_associations', :if => ::ActiveRecord::VERSION::STRING <= '4.0' do
+            it 'returns dependent join associations for all searches run against the context' do
+              parents, children = shared_context.join_associations
+
+              expect(children.aliased_table_name).to eq "children_people"
+              expect(parents.aliased_table_name).to eq "parents_people"
+            end
+
+            it 'can be rejoined to execute a valid query' do
+              parents, children = shared_context.join_associations
+
+              expect { Person.joins(parents).joins(children).to_a }.to_not raise_error
+            end
+          end
+
+          describe '#join_sources', :if => ::ActiveRecord::VERSION::STRING >= '3.1' do
+            it 'returns dependent arel join nodes for all searches run against the context' do
+              parents, children = shared_context.join_sources
+
+              expect(children.left.name).to eq "children_people"
+              expect(parents.left.name).to eq "parents_people"
+            end
+
+            it 'can be rejoined to execute a valid query' do
+              parents, children = shared_context.join_sources
 
-            result.should be_an ::ActiveRecord::Relation
-            result.to_sql.should match /SELECT DISTINCT/
+              expect { Person.joins(parents).joins(children).to_a }.to_not raise_error
+            end
           end
         end
 
         it 'contextualizes strings to attributes' do
           attribute = subject.contextualize 'children_children_parent_name'
-          attribute.should be_a Arel::Attributes::Attribute
-          attribute.name.to_s.should eq 'name'
-          attribute.relation.table_alias.should eq 'parents_people'
+          expect(attribute).to be_a Arel::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
           attribute = subject.contextualize 'children_articles_title'
-          attribute.should be_a Arel::Attributes::Attribute
-          attribute.name.to_s.should eq 'title'
-          attribute.relation.name.should eq 'articles'
-          attribute.relation.table_alias.should be_nil
+          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

data/spec/ransack/configuration_spec.rb

@@ -4,7 +4,7 @@ module Ransack
   describe Configuration do
     it 'yields Ransack on configure' do
       Ransack.configure do |config|
-        config.should eq Ransack
+        expect(config).to eq Ransack
       end
     end
 
@@ -13,28 +13,28 @@ module Ransack
         config.add_predicate :test_predicate
       end
 
-      Ransack.predicates.should have_key 'test_predicate'
-      Ransack.predicates.should have_key 'test_predicate_any'
-      Ransack.predicates.should have_key 'test_predicate_all'
+      expect(Ransack.predicates).to have_key 'test_predicate'
+      expect(Ransack.predicates).to have_key 'test_predicate_any'
+      expect(Ransack.predicates).to have_key 'test_predicate_all'
     end
 
     it 'avoids creating compound predicates if compounds: false' do
       Ransack.configure do |config|
         config.add_predicate(
           :test_predicate_without_compound,
-          compounds: false
+          :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'
+      expect(Ransack.predicates)
+      .to have_key 'test_predicate_without_compound'
+      expect(Ransack.predicates)
+      .not_to have_key 'test_predicate_without_compound_any'
+      expect(Ransack.predicates)
+      .not_to have_key 'test_predicate_without_compound_all'
     end
 
     it 'should have default value for search key' do
-      Ransack.options[:search_key].should eq :q
+      expect(Ransack.options[:search_key]).to eq :q
     end
 
     it 'changes default search key parameter' do
@@ -45,7 +45,7 @@ module Ransack
         config.search_key = :query
       end
 
-      Ransack.options[:search_key].should eq :query
+      expect(Ransack.options[:search_key]).to eq :query
 
       # restore original state so we don't break other tests
       Ransack.options = before
@@ -55,14 +55,14 @@ module Ransack
       Ransack.configure do |config|
         config.add_predicate(
           :test_array_predicate,
-          wants_array: true,
-          compounds: true
+          :wants_array => true,
+          :compounds => true
           )
       end
 
-      Ransack.predicates['test_array_predicate'].wants_array.should eq true
-      Ransack.predicates.should_not have_key 'test_array_predicate_any'
-      Ransack.predicates.should_not have_key 'test_array_predicate_all'
+      expect(Ransack.predicates['test_array_predicate'].wants_array).to eq true
+      expect(Ransack.predicates).not_to have_key 'test_array_predicate_any'
+      expect(Ransack.predicates).not_to have_key 'test_array_predicate_all'
     end
   end
 end

data/spec/ransack/dependencies_spec.rb

@@ -2,7 +2,7 @@ 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
+      expect(output).to be_empty
     end
   end
 end

data/spec/ransack/helpers/form_builder_spec.rb

@@ -35,11 +35,11 @@ module Ransack
         @s.created_at_eq = [2011, 1, 2, 3, 4, 5]
         html = @f.datetime_select(
           :created_at_eq,
-          use_month_numbers: true,
-          include_seconds: true
+          :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>/
+          expect(html).to match /<option selected="selected" value="#{val}">#{val}<\/option>/
         end
       end
 
@@ -47,26 +47,26 @@ module Ransack
 
         it 'localizes attribute names' do
           html = @f.label :name_cont
-          html.should match /Full Name contains/
+          expect(html).to match /Full Name contains/
         end
 
       end
 
       describe '#sort_link' do
         it 'sort_link for ransack attribute' do
-          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/
+          sort_link = @f.sort_link :name, :controller => 'people'
+          if ActiveRecord::VERSION::STRING =~ /^3\.[1-2]\./
+            expect(sort_link).to match /people\?q%5Bs%5D=name\+asc/
           else
-            sort_link.should match /people\?q(%5B|\[)s(%5D|\])=name\+asc/
+            expect(sort_link).to match /people\?q(%5B|\[)s(%5D|\])=name\+asc/
           end
-          sort_link.should match /sort_link/
-          sort_link.should match /Full Name<\/a>/
+          expect(sort_link).to match /sort_link/
+          expect(sort_link).to match /Full Name<\/a>/
         end
 
         it 'sort_link for common attribute' do
-          sort_link = @f.sort_link :id, controller: 'people'
-          sort_link.should match /id<\/a>/
+          sort_link = @f.sort_link :id, :controller => 'people'
+          expect(sort_link).to match /id<\/a>/
         end
       end
 
@@ -74,7 +74,7 @@ module Ransack
 
         it 'localizes :search when no default value given' do
           html = @f.submit
-          html.should match /"Search"/
+          expect(html).to match /"Search"/
         end
 
       end
@@ -83,27 +83,27 @@ module Ransack
 
         it 'returns ransackable attributes' do
           html = @f.attribute_select
-          html.split(/\n/).
-            should have(Person.ransackable_attributes.size + 1).lines
+          expect(html.split(/\n/).size).
+            to eq(Person.ransackable_attributes.size + 1)
           Person.ransackable_attributes.each do |attribute|
-            html.should match /<option value="#{attribute}">/
+            expect(html).to 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'])
-          html.split(/\n/).should have(attributes.size).lines
+          html = @f.attribute_select(:associations => ['articles'])
+          expect(html.split(/\n/).size).to eq(attributes.size)
           attributes.each do |attribute|
-            html.should match /<option value="#{attribute}">/
+            expect(html).to match /<option value="#{attribute}">/
           end
         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}">/
+            expect(html).to match /<optgroup label="#{model}">/
           end
         end
 
@@ -114,28 +114,28 @@ module Ransack
         it 'returns predicates with predicate_select' do
           html = @f.predicate_select
           Predicate.names.each do |key|
-            html.should match /<option value="#{key}">/
+            expect(html).to match /<option value="#{key}">/
           end
         end
 
         it 'filters predicates with single-value :only' do
-          html = @f.predicate_select only: 'eq'
+          html = @f.predicate_select :only => 'eq'
           Predicate.names.reject { |k| k =~ /^eq/ }.each do |key|
-            html.should_not match /<option value="#{key}">/
+            expect(html).not_to 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.should_not match /<option value="#{key}">/
+            expect(html).not_to match /<option value="#{key}">/
           end
         end
 
         it 'excludes compounds when compounds: false' do
-          html = @f.predicate_select compounds: false
+          html = @f.predicate_select :compounds => false
           Predicate.names.select { |k| k =~ /_(any|all)$/ }.each do |key|
-            html.should_not match /<option value="#{key}">/
+            expect(html).not_to match /<option value="#{key}">/
           end
         end
       end
@@ -148,11 +148,11 @@ module Ransack
         end
         it 'accepts poly_id field' do
           html = @f.text_field(:notable_id_eq)
-          html.should match /id=\"q_notable_id_eq\"/
+          expect(html).to 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\"/
+          expect(html).to match /id=\"q_notable_type_eq\"/
         end
       end
     end