squeel 1.1.1 → 1.2.1

data/spec/squeel/core_ext/symbol_spec.rb

@@ -33,7 +33,7 @@ describe Symbol do
       join = :blah.inner
       join.should be_a Squeel::Nodes::Join
       join._name.should eq :blah
-      join._type.should eq Arel::InnerJoin
+      join._type.should eq Squeel::InnerJoin
     end
   end
 
@@ -42,7 +42,7 @@ describe Symbol do
       join = :blah.outer
       join.should be_a Squeel::Nodes::Join
       join._name.should eq :blah
-      join._type.should eq Arel::OuterJoin
+      join._type.should eq Squeel::OuterJoin
     end
   end
 
@@ -51,7 +51,7 @@ describe Symbol do
       join = :blah.of_class(Person)
       join.should be_a Squeel::Nodes::Join
       join._name.should eq :blah
-      join._type.should eq Arel::InnerJoin
+      join._type.should eq Squeel::InnerJoin
       join._klass.should eq Person
     end
   end

data/spec/squeel/nodes/join_spec.rb

@@ -8,13 +8,13 @@ module Squeel
         @j = Join.new :name
       end
 
-      it 'defaults to Arel::InnerJoin' do
-        @j._type.should eq Arel::InnerJoin
+      it 'defaults to Squeel::InnerJoin' do
+        @j._type.should eq Squeel::InnerJoin
       end
 
       it 'allows setting join type' do
         @j.outer
-        @j._type.should eq Arel::OuterJoin
+        @j._type.should eq Squeel::OuterJoin
       end
 
       it 'allows setting polymorphic class' do
@@ -32,7 +32,7 @@ module Squeel
       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.should eq [@j, Join.new(:another, Arel::InnerJoin, Person)]
+        keypath.path.should eq [@j, Join.new(:another, Squeel::InnerJoin, Person)]
       end
 
       it 'creates an absolute keypath with just an endpoint with ~' do

data/spec/squeel/nodes/stub_spec.rb

@@ -48,7 +48,7 @@ module Squeel
       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.should eq [@s, Join.new(:another, Arel::InnerJoin, Person)]
+        keypath.path.should eq [@s, Join.new(:another, Squeel::InnerJoin, Person)]
       end
 
       it 'creates a KeyPath with a sifter endpoint when sent #sift' do
@@ -189,13 +189,13 @@ module Squeel
       it 'creates inner joins' do
         join = @s.inner
         join.should be_a Join
-        join._type.should eq Arel::InnerJoin
+        join._type.should eq Squeel::InnerJoin
       end
 
       it 'creates outer joins' do
         join = @s.outer
         join.should be_a Join
-        join._type.should eq Arel::OuterJoin
+        join._type.should eq Squeel::OuterJoin
       end
 
       it 'creates functions with #func' do

data/spec/squeel/nodes/subquery_join_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Squeel
+  module Nodes
+    describe SubqueryJoin do
+      before(:each) do
+        @j =
+          if activerecord_version_at_least('4.1.0')
+            SubqueryJoin.new(OrderItem.all.as('items'), dsl {(items.orderable_id == id) & (items.orderable_type == 'Seat')} )
+          else
+            SubqueryJoin.new(OrderItem.scoped.as('items'), dsl {(items.orderable_id == id) & (items.orderable_type == 'Seat')} )
+          end
+      end
+
+      it 'defaults to Squeel::InnerJoin' do
+        @j.type.should eq Squeel::InnerJoin
+      end
+
+      it 'allows setting join type' do
+        @j.outer
+        @j.type.should eq Squeel::OuterJoin
+      end
+
+      it 'subquery should be a Nodes::As' do
+        @j.subquery.should be_kind_of(As)
+      end
+
+      it 'constraints should be a node' do
+        @j.constraints.should be_kind_of(Node)
+      end
+
+      it 'only convert an ActiveRecord::Relation to a SubqueryJoin' do
+        j =
+          if activerecord_version_at_least('4.1.0')
+            OrderItem.all.as('items').on{(items.orderable_id == id) & (items.orderable_type == 'Seat')}
+          else
+            OrderItem.scoped.as('items').on{(items.orderable_id == id) & (items.orderable_type == 'Seat')}
+          end
+
+        j.should be_kind_of(SubqueryJoin)
+
+        expect { As.new('name', 'alias').on{(items.orderable_id == id) & (items.orderable_type == 'Seat')} }.to raise_error
+      end
+    end
+  end
+end

data/spec/squeel/visitors/order_visitor_spec.rb

@@ -18,17 +18,17 @@ module Squeel
 
       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/
