squeel 0.5.0

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

data/spec/squeel/nodes/predicate_operators_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Squeel
+  module Nodes
+    describe PredicateOperators do
+
+      describe '&' do
+        it 'creates And nodes from hashes' do
+          left = {:name.matches => 'J%'}
+          right  = {:name.matches => '%e'}
+          n = left & right
+          n.should be_a And
+          n.children.should eq [left, right]
+        end
+
+        it 'creates And nodes from predicates' do
+          left = :name.matches % 'J%'
+          right = :name.matches % '%e'
+          n = left & right
+          n.should be_a And
+          n.children.should eq [left, right]
+        end
+
+        it 'appends nodes to children from other And nodes' do
+          left = :name.matches % 'J%' & :name.matches % '%e'
+          right = :id.gt % 0
+          expected = left.children + [right]
+          left & right
+          left.should be_a And
+          left.children.should eq expected
+        end
+      end
+
+      describe '|' do
+        it 'creates Or nodes from hashes' do
+          left = {:name.matches => 'J%'}
+          right  = {:name.matches => '%e'}
+          n = left | right
+          n.should be_a Or
+          n.left.should eq left
+          n.right.should eq right
+        end
+
+        it 'creates Or nodes from predicates' do
+          left = :name.matches % 'J%'
+          right = :name.matches % '%e'
+          n = left | right
+          n.should be_a Or
+          n.left.should eq left
+          n.right.should eq right
+        end
+
+        it 'creates Or nodes from other Or nodes' do
+          left = :name.matches % 'J%' | :name.matches % '%e'
+          right = :id.gt % 0 | :id.lt % 100
+          n = left | right
+          n.should be_a Or
+          n.left.should eq left
+          n.right.should eq right
+        end
+      end
+
+      describe '-@' do
+        it 'creates Not nodes from hashes' do
+          expr = {:name => 'Joe'}
+          n = - expr
+          n.should be_a Not
+          n.expr.should eq expr
+        end
+
+        it 'creates Not nodes from predicates' do
+          expr = :name.matches % 'J%'
+          n = - expr
+          n.should be_a Not
+          n.expr.should eq expr
+        end
+
+        it 'creates Not nodes from other Not nodes' do
+          expr = -(:name.matches % '%e')
+          n = - expr
+          n.should be_a Not
+          n.expr.should eq expr
+        end
+      end
+
+    end
+  end
+end

data/spec/squeel/nodes/predicate_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+module Squeel
+  module Nodes
+    describe Predicate do
+
+      context 'ARel predicate methods' do
+        before do
+          @p = Predicate.new(:attribute)
+        end
+
+        Squeel::Constants::PREDICATES.each do |method_name|
+          it "creates #{method_name} predicates with no value" do
+            predicate = @p.send(method_name)
+            predicate.expr.should eq :attribute
+            predicate.method_name.should eq method_name
+            predicate.value?.should be_false
+          end
+
+          it "creates #{method_name} predicates with a value" do
+            predicate = @p.send(method_name, 'value')
+            predicate.expr.should eq :attribute
+            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 = @p.send(aliaz.to_s + suffix)
+                predicate.expr.should eq :attribute
+                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 = @p.send((aliaz.to_s + suffix), 'value')
+                predicate.expr.should eq :attribute
+                predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
+                predicate.value.should eq 'value'
+              end
+            end
+          end
+        end
+      end
+
+      it 'accepts a value on instantiation' do
+        @p = Predicate.new :name, :eq, 'value'
+        @p.value.should eq 'value'
+      end
+
+      it 'sets value via accessor' do
+        @p = Predicate.new :name, :eq
+        @p.value = 'value'
+        @p.value.should eq 'value'
+      end
+
+      it 'sets value via %' do
+        @p = Predicate.new :name, :eq
+        @p % 'value'
+        @p.value.should eq 'value'
+      end
+
+      it 'can be inquired for value presence' do
+        @p = Predicate.new :name, :eq
+        @p.value?.should be_false
+        @p.value = 'value'
+        @p.value?.should be_true
+      end
+
+      it 'can be ORed with another predicate' do
+        left = Predicate.new :name, :eq, 'Joe'
+        right = Predicate.new :name, :eq, 'Bob'
+        combined = left | right
+        combined.should be_a Nodes::Or
+        combined.left.should eq left
+        combined.right.should eq right
+      end
+
+      it 'can be ANDed with another predicate' do
+        left = Predicate.new :name, :eq, 'Joe'
+        right = Predicate.new :name, :eq, 'Bob'
+        combined = left & right
+        combined.should be_a Nodes::And
+        combined.children.should eq [left, right]
+      end
+
+    end
+  end
+end

