squeel 0.5.0

data/spec/squeel/contexts/join_dependency_context_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module Squeel
+  module Contexts
+    describe JoinDependencyContext do
+      before do
+        @jd = ActiveRecord::Associations::JoinDependency.
+             new(Person, {
+               :children => {
+                 :children => {
+                   :parent => :parent
+                 }
+               }
+             }, [])
+        @c = JoinDependencyContext.new(@jd)
+      end
+
+      it 'finds associations' do
+        last_association = @jd.join_parts.last
+        next_to_last_association = @jd.join_parts[-2]
+
+        @c.find(:parent, next_to_last_association).should eq last_association
+      end
+
+      it 'contextualizes join parts with the proper alias' do
+        table = @c.contextualize @jd.join_parts.last
+        table.table_alias.should eq 'parents_people_2'
+      end
+
+      it 'contextualizes symbols as a generic table' do
+        table = @c.contextualize :table
+        table.name.should eq 'table'
+        table.table_alias.should be_nil
+      end
+
+      it 'contextualizes non-JoinPart/Symbols to the default join base table' do
+        table = @c.contextualize nil
+        table.name.should eq 'people'
+        table.table_alias.should be_nil
+      end
+    end
+  end
+end

data/spec/squeel/dsl_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module Squeel
+  describe DSL do
+
+    it 'evaluates code' do
+      result = DSL.evaluate { {id => 1} }
+      result.should be_a Hash
+      result.keys.first.should be_a Nodes::Stub
+    end
+
+    it 'creates function nodes when a method has arguments' do
+      result = DSL.evaluate { max(id) }
+      result.should be_a Nodes::Function
+      result.args.should eq [Nodes::Stub.new(:id)]
+    end
+
+    it 'creates polymorphic join nodes when a method has a single class argument' do
+      result = DSL.evaluate { association(Person) }
+      result.should be_a Nodes::Join
+      result.klass.should eq Person
+    end
+
+    it 'handles OR between predicates' do
+      result = DSL.evaluate {(name =~ 'Joe%') | (articles.title =~ 'Hello%')}
+      result.should be_a Nodes::Or
+      result.left.should be_a Nodes::Predicate
+      result.right.should be_a Nodes::KeyPath
+      result.right.endpoint.should be_a Nodes::Predicate
+    end
+
+    it 'is not a full closure (instance_evals) when the block supplied has no arity' do
+      my_class = Class.new do
+        def a_method
+          'test'
+        end
+
+        def dsl_test
+          DSL.evaluate {name =~ a_method}
+        end
+      end
+
+      obj = my_class.new
+      result = obj.dsl_test
+      result.should be_a Nodes::Predicate
+      result.expr.should eq :name
+      result.method_name.should eq :matches
+      result.value.should be_a Nodes::Stub
+      result.value.symbol.should eq :a_method
+    end
+
+    it 'is a full closure (yields self) when the block supplied has an arity' do
+      my_class = Class.new do
+        def a_method
+          'test'
+        end
+
+        def dsl_test
+          DSL.evaluate {|q| q.name =~ a_method}
+        end
+      end
+
+      obj = my_class.new
+      result = obj.dsl_test
+      result.should be_a Nodes::Predicate
+      result.expr.should eq :name
+      result.method_name.should eq :matches
+      result.value.should be_a String
+      result.value.should eq 'test'
+    end
+
+  end
+end

data/spec/squeel/nodes/function_spec.rb