+        function.to_sql.should match /find_in_set\(#{Q}children_people_2#{Q}.#{Q}id#{Q}, '1,2,3'\) DESC/
       end
 
       it 'accepts Order with Operation expression' do
         operation = @v.accept(dsl{(id / 1).desc})
-        operation.to_sql.should match /"people"."id" \/ 1 DESC/
+        operation.to_sql.should match /#{Q}people#{Q}.#{Q}id#{Q} \/ 1 DESC/
       end
 
       it 'orders by predicates' do
         orders = @v.accept(dsl{name == 'Ernie'})
-        orders.to_sql.should match /"people"."name" = 'Ernie'/
+        orders.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = 'Ernie'/
       end
 
     end

data/spec/squeel/visitors/predicate_visitor_spec.rb

@@ -23,25 +23,38 @@ module Squeel
         node.right.should be_a Arel::Nodes::SelectStatement
       end
 
-      it 'does not quote nil values in Predicate nodes' do
+      it 'quote nil values in Predicate nodes' do
         predicate = Nodes::Predicate.new(Nodes::Function.new(:blah, [1, 2]), :in, nil)
         node = @v.accept(predicate)
         node.should be_a Arel::Nodes::In
-        node.right.should be_nil
+        if defined?(Arel::Nodes::Quoted)
+          node.right.expr.should == 'NULL'
+        else
+          node.right.should be_nil
+        end
+
       end
 
       it 'creates Equality nodes for simple hashes' do
         predicate = @v.accept(:name => 'Joe')
         predicate.should be_a Arel::Nodes::Equality
         predicate.left.name.to_s.should eq 'name'
-        predicate.right.should eq 'Joe'
+        if defined?(Arel::Nodes::Casted)
+          predicate.right.val.should eq 'Joe'
+        else
+          predicate.right.should eq 'Joe'
+        end
       end
 
       it 'creates In nodes for simple hashes with an array as a value' do
         predicate = @v.accept(:name => ['Joe', 'Bob'])
         predicate.should be_a Arel::Nodes::In
         predicate.left.name.to_s.should eq 'name'
-        predicate.right.should eq ['Joe', 'Bob']
+        if defined?(Arel::Nodes::Casted)
+          predicate.right.map(&:val).should eq ['Joe', 'Bob']
+        else
+          predicate.right.should eq ['Joe', 'Bob']
+        end
       end
 
       it 'generates "1=0" when given an empty array value in a hash' do
@@ -88,32 +101,32 @@ module Squeel
 
       it 'generates IS NULL for hash keys with a value of [nil]' do
         predicate = @v.accept(:id => [nil])
-        predicate.to_sql.should be_like '"people"."id" IS NULL'
+        predicate.to_sql.should be_like "#{Q}people#{Q}.#{Q}id#{Q} IS NULL"
       end
 
       it 'generates IS NULL for in predicates with a value of [nil]' do
         predicate = @v.accept(:id.in => [nil])
-        predicate.to_sql.should be_like '"people"."id" IS NULL'
+        predicate.to_sql.should be_like "#{Q}people#{Q}.#{Q}id#{Q} IS NULL"
       end
 
       it 'generates IS NOT NULL for not_in predicates with a value of [nil]' do
         predicate = @v.accept(:id.not_in => [nil])
-        predicate.to_sql.should be_like '"people"."id" IS NOT NULL'
+        predicate.to_sql.should be_like "#{Q}people#{Q}.#{Q}id#{Q} IS NOT NULL"
       end
 
       it 'generates IN OR IS NULL for hash keys with a value of [1, 2, 3, nil]' do
         predicate = @v.accept(:id => [1, 2, 3, nil])
-        predicate.to_sql.should be_like '("people"."id" IN (1, 2, 3) OR "people"."id" IS NULL)'
+        predicate.to_sql.should be_like "(#{Q}people#{Q}.#{Q}id#{Q} IN (1, 2, 3) OR #{Q}people#{Q}.#{Q}id#{Q} IS NULL)"
       end
 
       it 'generates IN OR IS NULL for in predicates with a value of [1, 2, 3, nil]' do
         predicate = @v.accept(:id.in => [1, 2, 3, nil])
-        predicate.to_sql.should be_like '("people"."id" IN (1, 2, 3) OR "people"."id" IS NULL)'
+        predicate.to_sql.should be_like "(#{Q}people#{Q}.#{Q}id#{Q} IN (1, 2, 3) OR #{Q}people#{Q}.#{Q}id#{Q} IS NULL)"
       end
 
       it 'generates IN AND IS NOT NULL for not_in predicates with a value of [1, 2, 3, nil]' do
         predicate = @v.accept(:id.not_in => [1, 2, 3, nil])
-        predicate.to_sql.should be_like '"people"."id" NOT IN (1, 2, 3) AND "people"."id" IS NOT NULL'
+        predicate.to_sql.should be_like "#{Q}people#{Q}.#{Q}id#{Q} NOT IN (1, 2, 3) AND #{Q}people#{Q}.#{Q}id#{Q} IS NOT NULL"
       end
 
       it 'allows a subquery on the value side of an explicit predicate' do
@@ -133,39 +146,47 @@ module Squeel
       it 'selects the primary key of a relation with no select_values with an explicit predicate' do
         predicate = @v.accept dsl{name.in(PersonWithNamePrimaryKey.where{name.in(['Aric Smith', 'Gladyce Kulas'])})}
         predicate.right.should be_a Arel::Nodes::SelectStatement
-        predicate.right.to_sql.should match /SELECT "people"."name"/
+        predicate.right.to_sql.should match /SELECT #{Q}people#{Q}.#{Q}name#{Q}/
       end
 
       it 'selects the primary key of a relation with no select_values with an implicit predicate' do
         predicate = @v.accept(:name => PersonWithNamePrimaryKey.where{name.in(['Aric Smith', 'Gladyce Kulas'])})
         predicate.right.should be_a Arel::Nodes::SelectStatement
-        predicate.right.to_sql.should match /SELECT "people"."name"/
+        predicate.right.to_sql.should match /SELECT #{Q}people#{Q}.#{Q}name#{Q}/
       end
 
       it "doesn't clobber a relation value's existing select_values if present with an explicit predicate" do
         predicate = @v.accept dsl{name.in(Person.select{name})}
         predicate.right.should be_a Arel::Nodes::SelectStatement
-        predicate.right.to_sql.should match /SELECT "people"."name"/
+        predicate.right.to_sql.should match /SELECT #{Q}people#{Q}.#{Q}name#{Q}/
       end
 
       it "doesn't clobber a relation value's existing select_values if present with an implicit predicate" do
         predicate = @v.accept(:name => Person.select{name})
         predicate.right.should be_a Arel::Nodes::SelectStatement
-        predicate.right.to_sql.should match /SELECT "people"."name"/
+        predicate.right.to_sql.should match /SELECT #{Q}people#{Q}.#{Q}name#{Q}/
       end
 
       it 'converts ActiveRecord::Base objects to their id' do
         predicate = @v.accept(:id => Person.first)
         predicate.should be_a Arel::Nodes::Equality
         predicate.left.name.to_s.should eq 'id'
-        predicate.right.should eq 1
+        if defined?(Arel::Nodes::Casted)
+          predicate.right.val.should eq 1
+        else
+          predicate.right.should eq 1
+        end
       end
 
       it 'converts arrays of ActiveRecord::Base objects to their ids' do
         predicate = @v.accept(:id => [Person.first, Person.last])
         predicate.should be_a Arel::Nodes::In
         predicate.left.name.to_s.should eq 'id'
-        predicate.right.should eq [1, 332]
+        if defined?(Arel::Nodes::Casted)
+          predicate.right.map(&:val).should eq [Person.first.id, Person.last.id]
+        else
+          predicate.right.should eq [Person.first.id, Person.last.id]
+        end
       end
 
       it 'creates the node against the proper table for nested hashes' do
@@ -182,7 +203,11 @@ module Squeel
         })
         predicate.should be_a Arel::Nodes::Equality
         predicate.left.relation.table_alias.should eq 'parents_people_2'
