arel 2.0.1 → 2.0.2

data/{spec/table_spec.rb → test/test_table.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'helper'
 
 module Arel
   describe Table do
@@ -6,23 +6,30 @@ module Arel
       @relation = Table.new(:users)
     end
 
+    describe 'skip' do
+      it 'should add an offset' do
+        sm = @relation.skip 2
+        sm.to_sql.must_be_like "SELECT FROM \"users\" OFFSET 2"
+      end
+    end
+
     describe 'primary_key' do
       it 'should return an attribute' do
-        check @relation.primary_key.name.should == :id
+        @relation.primary_key.name.must_equal :id
       end
     end
 
     describe 'select_manager' do
       it 'should return an empty select manager' do
         sm = @relation.select_manager
-        sm.to_sql.should be_like 'SELECT'
+        sm.to_sql.must_be_like 'SELECT'
       end
     end
 
     describe 'having' do
       it 'adds a having clause' do
         mgr = @relation.having @relation[:id].eq(10)
-        mgr.to_sql.should be_like %{
+        mgr.to_sql.must_be_like %{
          SELECT FROM "users" HAVING "users"."id" = 10
         }
       end
@@ -31,7 +38,7 @@ module Arel
     describe 'backwards compat' do
       describe 'joins' do
         it 'returns nil' do
-          check @relation.joins(nil).should == nil
+          @relation.joins(nil).must_equal nil
         end
       end
 
@@ -39,7 +46,7 @@ module Arel
         it 'noops on nil' do
           mgr = @relation.join nil
 
-          mgr.to_sql.should be_like %{ SELECT FROM "users" }
+          mgr.to_sql.must_be_like %{ SELECT FROM "users" }
         end
 
         it 'takes a second argument for join type' do
@@ -47,7 +54,7 @@ module Arel
           predicate = @relation[:id].eq(right[:id])
           mgr = @relation.join(right, Nodes::OuterJoin).on(predicate)
 
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
            SELECT FROM "users"
              LEFT OUTER JOIN "users" "users_2"
                ON "users"."id" = "users_2"."id"
@@ -59,7 +66,7 @@ module Arel
     describe 'group' do
       it 'should create a group' do
         manager = @relation.group @relation[:id]
-        manager.to_sql.should be_like %{
+        manager.to_sql.must_be_like %{
           SELECT FROM "users" GROUP BY "users"."id"
         }
       end
@@ -67,13 +74,12 @@ module Arel
 
     describe 'alias' do
       it 'should create a node that proxies to a table' do
-        check @relation.aliases.should == []
+        @relation.aliases.must_equal []
 
         node = @relation.alias
-        check @relation.aliases.should == [node]
-        check node.name.should == 'users_2'
-        check node[:id].relation.should == node
-        check node[:id].relation.should != node
+        @relation.aliases.must_equal [node]
+        node.name.must_equal 'users_2'
+        node[:id].relation.must_equal node
       end
     end
 
@@ -81,30 +87,30 @@ module Arel
       it 'takes :columns' do
         columns = Table.engine.connection.columns("users")
         @relation = Table.new(:users, :columns => columns)
-        check @relation.columns.first.name.should == :id
-        check @relation.engine.should == Table.engine
+        @relation.columns.first.name.must_equal :id
+        @relation.engine.must_equal Table.engine
       end
 
       it 'should accept an engine' do
         rel = Table.new :users, 'foo'
-        check rel.engine.should == 'foo'
+        rel.engine.must_equal 'foo'
       end
 
       it 'should accept a hash' do
         rel = Table.new :users, :engine => 'foo'
-        check rel.engine.should == 'foo'
+        rel.engine.must_equal 'foo'
       end
 
       it 'ignores as if it equals name' do
         rel = Table.new :users, :as => 'users'
-        rel.table_alias.should be_nil
+        rel.table_alias.must_be_nil
       end
     end
 
     describe 'order' do
       it "should take an order" do
         manager = @relation.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
 
@@ -112,19 +118,19 @@ module Arel
       it "should add a limit" do
         manager = @relation.take 1
         manager.project SqlLiteral.new '*'
-        manager.to_sql.should be_like %{ SELECT * FROM "users" LIMIT 1 }
+        manager.to_sql.must_be_like %{ SELECT * FROM "users" LIMIT 1 }
       end
     end
 
     describe 'project' do
       it 'can project' do
         manager = @relation.project SqlLiteral.new '*'
-        manager.to_sql.should be_like %{ SELECT * FROM "users" }
+        manager.to_sql.must_be_like %{ SELECT * FROM "users" }
       end
 
       it 'takes multiple parameters' do
         manager = @relation.project SqlLiteral.new('*'), SqlLiteral.new('*')
-        manager.to_sql.should be_like %{ SELECT *, * FROM "users" }
+        manager.to_sql.must_be_like %{ SELECT *, * FROM "users" }
       end
     end
 
@@ -132,8 +138,8 @@ module Arel
       it "returns a tree manager" do
         manager = @relation.where @relation[:id].eq 1
         manager.project @relation[:id]
-        manager.should be_kind_of TreeManager
-        manager.to_sql.should be_like %{
+        manager.must_be_kind_of TreeManager
+        manager.to_sql.must_be_like %{
           SELECT "users"."id"
           FROM "users"
           WHERE "users"."id" = 1
@@ -144,31 +150,31 @@ module Arel
     describe 'columns' do
       it 'returns a list of columns' do
         columns = @relation.columns
-        check columns.length.should == 2
-        columns.map { |x| x.name.to_s }.sort.should == %w{ name id }.sort
+        columns.length.must_equal 4
+        columns.map { |x| x.name.to_s }.sort.must_equal %w{ created_at bool name id }.sort
       end
     end
 
     it "should have a name" do
-      @relation.name.should == :users
+      @relation.name.must_equal :users
     end
 
     it "should have an engine" do
-      @relation.engine.should == Table.engine
+      @relation.engine.must_equal Table.engine
     end
 
     describe '[]' do
-      describe 'when given a', Symbol do
+      describe 'when given a Symbol' do
         it "manufactures an attribute if the symbol names an attribute within the relation" do
           column = @relation[:id]
-          check column.name.should == :id
-          column.should be_kind_of Attributes::Integer
+          column.name.must_equal :id
+          column.must_be_kind_of Attributes::Integer
         end
       end
 
       describe 'when table does not exist' do
         it 'returns nil' do
-          @relation[:foooo].should be_nil
+          @relation[:foooo].must_be_nil
         end
       end
     end

data/{spec/update_manager_spec.rb → test/test_update_manager.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'helper'
 
 module Arel
   describe 'update manager' do
@@ -14,7 +14,7 @@ module Arel
         um = Arel::UpdateManager.new Table.engine
         um.table table
         um.set [[table[:name], nil]]
-        um.to_sql.should be_like %{ UPDATE "users" SET "name" =  NULL }
+        um.to_sql.must_be_like %{ UPDATE "users" SET "name" =  NULL }
       end
 
       it 'takes a string' do
@@ -22,7 +22,7 @@ module Arel
         um = Arel::UpdateManager.new Table.engine
         um.table table
         um.set Nodes::SqlLiteral.new "foo = bar"
-        um.to_sql.should be_like %{ UPDATE "users" SET foo = bar }
+        um.to_sql.must_be_like %{ UPDATE "users" SET foo = bar }
       end
 
       it 'takes a list of lists' do
@@ -30,7 +30,7 @@ module Arel
         um = Arel::UpdateManager.new Table.engine
         um.table table
         um.set [[table[:id], 1], [table[:name], 'hello']]
-        um.to_sql.should be_like %{
+        um.to_sql.must_be_like %{
           UPDATE "users" SET "id" = 1, "name" =  'hello'
         }
       end
@@ -38,7 +38,7 @@ module Arel
       it 'chains' do
         table = Table.new(:users)
         um = Arel::UpdateManager.new Table.engine
-        um.set([[table[:id], 1], [table[:name], 'hello']]).should == um
+        um.set([[table[:id], 1], [table[:name], 'hello']]).must_equal um
       end
     end
 
@@ -46,12 +46,12 @@ module Arel
       it 'generates an update statement' do
         um = Arel::UpdateManager.new Table.engine
         um.table Table.new(:users)
-        um.to_sql.should be_like %{ UPDATE "users" }
+        um.to_sql.must_be_like %{ UPDATE "users" }
       end
 
       it 'chains' do
         um = Arel::UpdateManager.new Table.engine
-        um.table(Table.new(:users)).should == um
+        um.table(Table.new(:users)).must_equal um
       end
     end
 
@@ -61,7 +61,7 @@ module Arel
         um = Arel::UpdateManager.new Table.engine
         um.table table
         um.where table[:id].eq(1)
-        um.to_sql.should be_like %{
+        um.to_sql.must_be_like %{
           UPDATE "users" WHERE "users"."id" = 1
         }
       end
@@ -70,20 +70,8 @@ module Arel
         table = Table.new :users
         um = Arel::UpdateManager.new Table.engine
         um.table table
-        um.where(table[:id].eq(1)).should == um
+        um.where(table[:id].eq(1)).must_equal um
       end
     end
-
-    describe "TreeManager" do
-      subject do
-        table = Table.new :users
-        Arel::UpdateManager.new(Table.engine).tap do |manager|
-          manager.table table
-          manager.where table[:id].eq(1)
-        end
-      end
-
-      it_should_behave_like "TreeManager"
-    end
   end
 end

data/{spec/visitors/join_sql_spec.rb → test/visitors/test_join_sql.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'helper'
 
 module Arel
   module Visitors
@@ -12,7 +12,7 @@ module Arel
           t    = Table.new :users
           join = Nodes::InnerJoin.new t, t, Nodes::On.new(t[:id])
           j2   = Nodes::InnerJoin.new join, t, Nodes::On.new(t[:id])
-          @visitor.accept(j2).should be_like %{
+          @visitor.accept(j2).must_be_like %{
             INNER JOIN "users" ON "users"."id"
             INNER JOIN "users" ON "users"."id"
           }
@@ -24,7 +24,7 @@ module Arel
           t    = Table.new :users
           join = Nodes::OuterJoin.new t, t, Nodes::On.new(t[:id])
           j2   = Nodes::OuterJoin.new join, t, Nodes::On.new(t[:id])
-          @visitor.accept(j2).should be_like %{
+          @visitor.accept(j2).must_be_like %{
             LEFT OUTER JOIN "users" ON "users"."id"
             LEFT OUTER JOIN "users" ON "users"."id"
           }

data/test/visitors/test_mysql.rb

@@ -0,0 +1,27 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    describe 'the mysql visitor' do
+      before do
+        @visitor = MySQL.new Table.engine
+      end
+
+      ###
+      # :'(
+      # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
+      it 'defaults limit to 18446744073709551615' do
+        stmt = Nodes::SelectStatement.new
+        stmt.offset = Nodes::Offset.new(1)
+        sql = @visitor.accept(stmt)
+        sql.must_be_like "SELECT FROM DUAL LIMIT 18446744073709551615 OFFSET 1"
+      end
+
+      it 'uses DUAL for empty from' do
+        stmt = Nodes::SelectStatement.new
+        sql = @visitor.accept(stmt)
+        sql.must_be_like "SELECT FROM DUAL"
+      end
+    end
+  end
+end

data/{spec/visitors/oracle_spec.rb → test/visitors/test_oracle.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'helper'
 
 module Arel
   module Visitors
@@ -14,7 +14,7 @@ module Arel
         stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
         stmt.orders << Nodes::SqlLiteral.new('foo')
         sql = @visitor.accept(stmt)
-        sql.should be_like %{
+        sql.must_be_like %{
           SELECT #{select} ORDER BY alias_0__
         }
       end
@@ -28,7 +28,7 @@ module Arel
 
         sql = @visitor.accept(stmt)
         sql2 = @visitor.accept(stmt)
-        check sql.should == sql2
+        sql.must_equal sql2
       end
 
       it 'splits orders with commas' do
@@ -38,7 +38,7 @@ module Arel
         stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
         stmt.orders << Nodes::SqlLiteral.new('foo, bar')
         sql = @visitor.accept(stmt)
-        sql.should be_like %{
+        sql.must_be_like %{
           SELECT #{select} ORDER BY alias_0__, alias_1__
         }
       end
@@ -49,7 +49,7 @@ module Arel
             stmt = Nodes::SelectStatement.new
             stmt.limit = 10
             sql = @visitor.accept stmt
-            sql.should be_like %{ SELECT WHERE ROWNUM <= 10 }
+            sql.must_be_like %{ SELECT WHERE ROWNUM <= 10 }
           end
 
           it 'is idempotent' do
@@ -58,7 +58,7 @@ module Arel
             stmt.limit = 10
             sql = @visitor.accept stmt
             sql2 = @visitor.accept stmt
-            check sql.should == sql2
+            sql.must_equal sql2
           end
 
           it 'creates a subquery when there is order_by' do
@@ -66,7 +66,7 @@ module Arel
             stmt.orders << Nodes::SqlLiteral.new('foo')
             stmt.limit = 10
             sql = @visitor.accept stmt
-            sql.should be_like %{
+            sql.must_be_like %{
               SELECT * FROM (SELECT ORDER BY foo) WHERE ROWNUM <= 10
             }
           end
@@ -76,7 +76,7 @@ module Arel
             stmt.cores.first.projections << Nodes::SqlLiteral.new('DISTINCT id')
             stmt.limit = 10
             sql = @visitor.accept stmt
-            sql.should be_like %{
+            sql.must_be_like %{
               SELECT * FROM (SELECT DISTINCT id) WHERE ROWNUM <= 10
             }
           end
@@ -86,7 +86,7 @@ module Arel
             stmt.limit = 10
             stmt.offset = Nodes::Offset.new(10)
             sql = @visitor.accept stmt
-            sql.should be_like %{
+            sql.must_be_like %{
               SELECT * FROM (
                 SELECT raw_sql_.*, rownum raw_rnum_
                 FROM (SELECT ) raw_sql_
@@ -102,9 +102,25 @@ module Arel
             stmt.offset = Nodes::Offset.new(10)
             sql = @visitor.accept stmt
             sql2 = @visitor.accept stmt
-            check sql.should == sql2
+            sql.must_equal sql2
           end
         end
+
+        describe 'only offset' do
+          it 'creates a select from subquery with rownum condition' do
+            stmt = Nodes::SelectStatement.new
+            stmt.offset = Nodes::Offset.new(10)
+            sql = @visitor.accept stmt
+            sql.must_be_like %{
+              SELECT * FROM (
+                SELECT raw_sql_.*, rownum raw_rnum_
+                FROM (SELECT ) raw_sql_
+              )
+              WHERE raw_rnum_ > 10
+            }
+          end
+        end
+
       end
     end
   end

data/{spec/visitors/postgres_spec.rb → test/visitors/test_postgres.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'helper'
 
 module Arel
   module Visitors
@@ -8,7 +8,7 @@ module Arel
       end
 
       it 'should produce a lock value' do
-        @visitor.accept(Nodes::Lock.new).should be_like %{
+        @visitor.accept(Nodes::Lock.new).must_be_like %{
           FOR UPDATE
         }
       end