@@ -0,0 +1,149 @@
+module Squeel
+  module Nodes
+    describe Function do
+      before do
+        @f = :function.func(1,2,3)
+      end
+
+      Squeel::Constants::PREDICATES.each do |method_name|
+        it "creates #{method_name} predicates with no value" do
+          predicate = @f.send(method_name)
+          predicate.expr.should eq @f
+          predicate.method_name.should eq method_name
+          predicate.value?.should be_false
+        end
+
+        it "creates #{method_name} predicates with a value" do
+          predicate = @f.send(method_name, 'value')
+          predicate.expr.should eq @f
+          predicate.method_name.should eq method_name
+          predicate.value.should eq 'value'
+        end
+      end
+
+      Squeel::Constants::PREDICATE_ALIASES.each do |method_name, aliases|
+        aliases.each do |aliaz|
+          ['', '_any', '_all'].each do |suffix|
+            it "creates #{method_name.to_s + suffix} predicates with no value using the alias #{aliaz.to_s + suffix}" do
+              predicate = @f.send(aliaz.to_s + suffix)
+              predicate.expr.should eq @f
+              predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
+              predicate.value?.should be_false
+            end
+
+            it "creates #{method_name.to_s + suffix} predicates with a value using the alias #{aliaz.to_s + suffix}" do
+              predicate = @f.send((aliaz.to_s + suffix), 'value')
+              predicate.expr.should eq @f
+              predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
+              predicate.value.should eq 'value'
+            end
+          end
+        end
+      end
+
+      it 'creates ascending Order nodes with #asc' do
+        order = @f.asc
+        order.expr.should eq @f
+        order.should be_ascending
+      end
+
+      it 'creates descending Order nodes with #desc' do
+        order = @f.desc
+        order.expr.should eq @f
+        order.should be_descending
+      end
+
+      it 'creates eq predicates with ==' do
+        predicate = @f == 1
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :eq
+        predicate.value.should eq 1
+      end
+
+      it 'creates not_eq predicates with ^' do
+        predicate = @f ^ 1
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :not_eq
+        predicate.value.should eq 1
+      end
+
+      it 'creates not_eq predicates with !=' do
+        predicate = @f != 1
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :not_eq
+        predicate.value.should eq 1
+      end if respond_to?('!=')
+
+      it 'creates in predicates with >>' do
+        predicate = @f >> [1,2,3]
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :in
+        predicate.value.should eq [1,2,3]
+      end
+
+      it 'creates not_in predicates with <<' do
+        predicate = @f << [1,2,3]
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :not_in
+        predicate.value.should eq [1,2,3]
+      end
+
+      it 'creates matches predicates with =~' do
+        predicate = @f =~ '%bob%'
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :matches
+        predicate.value.should eq '%bob%'
+      end
+
+      it 'creates does_not_match predicates with !~' do
+        predicate = @f !~ '%bob%'
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :does_not_match
+        predicate.value.should eq '%bob%'
+      end if respond_to?('!~')
+
+      it 'creates gt predicates with >' do
+        predicate = @f > 1
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :gt
+        predicate.value.should eq 1
+      end
+
+      it 'creates gteq predicates with >=' do
+        predicate = @f >= 1
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :gteq
+        predicate.value.should eq 1
+      end
+
+      it 'creates lt predicates with <' do
+        predicate = @f < 1
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :lt
+        predicate.value.should eq 1
+      end
+
+      it 'creates lteq predicates with <=' do
+        predicate = @f <= 1
+        predicate.expr.should eq @f
+        predicate.method_name.should eq :lteq
+        predicate.value.should eq 1
+      end
+
+      describe '#as' do
+
+        it 'aliases the function' do
+          @f.as('the_alias')
+          @f.alias.should eq 'the_alias'
+        end
+
+        it 'casts the alias to a string' do
+          @f.as(:the_alias)
+          @f.alias.should eq 'the_alias'
+        end
+
+      end
+
+    end
+  end
+end

data/spec/squeel/nodes/join_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Squeel
+  module Nodes
+    describe Join do
+
+      it 'defaults to Arel::InnerJoin' do
+        @j = Join.new :name
+        @j.type.should eq Arel::InnerJoin
+      end
+
+      it 'allows setting join type' do
+        @j = Join.new :name
+        @j.outer
+        @j.type.should eq Arel::OuterJoin
+      end
+
+      it 'allows setting polymorphic class' do
+        @j = Join.new :name
+        @j.klass = Person
+        @j.should be_polymorphic
+        @j.klass.should eq Person
+      end
+
+    end
+  end
+end

