arel 2.0.1 → 2.0.2

data/{spec/insert_manager_spec.rb → test/test_insert_manager.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'helper'
 
 module Arel
   describe 'insert manager' do
@@ -13,13 +13,9 @@ module Arel
         table = Table.new(:users)
         manager = Arel::InsertManager.new Table.engine
 
-        table[:id].column.extend(Module.new {
-          def type; :boolean; end
-        })
-
-        manager.insert [[table[:id], false]]
-        manager.to_sql.should be_like %{
-          INSERT INTO "users" ("id") VALUES ('f')
+        manager.insert [[table[:bool], false]]
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("bool") VALUES ('f')
         }
       end
 
@@ -27,7 +23,7 @@ module Arel
         table = Table.new(:users)
         manager = Arel::InsertManager.new Table.engine
         manager.insert [[table[:id], nil]]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           INSERT INTO "users" ("id") VALUES (NULL)
         }
       end
@@ -37,12 +33,11 @@ module Arel
         manager = Arel::InsertManager.new Table.engine
 
         time = Time.now
-        attribute = table[:id]
-        attribute.column.type = :date
+        attribute = table[:created_at]
 
         manager.insert [[attribute, time]]
-        manager.to_sql.should be_like %{
-          INSERT INTO "users" ("id") VALUES (#{Table.engine.connection.quote time})
+        manager.to_sql.must_be_like %{
+          INSERT INTO "users" ("created_at") VALUES (#{Table.engine.connection.quote time})
         }
       end
 
@@ -51,7 +46,7 @@ module Arel
         manager = Arel::InsertManager.new Table.engine
         manager.into table
         manager.insert [[table[:id], 1], [table[:name], 'aaron']]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
         }
       end
@@ -60,7 +55,7 @@ module Arel
         table = Table.new(:users)
         manager = Arel::InsertManager.new Table.engine
         manager.insert [[table[:id], 1], [table[:name], 'aaron']]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
         }
       end
@@ -74,14 +69,14 @@ module Arel
     describe 'into' do
       it 'takes an engine' do
         manager = Arel::InsertManager.new Table.engine
-        manager.into(Table.new(:users)).should == manager
+        manager.into(Table.new(:users)).must_equal manager
       end
 
       it 'converts to sql' do
         table   = Table.new :users
         manager = Arel::InsertManager.new Table.engine
         manager.into table
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           INSERT INTO "users"
         }
       end
@@ -93,7 +88,7 @@ module Arel
         manager = Arel::InsertManager.new Table.engine
         manager.into table
         manager.columns << table[:id]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           INSERT INTO "users" ("id")
         }
       end
@@ -106,7 +101,7 @@ module Arel
         manager.into table
 
         manager.values = Nodes::Values.new [1]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           INSERT INTO "users" VALUES (1)
         }
       end
@@ -121,21 +116,10 @@ module Arel
         manager.values = Nodes::Values.new [1, 'aaron']
         manager.columns << table[:id]
         manager.columns << table[:name]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
         }
       end
     end
-
-    describe "TreeManager" do
-      subject do
-        table = Table.new(:users)
-        Arel::InsertManager.new(Table.engine).tap do |manager|
-          manager.insert [[table[:id], nil]]
-        end
-      end
-
-      it_should_behave_like "TreeManager"
-    end
   end
 end