-        predicate.right.should eq 'Joe'
+        if defined?(Arel::Nodes::Casted)
+          predicate.right.val.should eq 'Joe'
+        else
+          predicate.right.should eq 'Joe'
+        end
       end
 
       it 'treats keypath keys like nested hashes' do
@@ -255,28 +280,28 @@ module Squeel
         predicate = @v.accept(dsl{{name => name}})
         predicate.should be_a Arel::Nodes::Equality
         predicate.right.should be_a Arel::Attribute
-        predicate.to_sql.should match /"people"."name" = "people"."name"/
+        predicate.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = #{Q}people#{Q}.#{Q}name#{Q}/
       end
 
       it 'contextualizes Symbol values' do
         predicate = @v.accept(:name => :name)
         predicate.should be_a Arel::Nodes::Equality
         predicate.right.should be_a Arel::Attribute
-        predicate.to_sql.should match /"people"."name" = "people"."name"/
+        predicate.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = #{Q}people#{Q}.#{Q}name#{Q}/
       end
 
       it 'contextualizes KeyPath values in hashes' do
         predicate = @v.accept(dsl{{name => children.name}})
         predicate.should be_a Arel::Nodes::Equality
         predicate.right.should be_a Arel::Attribute
-        predicate.to_sql.should match /"people"."name" = "children_people"."name"/
+        predicate.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = #{Q}children_people#{Q}.#{Q}name#{Q}/
       end
 
       it 'contextualizes KeyPath values in predicates' do
         predicate = @v.accept(dsl{name == children.name})
         predicate.should be_a Arel::Nodes::Equality
         predicate.right.should be_a Arel::Attribute
