ransack_ffcrm 0.6.0

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      describe Base do
+
+        subject { ::ActiveRecord::Base }
+
+        it { should respond_to :ransack }
+        it { should respond_to :search }
+
+        describe '#search' do
+          subject { Person.search }
+
+          it { should be_a Search }
+          it 'has a Relation as its object' do
+            subject.object.should be_an ::ActiveRecord::Relation
+          end
+        end
+
+        describe '#ransacker' do
+          # 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')
+            s.result.should have(1).person
+            s.result.first.should eq Person.find_by_name('Aric Smith')
+          end
+
+          it 'can be accessed through associations' do
+            s = Person.search(:children_reversed_name_eq => 'htimS cirA')
+            s.result.to_sql.should match /"children_people"."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')
+          end if defined?(Arel::Nodes::InfixOperation)
+        end
+
+        describe '#ransackable_attributes' do
+          subject { Person.ransackable_attributes }
+
+          it { should include 'name' }
+          it { should include 'reversed_name' }
+          it { should include 'doubled_name' }
+        end
+
+        describe '#ransackable_associations' do
+          subject { Person.ransackable_associations }
+
+          it { should include 'parent' }
+          it { should include 'children' }
+          it { should include 'articles' }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      describe Context do
+        subject { Context.new(Person) }
+
+        describe '#evaluate' do
+          it 'evaluates search obects' do
+            search = Search.new(Person, :name_eq => 'Joe Blow')
+            result = subject.evaluate(search)
+
+            result.should be_an ::ActiveRecord::Relation
+            result.to_sql.should match /"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)
+
+            result.should be_an ::ActiveRecord::Relation
+            result.to_sql.should match /SELECT DISTINCT/
+          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'
+        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
+        end
+
+      end
+    end
+  end
+end

data/spec/ransack/configuration_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Ransack
+  describe Configuration do
+    it 'yields Ransack on configure' do
+      Ransack.configure do |config|
+        config.should eq Ransack
+      end
+    end
+
+    it 'adds predicates' do
+      Ransack.configure do |config|
+        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'
+    end
+
+    it 'avoids creating compound predicates if :compounds => false' do
+      Ransack.configure do |config|
+        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'
+    end
+  end
+end

data/spec/ransack/helpers/form_builder_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+module Ransack
+  module Helpers
+    describe FormBuilder do
+
+      router = ActionDispatch::Routing::RouteSet.new
+      router.draw do
+        resources :people
+        match ':controller(/:action(/:id(.:format)))'
+      end
+
+      include router.url_helpers
+
+      # FIXME: figure out a cleaner way to get this behavior
+      before do
+        @controller = ActionView::TestCase::TestController.new
+        @controller.instance_variable_set(:@_routes, router)
+        @controller.class_eval do
+          include router.url_helpers
+        end
+
+        @controller.view_context_class.class_eval do
+          include router.url_helpers
+        end
+
+        @s = Person.search
+        @controller.view_context.search_form_for @s do |f|
+          @f = f
+        end
+      end
+
+      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
+        %w(2011 1 2 03 04 05).each do |val|
+          html.should match /<option selected="selected" value="#{val}">#{val}<\/option>/
+        end
+      end
+
+      describe '#label' do
+
+        it 'localizes attribute names' do
+          html = @f.label :name_cont
+          html.should match /Full Name contains/
+        end
+
+      end
+
+      describe '#sort_link' do
+        subject { @f.sort_link :name, :controller => 'people' }
+
+        it { should match /people\?q%5Bs%5D=name\+asc/}
+        it { should match /sort_link/}
+        it { should match /Full Name<\/a>/}
+      end
+
+      describe '#submit' do
+
+        it 'localizes :search when no default value given' do
+          html = @f.submit
+          html.should match /"Search"/
+        end
+
+      end
+
+      describe '#attribute_select' do
+
+        it 'returns ransackable attributes' do
+          html = @f.attribute_select
+          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']
+          html.split(/\n/).should have(attributes.size).lines
+          attributes.each do |attribute|
+            html.should match /<option value="#{attribute}">/
+          end
+        end
+
+        it 'returns option groups for base and associations with :associations' do
+          html = @f.attribute_select :associations => ['articles']
+          [Person, Article].each do |model|
+            html.should match /<optgroup label="#{model}">/
+          end
+        end
+
+      end
+
+      describe '#predicate_select' do
+
+        it 'returns predicates with predicate_select' do
+          html = @f.predicate_select
+          Predicate.names.each do |key|
+            html.should match /<option value="#{key}">/
+          end
+        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.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.should_not match /<option value="#{key}">/
+          end
+        end
+
+        it 'sorts predicate keys based on order of :only array, with :compounds => false' do
+          ordered_keys = @f.send(:predicate_keys, :compounds => false, :only => [:cont, :blank, :eq, :unknown])
+          ordered_keys.should == %w(cont blank eq)
+        end
+
+        it 'sorts predicate keys based on order of :only array, with :compounds => true' do
+          ordered_keys = @f.send(:predicate_keys, :compounds => true, :only => [:cont, :blank, :eq, :unknown])
+          ordered_keys.should == %w(cont cont_any cont_all blank eq eq_any eq_all)
+        end
+
+        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
+    end
+  end
+end