data/{spec/select_manager_spec.rb → test/test_select_manager.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'helper'
 
 module Arel
   class EngineProxy
@@ -37,6 +37,18 @@ module Arel
 
   describe 'select manager' do
     describe 'backwards compatibility' do
+      describe 'project' do
+        it 'accepts symbols as sql literals' do
+          table   = Table.new :users
+          manager = Arel::SelectManager.new Table.engine
+          manager.project :id
+          manager.from table
+          manager.to_sql.must_be_like %{
+            SELECT id FROM "users"
+          }
+        end
+      end
+
       describe 'order' do
         it 'accepts symbols' do
           table   = Table.new :users
@@ -44,9 +56,7 @@ module Arel
           manager.project SqlLiteral.new '*'
           manager.from table
           manager.order :foo
-          manager.to_sql.should be_like %{
-          SELECT * FROM "users" ORDER BY foo
-          }
+          manager.to_sql.must_be_like %{ SELECT * FROM "users" ORDER BY foo }
         end
       end
 
@@ -56,9 +66,7 @@ module Arel
           manager = Arel::SelectManager.new Table.engine
           manager.from table
           manager.group :foo
-          manager.to_sql.should be_like %{
-          SELECT FROM "users" GROUP BY foo
-          }
+          manager.to_sql.must_be_like %{ SELECT FROM "users" GROUP BY foo }
         end
       end
 
@@ -70,7 +78,7 @@ module Arel
           manager.from table
           manager.from 'users'
           manager.project table['id']
-          manager.to_sql.should be_like 'SELECT "users"."id" FROM users'
+          manager.to_sql.must_be_like 'SELECT "users"."id" FROM users'
         end
       end
 
@@ -79,7 +87,7 @@ module Arel
           table   = Table.new :users
           mgr = table.from table
           mgr.having 'foo'
-          mgr.to_sql.should be_like %{ SELECT FROM "users" HAVING foo }
+          mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo }
         end
       end
     end
@@ -90,8 +98,7 @@ module Arel
         mgr = table.from table
         m2 = mgr.clone
         m2.project "foo"
-
-        check mgr.to_sql.should_not == m2.to_sql
+        mgr.to_sql.wont_equal m2.to_sql
       end
     end
 
@@ -100,7 +107,7 @@ module Arel
         table   = Table.new :users, :engine => Table.engine, :as => 'foo'
         mgr = table.from table
         mgr.skip 10
-        mgr.to_sql.should be_like %{ SELECT FROM "users" "foo" OFFSET 10 }
+        mgr.to_sql.must_be_like %{ SELECT FROM "users" "foo" OFFSET 10 }
       end
     end
 
@@ -109,22 +116,50 @@ module Arel
         table   = Table.new :users
         mgr = table.from table
         mgr.skip 10
-        mgr.to_sql.should be_like %{ SELECT FROM "users" OFFSET 10 }
+        mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
       end
 
       it 'should chain' do
         table   = Table.new :users
         mgr = table.from table