-        predicate.to_sql.should match /"people"."name" = "children_people"."name"/
+        predicate.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = #{Q}children_people#{Q}.#{Q}name#{Q}/
       end
 
       it 'visits Squeel Sifters at top level' do
@@ -284,8 +309,8 @@ module Squeel
         predicate.should be_a Arel::Nodes::Grouping
         expr = predicate.expr
         expr.should be_a Arel::Nodes::Or
-        expr.left.to_sql.should match /"people"."name" LIKE 'smith%'/
-        expr.right.to_sql.should match /"people"."name" LIKE '%smith'/
+        expr.left.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} [I]*LIKE 'smith%'/
+        expr.right.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} [I]*LIKE '%smith'/
       end
 
       it 'visits nested Squeel sifters' do
@@ -293,8 +318,8 @@ module Squeel
         predicate.should be_a Arel::Nodes::Grouping
         expr = predicate.expr
         expr.should be_a Arel::Nodes::Or
-        expr.left.to_sql.should match /"children_people"."name" LIKE 'smith%'/
-        expr.right.to_sql.should match /"children_people"."name" LIKE '%smith'/
+        expr.left.to_sql.should match /#{Q}children_people#{Q}.#{Q}name#{Q} [I]*LIKE 'smith%'/
+        expr.right.to_sql.should match /#{Q}children_people#{Q}.#{Q}name#{Q} [I]*LIKE '%smith'/
       end
 
       it 'visits sifters in a keypath' do
@@ -302,14 +327,14 @@ module Squeel
         predicate.should be_a Arel::Nodes::Grouping
         expr = predicate.expr
         expr.should be_a Arel::Nodes::Or
-        expr.left.to_sql.should match /"children_people"."name" LIKE 'smith%'/
-        expr.right.to_sql.should match /"children_people"."name" LIKE '%smith'/
+        expr.left.to_sql.should match /#{Q}children_people#{Q}.#{Q}name#{Q} [I]*LIKE 'smith%'/
+        expr.right.to_sql.should match /#{Q}children_people#{Q}.#{Q}name#{Q} [I]*LIKE '%smith'/
       end
 
       it 'honors an explicit table in string keys' do
         predicate = @v.accept('things.attribute' => 'retro')
         predicate.should be_a Arel::Nodes::Equality
-        predicate.to_sql.should match /"things"."attribute" = 'retro'/
+        predicate.to_sql.should match /#{Q}things#{Q}.#{Q}attribute#{Q} = 'retro'/
       end
 
       it 'does not allow "table.column" keys after context change' do
@@ -324,28 +349,32 @@ module Squeel
         predicate = @v.accept(dsl{id >> Person.select{id}.limit(3).order{id.desc}})
         predicate.should be_a Arel::Nodes::In
         predicate.right.should be_a Arel::Nodes::SelectStatement
-        predicate.to_sql.should be_like '"people"."id" IN (SELECT  "people"."id" FROM "people"  ORDER BY "people"."id" DESC LIMIT 3)'
+        predicate.to_sql.should be_like "#{Q}people#{Q}.#{Q}id#{Q} IN (SELECT  #{Q}people#{Q}.#{Q}id#{Q} FROM #{Q}people#{Q}  ORDER BY #{Q}people#{Q}.#{Q}id#{Q} DESC LIMIT 3)"
       end
 
       it 'converts ActiveRecord::Relation values in function arguments to their Arel AST' do
         predicate = @v.accept(dsl{exists(Person.where{name == 'Aric Smith'})})
         predicate.should be_a Arel::Nodes::NamedFunction
         predicate.expressions.first.should be_a Arel::Nodes::SelectStatement