data/spec/ransack/helpers/form_helper_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Ransack
+  module Helpers
+    describe FormHelper do
+
+      router = ActionDispatch::Routing::RouteSet.new
+      router.draw do
+        resources :people
+        match ':controller(/:action(/:id(.:format)))'
+      end
+
+      include router.url_helpers
+
+      # FIXME: figure out a cleaner way to get this behavior
+      before do
+        @controller = ActionView::TestCase::TestController.new
+        @controller.instance_variable_set(:@_routes, router)
+        @controller.class_eval do
+          include router.url_helpers
+        end
+
+        @controller.view_context_class.class_eval do
+          include router.url_helpers
+        end
+      end
+
+      describe '#sort_link' do
+        subject { @controller.view_context.sort_link(Person.search(:sorts => ['name desc']), :name, :controller => 'people') }
+
+        it { should match /people\?q%5Bs%5D=name\+asc/}
+        it { should match /sort_link desc/}
+        it { should match /Full Name ▼/}
+      end
+
+    end
+  end
+end

data/spec/ransack/nodes/condition_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Ransack
+  module Nodes
+    describe Condition do
+
+      context 'with multiple values and an _any predicate' do
+        subject { Condition.extract(Context.for(Person), 'name_eq_any', Person.first(2).map(&:name)) }
+
+        specify { subject.values.should have(2).values }
+      end
+
+    end
+  end
+end

data/spec/ransack/nodes/grouping_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Ransack
+  module Nodes
+    describe Grouping do
+      before do
+        @g = 1
+      end
+
+
+    end
+  end
+end

data/spec/ransack/predicate_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Ransack
+  describe Predicate do
+
+    before do
+      @s = Search.new(Person)
+    end
+
+    describe 'eq' do
+      it 'generates an equality condition for boolean true' do
+        @s.awesome_eq = true
+        @s.result.to_sql.should match /"people"."awesome" = 't'/
+      end
+
+      it 'generates an equality condition for boolean false' do
+        @s.awesome_eq = false
+        @s.result.to_sql.should match /"people"."awesome" = 'f'/
+      end
+
+      it 'does not generate a condition for nil' do
+        @s.awesome_eq = nil
+        @s.result.to_sql.should_not match /WHERE/
+      end
+    end
+
+    describe 'cont' do
+      it 'generates a LIKE query with value surrounded by %' do
+        @s.name_cont = 'ric'
+        @s.result.to_sql.should match /"people"."name" LIKE '%ric%'/
+      end
+    end
+
+    describe 'not_cont' do
+      it 'generates a NOT LIKE query with value surrounded by %' do
+        @s.name_not_cont = 'ric'
+        @s.result.to_sql.should match /"people"."name" NOT LIKE '%ric%'/
+      end
+    end
+
+    describe 'null' do
+      it 'generates a value IS NULL query' do
+        @s.name_null = true
+        @s.result.to_sql.should match /"people"."name" IS NULL/
+      end
+    end
+
+    describe 'not_null' do
+      it 'generates a value IS NOT NULL query' do
+        @s.name_not_null = true
+        @s.result.to_sql.should match /"people"."name" IS NOT NULL/
+      end
+    end
+  end
+end

