squeel_rbg 0.8.2

data/spec/squeel/dsl_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module Squeel
+  describe DSL do
+
+    it 'evaluates code' do
+      result = DSL.eval { {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.eval { 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.eval { association(Person) }
+      result.should be_a Nodes::Join
+      result._klass.should eq Person
+    end
+
+    it 'handles OR between predicates' do
+      result = DSL.eval {(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.eval {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.eval {|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
+
+    describe '#my' do
+      it 'allows access to caller instance variables' do
+        @test_var = "test"
+        result = DSL.eval{my{@test_var}}
+        result.should be_a String
+        result.should eq @test_var
+      end
+
+      it 'allows access to caller methods' do
+        def test_scoped_method
+          :name
+        end
+
+        result = DSL.eval{my{test_scoped_method}}
+        result.should be_a Symbol
+        result.should eq :name
+      end
+    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,47 @@
+require 'spec_helper'
+
+module Squeel
+  module Nodes
+    describe Join do
+
+      before do
+        @j = Join.new :name
+      end
+
+      it 'defaults to Arel::InnerJoin' do
+        @j._type.should eq Arel::InnerJoin
+      end
+
+      it 'allows setting join type' do
+        @j.outer
+        @j._type.should eq Arel::OuterJoin
+      end
+
+      it 'allows setting polymorphic class' do
+        @j._klass = Person
+        @j.should be_polymorphic
+        @j._klass.should eq Person
+      end
+
+      it 'creates a KeyPath when sent an unknown method' do
+        keypath = @j.another
+        keypath.should be_a KeyPath
+        keypath.path_with_endpoint.should eq [@j, Stub.new(:another)]
+      end
+
+      it 'creates a KeyPath with a join endpoint when sent a method with a Class param' do
+        keypath = @j.another(Person)
+        keypath.should be_a KeyPath
+        keypath.path_with_endpoint.should eq [@j, Join.new(:another, Arel::InnerJoin, Person)]
+      end
+
+      it 'creates an absolute keypath with just an endpoint with ~' do
+        node = ~@j
+        node.should be_a KeyPath
+        node.path.should eq []
+        node.endpoint.should eq @j
+      end
+
+    end
+  end
+end

data/spec/squeel/nodes/key_path_spec.rb

@@ -0,0 +1,100 @@
+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(Stub.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 as nodes with #as' do
+        @k.as('other_name')
+        as = @k.endpoint
+        as.should be_a Squeel::Nodes::As
+        as.left.should eq Stub.new(:fourth)
+        as.right.should eq 'other_name'
+      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

data/spec/squeel/nodes/operators_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module Squeel
+  module Nodes
+    describe Operators do
+
+      [:+, :-, :*, :/].each do |operator|
+        describe "#{operator}" do
+          it "creates Operations with #{operator} operator from stubs" do
+            left = Stub.new(:stubby_mcstubbenstein)
+            node = left.send(operator, 1)
+            node.should be_an Operation
+            node.left.should eq left
+            node.operator.should eq operator
+            node.right.should eq 1
+          end
+
+          it "creates Operations with #{operator} operator from key paths" do
+            left = KeyPath.new(:first, :second)
+            node = left.send(operator, 1)
+            node.should be_an Operation
+            node.left.should eq left
+            node.operator.should eq operator
+            node.right.should eq 1
+          end
+
+          it "creates Operations with #{operator} operator from functions" do
+            left = Function.new(:name, ["arg1", "arg2"])
+            node = left.send(operator, 1)
+            node.should be_an Operation
+            node.left.should eq left
+            node.operator.should eq operator
+            node.right.should eq 1
+          end
+
+          it "creates Operations with #{operator} operator from operations" do
+            left = Stub.new(:stubby_mcstubbenstein) + 1
+            node = left.send(operator, 1)
+            node.should be_an Operation
+            node.left.should eq left
+            node.operator.should eq operator
+            node.right.should eq 1
+          end
+        end
+      end
+
+      describe '#op' do
+        it "creates Operations with custom operator from stubs" do
+          left = Stub.new(:stubby_mcstubbenstein)
+          node = left.op('||', 1)
+          node.should be_an Operation
+          node.left.should eq left
+          node.operator.should eq '||'
+          node.right.should eq 1
+        end
+
+        it "creates Operations with custom operator from key paths" do
+          left = KeyPath.new(:first, :second)
+          node = left.op('||', 1)
+          node.should be_an Operation
+          node.left.should eq left
+          node.operator.should eq '||'
+          node.right.should eq 1
+        end
+
+        it "creates Operations with custom operator from functions" do
+          left = Function.new(:name, ["arg1", "arg2"])
+          node = left.op('||', 1)
+          node.should be_an Operation
+          node.left.should eq left
+          node.operator.should eq '||'
+          node.right.should eq 1
+        end
+
+        it "creates Operations with custom operator from operations" do
+          left = Stub.new(:stubby_mcstubbenstein) + 1
+          node = left.op('||', 1)
+          node.should be_an Operation
+          node.left.should eq left
+          node.operator.should eq '||'
+          node.right.should eq 1
+        end
+      end
+
+    end
+  end
+end

data/spec/squeel/nodes/order_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Squeel
+  module Nodes
+    describe Order do
+
+      it 'requires a direction of -1 or 1' do
+        expect { Order.new :attribute, 0 }.to raise_error ArgumentError
+      end
+
+      it 'defaults to ascending order' do
+        @o = Order.new :attribute
+        @o.should be_ascending
+      end
+
+      it 'allows reversal of order' do
+        @o = Order.new :attribute, 1
+        @o.reverse!
+        @o.should be_descending
+      end
+
+      it 'allows setting order' do
+        @o = Order.new :attribute
+        @o.desc
+        @o.should be_descending
+      end
+
+    end
+  end
+end