data/spec/squeel/nodes/key_path_spec.rb

@@ -0,0 +1,92 @@
+module Squeel
+  module Nodes
+    describe KeyPath do
+      before do
+        @k = KeyPath.new(:first, :second)
+      end
+
+      it 'appends to its path when endpoint is a Stub' do
+        @k.third.fourth.fifth
+        @k.path.should eq [:first, :second, :third, :fourth]
+        @k.endpoint.should eq Stub.new(:fifth)
+      end
+
+      it 'becomes absolute when prefixed with ~' do
+        ~@k.third.fourth.fifth
+        @k.path.should eq [:first, :second, :third, :fourth]
+        @k.endpoint.should eq Stub.new(:fifth)
+        @k.should be_absolute
+      end
+
+      it 'stops appending once its endpoint is not a Stub' do
+        @k.third.fourth.fifth == 'cinco'
+        @k.endpoint.should eq Predicate.new(:fifth, :eq, 'cinco')
+        expect { @k.another }.to raise_error NoMethodError
+      end
+
+      it 'sends missing calls to its endpoint if the endpoint responds to them' do
+        @k.third.fourth.fifth.matches('Joe%')
+        @k.endpoint.should be_a Predicate
+        @k.endpoint.expr.should eq :fifth
+        @k.endpoint.method_name.should eq :matches
+        @k.endpoint.value.should eq 'Joe%'
+      end
+
+      it 'creates a polymorphic join at its endpoint' do
+        @k.third.fourth.fifth(Person)
+        @k.endpoint.should be_a Join
+        @k.endpoint.should be_polymorphic
+      end
+
+      it 'creates a named function at its endpoint' do
+        @k.third.fourth.fifth.max(1,2,3)
+        @k.endpoint.should be_a Function
+        @k.endpoint.name.should eq :max
+        @k.endpoint.args.should eq [1,2,3]
+      end
+
+      it 'creates AND nodes with & if the endpoint responds to &' do
+        node = @k.third.fourth.eq('Bob') & Stub.new(:attr).eq('Joe')
+        node.should be_a And
+        node.children.should eq [@k, Stub.new(:attr).eq('Joe')]
+      end
+
+      it 'raises NoMethodError with & if the endpoint does not respond to &' do
+        expect {@k.third.fourth & Stub.new(:attr).eq('Joe')}.to raise_error NoMethodError
+      end
+
+      it 'creates Or nodes with | if the endpoint responds to |' do
+        node = @k.third.fourth.eq('Bob') | Stub.new(:attr).eq('Joe')
+        node.should be_a Or
+        node.left.should eq @k
+        node.right.should eq Stub.new(:attr).eq('Joe')
+      end
+
+      it 'raises NoMethodError with | if the endpoint does not respond to |' do
+        expect {@k.third.fourth | Stub.new(:attr).eq('Joe')}.to raise_error NoMethodError
+      end
+
+      it 'creates Operation nodes with - if the endpoint responds to -' do
+        node = @k.third.fourth - 4
+        node.should be_an Operation
+        node.left.should eq @k
+        node.right.should eq 4
+      end
+
+      it 'raises NoMethodError with - if the endpoint does not respond to -' do
+        expect {@k.third.fourth(Person) - Stub.new(:attr).eq('Joe')}.to raise_error NoMethodError
+      end
+
+      it 'creates NOT nodes with -@ if the endpoint responds to -@' do
+        node = - @k.third.fourth.eq('Bob')
+        node.should be_a Not
+        node.expr.should eq @k
+      end
+
+      it 'raises NoMethodError with -@ if the endpoint does not respond to -@' do
+        expect {-@k.third.fourth}.to raise_error NoMethodError
+      end
+
+    end
+  end
+end

data/spec/squeel/nodes/operation_spec.rb