-        mgr.skip(10).to_sql.should be_like %{ SELECT FROM "users" OFFSET 10 }
+        mgr.skip(10).to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
+      end
+    end
+
+    describe 'exists' do
+      it 'should create an exists clause' do
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new Table.engine, table
+        manager.project SqlLiteral.new '*'
+        m2 = Arel::SelectManager.new(manager.engine)
+        m2.project manager.exists
+        m2.to_sql.must_be_like %{ SELECT EXISTS (#{manager.to_sql}) }
+      end
+
+      it 'can be aliased' do
+        table = Table.new(:users)
+        manager = Arel::SelectManager.new Table.engine, table
+        manager.project SqlLiteral.new '*'
+        m2 = Arel::SelectManager.new(manager.engine)
+        m2.project manager.exists.as('foo')
+        m2.to_sql.must_be_like %{ SELECT EXISTS (#{manager.to_sql}) AS foo }
+      end
+    end
+
+    describe 'ast' do
+      it 'should return the ast' do
+        table   = Table.new :users
+        mgr = table.from table
+        ast = mgr.ast
+        mgr.visitor.accept(ast).must_equal mgr.to_sql
       end
     end
 
     describe 'taken' do
       it 'should return limit' do
-        table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
         manager.take 10
-        check manager.taken.should == 10
+        manager.taken.must_equal 10
       end
     end
 
@@ -136,7 +171,7 @@ module Arel
         manager.from table
         manager.insert 'VALUES(NULL)'
 
-        engine.executed.last.should be_like %{
+        engine.executed.last.must_be_like %{
           INSERT INTO "users" VALUES(NULL)
         }
       end
@@ -147,7 +182,7 @@ module Arel
       it 'adds a lock node' do
         table   = Table.new :users
         mgr = table.from table
-        mgr.lock.to_sql.should be_like %{ SELECT FROM "users" }
+        mgr.lock.to_sql.must_be_like %{ SELECT FROM "users" }
       end
     end
 
@@ -157,7 +192,7 @@ module Arel
         manager = Arel::SelectManager.new Table.engine
         order = table[:id]
         manager.order table[:id]
-        check manager.orders.should == [order]
+        manager.orders.must_equal [order]
       end
     end
 
@@ -168,7 +203,7 @@ module Arel
         manager.project SqlLiteral.new '*'
         manager.from table
         manager.order table[:id]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           SELECT * FROM "users" ORDER BY "users"."id"
         }
       end
@@ -180,7 +215,7 @@ module Arel
         manager.project SqlLiteral.new '*'
         manager.from table
         manager.order table[:id], table[:name]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           SELECT * FROM "users" ORDER BY "users"."id", "users"."name"
         }
       end
@@ -188,7 +223,7 @@ module Arel
       it 'chains' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
-        check manager.order(table[:id]).should == manager
+        manager.order(table[:id]).must_equal manager
       end
     end
 
@@ -201,7 +236,7 @@ module Arel
 
         manager.from left
         manager.join(right).on(predicate, predicate)
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
            SELECT FROM "users"
              INNER JOIN "users" "users_2"
                ON "users"."id" = "users_2"."id" AND
@@ -221,7 +256,7 @@ module Arel
           predicate,
           left[:name].eq(right[:name])
         )
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
            SELECT FROM "users"
              INNER JOIN "users" "users_2"
                ON "users"."id" = "users_2"."id" AND
@@ -240,7 +275,7 @@ module Arel
 
         manager.from left
         manager.join(right).on(predicate)
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
            SELECT FROM "users"
              INNER JOIN "users" "users_2"
                ON "users"."id" = "users_2"."id"
@@ -255,7 +290,7 @@ module Arel
 
         manager.from left
         manager.join(right, Nodes::OuterJoin).on(predicate)
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
            SELECT FROM "users"
              LEFT OUTER JOIN "users" "users_2"
                ON "users"."id" = "users_2"."id"
@@ -264,7 +299,7 @@ module Arel
 
       it 'noops on nil' do
         manager   = Arel::SelectManager.new Table.engine
-        check manager.join(nil).should == manager
+        manager.join(nil).must_equal manager
       end
     end
 
@@ -274,10 +309,10 @@ module Arel
         aliaz   = table.alias
         manager = Arel::SelectManager.new Table.engine
         manager.from Nodes::InnerJoin.new(table, aliaz, table[:id].eq(aliaz[:id]))
-        manager.join_sql.should be_like %{
+        manager.join_sql.must_be_like %{
           INNER JOIN "users" "users_2" "users"."id" = "users_2"."id"
         }
-        check manager.joins(manager).should == manager.join_sql
+        manager.joins(manager).must_equal manager.join_sql
       end
 
       it 'returns outer join sql' do
@@ -285,35 +320,33 @@ module Arel
         aliaz   = table.alias
         manager = Arel::SelectManager.new Table.engine
         manager.from Nodes::OuterJoin.new(table, aliaz, table[:id].eq(aliaz[:id]))
-        manager.join_sql.should be_like %{
+        manager.join_sql.must_be_like %{
           LEFT OUTER JOIN "users" "users_2" "users"."id" = "users_2"."id"
         }
-        check manager.joins(manager).should == manager.join_sql
+        manager.joins(manager).must_equal manager.join_sql
       end
 
       it 'returns string join sql' do
         table   = Table.new :users
-        aliaz   = table.alias
         manager = Arel::SelectManager.new Table.engine
         manager.from Nodes::StringJoin.new(table, 'hello')
-        manager.join_sql.should be_like %{ 'hello' }
-        check manager.joins(manager).should == manager.join_sql
+        manager.join_sql.must_be_like %{ 'hello' }
+        manager.joins(manager).must_equal manager.join_sql
       end
 
       it 'returns nil join sql' do
         manager = Arel::SelectManager.new Table.engine
-        manager.join_sql.should be_nil
+        manager.join_sql.must_be_nil
       end
     end
 
     describe 'order_clauses' do
       it 'returns order clauses as a list' do
         table   = Table.new :users
-        aliaz   = table.alias
         manager = Arel::SelectManager.new Table.engine
         manager.from table
         manager.order table[:id]
-        manager.order_clauses.first.should be_like %{ "users"."id" }
+        manager.order_clauses.first.must_be_like %{ "users"."id" }
       end
     end
 
@@ -323,7 +356,7 @@ module Arel
         manager = Arel::SelectManager.new Table.engine
         manager.from table
         manager.group table[:id]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           SELECT FROM "users" GROUP BY "users"."id"
         }
       end
@@ -331,7 +364,7 @@ module Arel
       it 'chains' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
-        check manager.group(table[:id]).should == manager
+        manager.group(table[:id]).must_equal manager
       end
 
       it 'takes multiple args' do
@@ -339,7 +372,7 @@ module Arel
         manager = Arel::SelectManager.new Table.engine
         manager.from table
         manager.group table[:id], table[:name]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           SELECT FROM "users" GROUP BY "users"."id", "users"."name"
         }
       end
@@ -350,7 +383,7 @@ module Arel
         manager = Arel::SelectManager.new Table.engine
         manager.from table
         manager.group 'foo'
-        manager.to_sql.should be_like %{ SELECT FROM "users" GROUP BY foo }
+        manager.to_sql.must_be_like %{ SELECT FROM "users" GROUP BY foo }
       end
     end
 
@@ -362,7 +395,7 @@ module Arel
         manager.from table
         manager.delete
 
-        engine.executed.last.should be_like %{ DELETE FROM "users" }
+        engine.executed.last.must_be_like %{ DELETE FROM "users" }
       end
 
       it "copies where" do
@@ -373,7 +406,7 @@ module Arel
         manager.where table[:id].eq 10
         manager.delete
 
-        engine.executed.last.should be_like %{
+        engine.executed.last.must_be_like %{
           DELETE FROM "users" WHERE "users"."id" = 10
         }
       end
@@ -385,14 +418,14 @@ module Arel
         manager = Arel::SelectManager.new Table.engine
         manager.from table
         manager.where table[:id].eq 10
-        manager.where_sql.should be_like %{ WHERE "users"."id" = 10 }
+        manager.where_sql.must_be_like %{ WHERE "users"."id" = 10 }
       end
 
       it 'returns nil when there are no wheres' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
         manager.from table
-        manager.where_sql.should be_nil
+        manager.where_sql.must_be_nil
       end
     end
 
@@ -405,7 +438,7 @@ module Arel
         manager.take 1
         manager.update(SqlLiteral.new('foo = bar'))
 
-        engine.executed.last.should be_like %{
+        engine.executed.last.must_be_like %{
           UPDATE "users" SET foo = bar
           WHERE "users"."id" IN (SELECT "users"."id" FROM "users" LIMIT 1)
         }
@@ -419,7 +452,7 @@ module Arel
         manager.order :foo
         manager.update(SqlLiteral.new('foo = bar'))
 
-        engine.executed.last.should be_like %{
+        engine.executed.last.must_be_like %{
           UPDATE "users" SET foo = bar
           WHERE "users"."id" IN (SELECT "users"."id" FROM "users" ORDER BY foo)
         }
@@ -432,7 +465,7 @@ module Arel
         manager.from table
         manager.update(SqlLiteral.new('foo = bar'))
 
-        engine.executed.last.should be_like %{ UPDATE "users" SET foo = bar }
+        engine.executed.last.must_be_like %{ UPDATE "users" SET foo = bar }
       end
 
       it 'copies where clauses' do
@@ -443,7 +476,7 @@ module Arel
         manager.from table
         manager.update(table[:id] => 1)
 
-        engine.executed.last.should be_like %{
+        engine.executed.last.must_be_like %{
           UPDATE "users" SET "id" = 1 WHERE "users"."id" = 10
         }
       end
@@ -455,7 +488,7 @@ module Arel
         manager.from table
         manager.update(table[:id] => 1)
 
-        engine.executed.last.should be_like %{
+        engine.executed.last.must_be_like %{
           UPDATE "users" SET "id" = 1
         }
       end
@@ -463,25 +496,22 @@ module Arel
 
     describe 'project' do
       it 'takes multiple args' do
-        table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
         manager.project Nodes::SqlLiteral.new('foo'),
           Nodes::SqlLiteral.new('bar')
-        manager.to_sql.should be_like %{ SELECT foo, bar }
+        manager.to_sql.must_be_like %{ SELECT foo, bar }
       end
 
       it 'takes strings' do
-        table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
         manager.project Nodes::SqlLiteral.new('*')
-        manager.to_sql.should be_like %{ SELECT * }
+        manager.to_sql.must_be_like %{ SELECT * }
       end
 
       it "takes sql literals" do
-        table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
         manager.project Nodes::SqlLiteral.new '*'
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           SELECT *
         }
       end
@@ -495,7 +525,7 @@ module Arel
         manager.where(table['id'].eq(1))
         manager.take 1
 
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           SELECT "users"."id"
           FROM "users"
           WHERE "users"."id" = 1
@@ -504,9 +534,8 @@ module Arel
       end
 
       it "chains" do
-        table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
-        manager.take(1).should == manager
+        manager.take(1).must_equal manager
       end
     end
 
@@ -516,7 +545,7 @@ module Arel
         manager = Arel::SelectManager.new Table.engine
         manager.from(table).project(table['id'])
         manager.where(table['id'].eq(1))
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           SELECT "users"."id"
           FROM "users"
           WHERE "users"."id" = 1
@@ -527,7 +556,7 @@ module Arel
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
         manager.from(table)
-        manager.project(table['id']).where(table['id'].eq 1).should == manager
+        manager.project(table['id']).where(table['id'].eq 1).must_equal manager
       end
     end
 
@@ -539,9 +568,9 @@ module Arel
 
         mgr = left.join(right)
         mgr.project Nodes::SqlLiteral.new('*')
-        check mgr.on(predicate).should == mgr
+        mgr.on(predicate).must_equal mgr
 
-        mgr.to_sql.should be_like %{
+        mgr.to_sql.must_be_like %{
            SELECT * FROM "users"
              INNER JOIN "users" "users_2"
                ON "users"."id" = "users_2"."id"
@@ -556,26 +585,15 @@ module Arel
 
         manager.from table
         manager.project table['id']
-        manager.to_sql.should be_like 'SELECT "users"."id" FROM "users"'
+        manager.to_sql.must_be_like 'SELECT "users"."id" FROM "users"'
       end
 
       it "chains" do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
-        check manager.from(table).project(table['id']).should == manager
-        manager.to_sql.should be_like 'SELECT "users"."id" FROM "users"'
-      end
-    end
-
-    describe "TreeManager" do
-      subject do
-        table   = Table.new :users
-        Arel::SelectManager.new(Table.engine).tap do |manager|
-          manager.from(table).project(table['id'])
-        end
+        manager.from(table).project(table['id']).must_equal manager
+        manager.to_sql.must_be_like 'SELECT "users"."id" FROM "users"'
       end
-
-      it_should_behave_like "TreeManager"
     end
   end
 end