data/spec/ransack/search_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+module Ransack
+  describe Search do
+
+    describe '#build' do
+      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'
+        condition.attributes.first.name.should eq 'name'
+        condition.value.should eq 'Ernie'
+      end
+
+      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'
+        condition.attributes.first.name.should eq 'children_name'
+        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')
+        condition = search.base[:notable_of_Person_type_name_eq]
+        condition.should be_a Nodes::Condition
+        condition.predicate.name.should eq 'eq'
+        condition.attributes.first.name.should eq 'notable_of_Person_type_name'
+        condition.value.should eq 'Ernie'
+      end
+
+      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')
+        condition = search.base[:notable_of_Person_type_name_or_notable_of_Article_type_title_eq]
+        condition.should be_a Nodes::Condition
+        condition.predicate.name.should eq 'eq'
+        condition.attributes.first.name.should eq 'notable_of_Person_type_name'
+        condition.attributes.last.name.should eq 'notable_of_Article_type_title'
+        condition.value.should eq 'Ernie'
+      end
+
+      it 'discards empty conditions' do
+        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'},
+          ]
+        )
+        ors = search.groupings
+        ors.should have(2).items
+        or1, or2 = ors
+        or1.should be_a Nodes::Grouping
+        or1.combinator.should eq 'or'
+        or2.should be_a Nodes::Grouping
+        or2.combinator.should eq 'or'
+      end
+
+      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'},
+          }
+        )
+        ors = search.groupings
+        ors.should have(2).items
+        or1, or2 = ors
+        or1.should be_a Nodes::Grouping
+        or1.combinator.should eq 'or'
+        or2.should be_a Nodes::Grouping
+        or2.combinator.should eq 'or'
+      end
+
+      it 'accepts "attributes" hashes for conditions' do
+        search = Search.new(Person,
+          :c => {
+            '0' => {:a => ['name'], :p => 'eq', :v => ['Ernie']},
+            '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]
+      end
+    end
+
+    describe '#result' do
+      it 'evaluates conditions contextually' do
+        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" = 'Ernie'/
+      end
+
+      it 'evaluates compound conditions contextually' do
+        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" = 'Ernie' OR "people"\."name" = 'Ernie'/
+      end
+
+      it 'evaluates polymorphic belongs_to association conditions contextually' do
+        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" = '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.result.should be_an ActiveRecord::Relation
+        where = search.result.where_values.first
+        where.to_sql.should match /"children_people"."name" = 'Ernie'/
+        where.to_sql.should match /"people"."name" = 'Ernie'/
+        where.to_sql.should match /"children_people_2"."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'},
+          ]
+        )
+        search.result.should be_an ActiveRecord::Relation
+        where = search.result.where_values.first
+        sql = where.to_sql
+        first, second = sql.split(/ AND /)
+        first.should match /"people"."name" = 'Ernie'/
+        first.should match /"children_people"."name" = 'Ernie'/
+        second.should match /"people"."name" = 'Bert'/
+        second.should match /"children_people"."name" = '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'}])
+        search.result.all.should have(920).items
+        search.result(:distinct => true).should have(330).items
+        search.result.all.uniq.should eq search.result(:distinct => true).all
+      end
+    end
+
+    describe '#sorts=' do
+      before do
+        @s = Search.new(Person)
+      end
+
+      it 'creates sorts based on a single attribute/direction' do
+        @s.sorts = 'id desc'
+        @s.sorts.should have(1).item
+        sort = @s.sorts.first
+        sort.should be_a Nodes::Sort
+        sort.name.should eq 'id'
+        sort.dir.should eq 'desc'
+      end
+
+      it 'creates sorts based on multiple attributes/directions in array format' do
+        @s.sorts = ['id desc', 'name asc']
+        @s.sorts.should have(2).items
+        sort1, sort2 = @s.sorts
+        sort1.should be_a Nodes::Sort
+        sort1.name.should eq 'id'
+        sort1.dir.should eq 'desc'
+        sort2.should be_a Nodes::Sort
+        sort2.name.should eq 'name'
+        sort2.dir.should eq 'asc'
+      end
+
+      it 'creates sorts based on multiple attributes/directions in hash format' do
+        @s.sorts = {
+          '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}
+        id_sort = @s.sorts.detect {|s| s.name == 'id'}
+        name_sort = @s.sorts.detect {|s| s.name == 'name'}
+        id_sort.dir.should eq 'desc'
+        name_sort.dir.should eq 'asc'
+      end
+    end
+
+    describe '#method_missing' do
+      before do
+        @s = Search.new(Person)
+      end
+
+      it 'raises NoMethodError when sent an invalid attribute' do
+        expect {@s.blah}.to raise_error NoMethodError
+      end
+
+      it 'sets condition attributes when sent valid attributes' do
+        @s.name_eq = 'Ernie'
+        @s.name_eq.should eq 'Ernie'
+      end
+
+      it 'allows chaining to access nested conditions' do
+        @s.groupings = [{:m => 'or', :name_eq => 'Ernie', :children_name_eq => 'Ernie'}]
+        @s.groupings.first.name_eq.should eq 'Ernie'
+        @s.groupings.first.children_name_eq.should eq 'Ernie'
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+require 'machinist/active_record'
+require 'sham'
+require 'faker'
+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|
+  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(' ') }
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    puts '=' * 80
+    puts "Running specs against ActiveRecord #{ActiveRecord::VERSION::STRING} and ARel #{Arel::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/support/en.yml

@@ -0,0 +1,5 @@
+en:
+  ransack:
+    attributes:
+      person:
+        name: Full Name