-        predicate.to_sql.should be_like "exists(SELECT \"people\".* FROM \"people\"  WHERE \"people\".\"name\" = 'Aric Smith')"
+        predicate.to_sql.should be_like "exists(SELECT #{Q}people#{Q}.* FROM #{Q}people#{Q}  WHERE #{Q}people#{Q}.#{Q}name#{Q} = 'Aric Smith')"
       end
 
       it "doesn't try to sanitize_sql an array of strings in the value of a Predicate" do
         predicate = @v.accept(dsl{name >> ['Aric Smith', 'Gladyce Kulas']})
         predicate.should be_a Arel::Nodes::In
         predicate.right.should be_an Array
-        predicate.to_sql.should match /"people"."name" IN \('Aric Smith', 'Gladyce Kulas'\)/
+        predicate.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} IN \('Aric Smith', 'Gladyce Kulas'\)/
       end
 
       it 'creates a node of the proper type when a hash has a Predicate as a key' do
         predicate = @v.accept(:name.matches => 'Joe%')
         predicate.should be_a Arel::Nodes::Matches
         predicate.left.name.should eq :name
-        predicate.right.should eq 'Joe%'
+        if defined?(Arel::Nodes::Casted)
+          predicate.right.val.should eq 'Joe%'
+        else
+          predicate.right.should eq 'Joe%'
+        end
       end
 
       it 'treats hash keys as an association when there is an Or on the value side' do
@@ -383,7 +412,11 @@ module Squeel
         predicate.should be_a Arel::Nodes::Equality
         predicate.left.relation.table_alias.should eq 'children_people_2'
         predicate.left.name.to_s.should eq 'name'
-        predicate.right.should eq 'Joe'
+        if defined?(Arel::Nodes::Casted)
+        predicate.right.val.should eq 'Joe'
+        else
+          predicate.right.should eq 'Joe'
+        end
       end
 
       it 'creates an Arel Grouping node containing an Or node for Or nodes' do
@@ -409,7 +442,7 @@ module Squeel
 
       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 /"people"."id"/
+        function.to_sql.should match /#{Q}people#{Q}.#{Q}id#{Q}/
       end
 
       it 'sets the alias on the Arel NamedFunction from the Function alias' do
@@ -419,12 +452,12 @@ module Squeel
 
       it 'accepts As nodes containing symbols' do
         as = @v.accept(:name.as('other_name'))
-        as.to_sql.should match /"people"."name" AS other_name/
+        as.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} 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/
+        as.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} AS other_name/
       end
 
       it 'creates an Arel Addition node for an Operation node with + as operator' do

data/spec/squeel/visitors/select_visitor_spec.rb

@@ -18,7 +18,7 @@ module Squeel
 
       it 'selects predicates' do
         selects = @v.accept(dsl{name == 'Ernie'})
-        selects.to_sql.should match /"people"."name" = 'Ernie'/
+        selects.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} = 'Ernie'/
       end
 
     end

data/spec/squeel/visitors/visitor_spec.rb

@@ -33,6 +33,7 @@ module Squeel
             }
           }
         })
+
         attributes.should be_a Array
         attribute = attributes.first
         attribute.should be_a Arel::Attributes::Attribute
@@ -68,7 +69,7 @@ module Squeel
       it 'allows a subquery as a selection' do
         relation = Person.where(:name => 'Aric Smith').select(:id)
         node = @v.accept(relation.as('aric'))
-        node.to_sql.should be_like "(SELECT \"people\".\"id\" FROM \"people\"  WHERE \"people\".\"name\" = 'Aric Smith') aric"
+        node.to_sql.should be_like "(SELECT #{Q}people#{Q}.#{Q}id#{Q} FROM #{Q}people#{Q}  WHERE #{Q}people#{Q}.#{Q}name#{Q} = 'Aric Smith') aric"
       end
 
       it 'creates an Arel NamedFunction node for a Function node' do
@@ -78,12 +79,12 @@ module Squeel
 
       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'\)/
+        function.to_sql.should match /find_in_set\(#{Q}people#{Q}.#{Q}id#{Q}, '1,2,3'\)/
       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'\)/
+        function.to_sql.should match /find_in_set\(#{Q}children_people_2#{Q}.#{Q}id#{Q}, '1,2,3'\)/
       end
 
       it 'sets the alias on the Arel NamedFunction from the Function alias' do
@@ -93,17 +94,17 @@ module Squeel
 
       it 'accepts As nodes containing symbols' do
         as = @v.accept(:name.as('other_name'))
-        as.to_sql.should match /"people"."name" AS other_name/
+        as.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} 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/
+        as.to_sql.should match /#{Q}people#{Q}.#{Q}name#{Q} 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/
+        as.to_sql.should match /#{Q}children_people#{Q}.#{Q}name#{Q} AS other_name/
       end
 
       it 'creates an Arel Grouping node for a Squeel Grouping node' do