squeel_rbg 0.8.2

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,50 @@
+require 'spec_helper'
+
+module Squeel
+  module Nodes
+    describe Predicate do
+
+      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,198 @@
+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
+
+      it 'creates a KeyPath when sent an unknown method' do
+        keypath = @s.another
+        keypath.should be_a KeyPath
+        keypath.path_with_endpoint.should eq [@s, Stub.new(:another)]
+      end
+
+      it 'creates a KeyPath with a join endpoint when sent a method with a Class param' do
+        keypath = @s.another(Person)
+        keypath.should be_a KeyPath
+        keypath.path_with_endpoint.should eq [@s, Join.new(:another, Arel::InnerJoin, Person)]
+      end
+
+      it 'creates an absolute keypath with just an endpoint with ~' do
+        node = ~@s
+        node.should be_a KeyPath
+        node.path.should eq []
+        node.endpoint.should eq @s
+      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 as nodes with #as' do
+        as = @s.as('other_name')
+        as.should be_a Squeel::Nodes::As
+        as.left.should eq @s
+        as.right.should eq 'other_name'
+      end
+
+    end
+  end
+end

data/spec/squeel/visitors/attribute_visitor_spec.rb

@@ -0,0 +1,142 @@
+module Squeel
+  module Visitors
+    describe AttributeVisitor do
+
+      before do
+        @jd = new_join_dependency(Person, {
+               :children => {
+                 :children => {
+                   :parent => :parent
+                 }
+               }
+             }, [])
+        @c = Squeel::Adapters::ActiveRecord::Context.new(@jd)
+        @v = AttributeVisitor.new(@c)
+      end
+
+      it 'creates a bare ARel attribute given a symbol with no asc/desc' do
+        attribute = @v.accept(:name)
+        attribute.should be_a Arel::Attribute
+        attribute.name.should eq :name
+        attribute.relation.name.should eq 'people'
+      end
+
+      it 'creates the ordering against the proper table for nested hashes' do
+        orders = @v.accept({
+          :children => {
+            :children => {
+              :parent => {
+                :parent => :name.asc
+              }
+            }
+          }
+        })
+        orders.should be_a Array
+        ordering = orders.first
+        ordering.should be_a Arel::Nodes::Ordering
+        ordering.expr.relation.table_alias.should eq 'parents_people_2'
+        ordering.direction.should eq :asc
+      end
+
+      it 'does not alter values it is unable to accept' do
+        orders = @v.accept(['THIS PARAMETER', 'WHAT DOES IT MEAN???'])
+        orders.should eq ['THIS PARAMETER', 'WHAT DOES IT MEAN???']
+      end
+
+      it 'treats keypath keys like nested hashes' do
+        ordering = @v.accept(Nodes::Stub.new(:children).children.parent.parent.name.asc)
+        ordering.should be_a Arel::Nodes::Ordering
+        ordering.expr.relation.table_alias.should eq 'parents_people_2'
+        ordering.direction.should eq :asc
+      end
+
+      it 'honors absolute keypaths' do
+        orders = @v.accept(dsl{{children => {children => ~children.children.name.asc}}})
+        orders.should be_a Array
+        ordering = orders.first
+        ordering.expr.relation.table_alias.should eq 'children_people_2'
+        ordering.direction.should eq :asc
+      end
+
+      it 'allows hashes with keypath keys' do
+        orders = @v.accept(Nodes::Stub.new(:children).children.parent.parent => :name.asc)
+        orders.should be_a Array
+        ordering = orders.first
+        ordering.should be_a Arel::Nodes::Ordering
+        ordering.expr.relation.table_alias.should eq 'parents_people_2'
+        ordering.direction.should eq :asc
+      end
+
+      it 'creates an ARel NamedFunction node for a Function node' do
+        function = @v.accept(:find_in_set.func())
+        function.should be_a Arel::Nodes::NamedFunction
+      end
+
+      it 'maps symbols in Function args to ARel attributes' do
+        function = @v.accept(:find_in_set.func(:id, '1,2,3'))
+        function.to_sql.should match /find_in_set\("people"."id", '1,2,3'\)/
+      end
+
+      it 'accepts Order with Function expression' do
+        function = @v.accept(dsl{find_in_set(children.children.id, '1,2,3').desc})
+        function.to_sql.should match /find_in_set\("children_people_2"."id", '1,2,3'\) DESC/
+      end
+
+      it 'accepts keypaths as function args' do
+        function = @v.accept(dsl{find_in_set(children.children.id, '1,2,3')})
+        function.to_sql.should match /find_in_set\("children_people_2"."id", '1,2,3'\)/
+      end
+
+      it 'sets the alias on the ARel NamedFunction from the Function alias' do
+        function = @v.accept(:find_in_set.func(:id, '1,2,3').as('newname'))
+        function.to_sql.should match /newname/
+      end
+
+      it 'accepts As nodes containing symbols' do
+        as = @v.accept(:name.as('other_name'))
+        as.to_sql.should match /"people"."name" AS other_name/
+      end
+
+      it 'accepts As nodes containing stubs' do
+        as = @v.accept(dsl{name.as(other_name)})
+        as.to_sql.should match /"people"."name" AS other_name/
+      end
+
+      it 'accepts As nodes containing keypaths' do
+        as = @v.accept(dsl{children.name.as(other_name)})
+        as.to_sql.should match /"children_people"."name" AS other_name/
+      end
+
+      it 'creates an ARel Addition node for an Operation node with + as operator' do
+        operation = @v.accept(dsl{id + 1})
+        operation.should be_a Arel::Nodes::Addition
+      end
+
+      it 'creates an ARel Subtraction node for an Operation node with - as operator' do
+        operation = @v.accept(dsl{id - 1})
+        operation.should be_a Arel::Nodes::Subtraction
+      end
+
+      it 'creates an ARel Multiplication node for an Operation node with * as operator' do
+        operation = @v.accept(dsl{id * 1})
+        operation.should be_a Arel::Nodes::Multiplication
+      end
+
+      it 'creates an ARel Division node for an Operation node with / as operator' do
+        operation = @v.accept(dsl{id / 1})
+        operation.should be_a Arel::Nodes::Division
+      end
+
+      it 'sets the alias on an InfixOperation from the Operation alias' do
+        operation = @v.accept(dsl{(id + 1).as(:incremented_id)})
+        operation.to_sql.should match /incremented_id/
+      end
+
+      it 'accepts Order with Operation expression' do
+        operation = @v.accept(dsl{(id / 1).desc})
+        operation.to_sql.should match /"people"."id" \/ 1 DESC/
+      end
+
+    end
+  end
+end