data/spec/squeel/nodes/stub_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+module Squeel
+  module Nodes
+    describe Stub do
+      before do
+        @s = Stub.new :attribute
+      end
+
+      it 'hashes like a symbol' do
+        @s.hash.should eq :attribute.hash
+      end
+
+      it 'returns its symbol when sent to_sym' do
+        @s.to_sym.should eq :attribute
+      end
+
+      it 'returns a string matching its symbol when sent to_s' do
+        @s.to_s.should eq 'attribute'
+      end
+
+      it 'merges against matching stubs' do
+        hash1 = {Stub.new(:attribute) => 1}
+        hash2 = {Stub.new(:attribute) => 2}
+        merged = hash1.merge(hash2)
+        merged.keys.should have(1).key
+        merged[Stub.new(:attribute)].should eq 2
+      end
+
+      Squeel::Constants::PREDICATES.each do |method_name|
+        it "creates #{method_name} predicates with no value" do
+          predicate = @s.send(method_name)
+          predicate.expr.should eq :attribute
+          predicate.method_name.should eq method_name
+          predicate.value?.should be_false
+        end
+
+        it "creates #{method_name} predicates with a value" do
+          predicate = @s.send(method_name, 'value')
+          predicate.expr.should eq :attribute
+          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 = @s.send(aliaz.to_s + suffix)
+              predicate.expr.should eq :attribute
+              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 = @s.send((aliaz.to_s + suffix), 'value')
+              predicate.expr.should eq :attribute
+              predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
+              predicate.value.should eq 'value'
+            end
+          end
+        end
+      end
+
+      it 'creates eq predicates with ==' do
+        predicate = @s == 1
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :eq
+        predicate.value.should eq 1
+      end
+
+      it 'creates not_eq predicates with ^' do
+        predicate = @s ^ 1
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :not_eq
+        predicate.value.should eq 1
+      end
+
+      it 'creates not_eq predicates with !=' do
+        predicate = @s != 1
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :not_eq
+        predicate.value.should eq 1
+      end if respond_to?('!=')
+
+      it 'creates in predicates with >>' do
+        predicate = @s >> [1,2,3]
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :in
+        predicate.value.should eq [1,2,3]
+      end
+
+      it 'creates not_in predicates with <<' do
+        predicate = @s << [1,2,3]
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :not_in
+        predicate.value.should eq [1,2,3]
+      end
+
+      it 'creates matches predicates with =~' do
+        predicate = @s =~ '%bob%'
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :matches
+        predicate.value.should eq '%bob%'
+      end
+
+      it 'creates does_not_match predicates with !~' do
+        predicate = @s !~ '%bob%'
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :does_not_match
+        predicate.value.should eq '%bob%'
+      end if respond_to?('!~')
+
+      it 'creates gt predicates with >' do
+        predicate = @s > 1
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :gt
+        predicate.value.should eq 1
+      end
+
+      it 'creates gteq predicates with >=' do
+        predicate = @s >= 1
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :gteq
+        predicate.value.should eq 1
+      end
+
+      it 'creates lt predicates with <' do
+        predicate = @s < 1
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :lt
+        predicate.value.should eq 1
+      end
+
+      it 'creates lteq predicates with <=' do
+        predicate = @s <= 1
+        predicate.expr.should eq :attribute
+        predicate.method_name.should eq :lteq
+        predicate.value.should eq 1
+      end
+
+      it 'creates ascending orders' do
+        order = @s.asc
+        order.should be_ascending
+      end
+
+      it 'creates descending orders' do
+        order = @s.desc
+        order.should be_descending
+      end
+
+      it 'creates inner joins' do
+        join = @s.inner
+        join.should be_a Join
+        join.type.should eq Arel::InnerJoin
+      end
+
+      it 'creates outer joins' do
+        join = @s.outer
+        join.should be_a Join
+        join.type.should eq Arel::OuterJoin
+      end
+
+      it 'creates functions with #func' do
+        function = @s.func
+        function.should be_a Function
+      end
+
+      it 'creates functions with #[]' do
+        function = @s[1, 2, 3]
+        function.should be_a Function
+        function.args.should eq [1, 2, 3]
+      end
+
+    end
+  end
+end