@@ -0,0 +1,149 @@
+module Squeel
+  module Nodes
+    describe Operation do
+      before do
+        @o = dsl{name + 1}
+      end
+
+      Squeel::Constants::PREDICATES.each do |method_name|
+        it "creates #{method_name} predicates with no value" do
+          predicate = @o.send(method_name)
+          predicate.expr.should eq @o
+          predicate.method_name.should eq method_name
+          predicate.value?.should be_false
+        end
+
+        it "creates #{method_name} predicates with a value" do
+          predicate = @o.send(method_name, 'value')
+          predicate.expr.should eq @o
+          predicate.method_name.should eq method_name
+          predicate.value.should eq 'value'
+        end
+      end
+
+      Squeel::Constants::PREDICATE_ALIASES.each do |method_name, aliases|
+        aliases.each do |aliaz|
+          ['', '_any', '_all'].each do |suffix|
+            it "creates #{method_name.to_s + suffix} predicates with no value using the alias #{aliaz.to_s + suffix}" do
+              predicate = @o.send(aliaz.to_s + suffix)
+              predicate.expr.should eq @o
+              predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
+              predicate.value?.should be_false
+            end
+
+            it "creates #{method_name.to_s + suffix} predicates with a value using the alias #{aliaz.to_s + suffix}" do
+              predicate = @o.send((aliaz.to_s + suffix), 'value')
+              predicate.expr.should eq @o
+              predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
+              predicate.value.should eq 'value'
+            end
+          end
+        end
+      end
+
+      it 'creates ascending Order nodes with #asc' do
+        order = @o.asc
+        order.expr.should eq @o
+        order.should be_ascending
+      end
+
+      it 'creates descending Order nodes with #desc' do
+        order = @o.desc
+        order.expr.should eq @o
+        order.should be_descending
+      end
+
+      it 'creates eq predicates with ==' do
+        predicate = @o == 1
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :eq
+        predicate.value.should eq 1
+      end
+
+      it 'creates not_eq predicates with ^' do
+        predicate = @o ^ 1
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :not_eq
+        predicate.value.should eq 1
+      end
+
+      it 'creates not_eq predicates with !=' do
+        predicate = @o != 1
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :not_eq
+        predicate.value.should eq 1
+      end if respond_to?('!=')
+
+      it 'creates in predicates with >>' do
+        predicate = @o >> [1,2,3]
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :in
+        predicate.value.should eq [1,2,3]
+      end
+
+      it 'creates not_in predicates with <<' do
+        predicate = @o << [1,2,3]
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :not_in
+        predicate.value.should eq [1,2,3]
+      end
+
+      it 'creates matches predicates with =~' do
+        predicate = @o =~ '%bob%'
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :matches
+        predicate.value.should eq '%bob%'
+      end
+
+      it 'creates does_not_match predicates with !~' do
+        predicate = @o !~ '%bob%'
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :does_not_match
+        predicate.value.should eq '%bob%'
+      end if respond_to?('!~')
+
+      it 'creates gt predicates with >' do
+        predicate = @o > 1
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :gt
+        predicate.value.should eq 1
+      end
+
+      it 'creates gteq predicates with >=' do
+        predicate = @o >= 1
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :gteq
+        predicate.value.should eq 1
+      end
+
+      it 'creates lt predicates with <' do
+        predicate = @o < 1
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :lt
+        predicate.value.should eq 1
+      end
+
+      it 'creates lteq predicates with <=' do
+        predicate = @o <= 1
+        predicate.expr.should eq @o
+        predicate.method_name.should eq :lteq
+        predicate.value.should eq 1
+      end
+
+      describe '#as' do
+
+        it 'aliases the function' do
+          @o.as('the_alias')
+          @o.alias.should eq 'the_alias'
+        end
+
+        it 'casts the alias to a string' do
+          @o.as(:the_alias)
+          @o.alias.should eq 'the_alias'
+        end
+
+      end
+
+    end
+  end
+end