arel 2.0.1 → 2.0.2

data/lib/arel/visitors.rb

@@ -1,4 +1,6 @@
+require 'arel/visitors/visitor'
 require 'arel/visitors/to_sql'
+require 'arel/visitors/sqlite'
 require 'arel/visitors/postgresql'
 require 'arel/visitors/mysql'
 require 'arel/visitors/oracle'
@@ -14,6 +16,8 @@ module Arel
       'mysql'           => Arel::Visitors::MySQL,
       'mysql2'          => Arel::Visitors::MySQL,
       'oracle_enhanced' => Arel::Visitors::Oracle,
+      'sqlite'          => Arel::Visitors::SQLite,
+      'sqlite3'         => Arel::Visitors::SQLite,
     }
 
     ENGINE_VISITORS = Hash.new do |hash, engine|

data/lib/arel/visitors/dot.rb

@@ -1,6 +1,6 @@
 module Arel
   module Visitors
-    class Dot
+    class Dot < Arel::Visitors::Visitor
       class Node # :nodoc:
         attr_accessor :name, :id, :fields
 
@@ -23,7 +23,7 @@ module Arel
       end
 
       def accept object
-        visit object
+        super
         to_dot
       end
 
@@ -188,7 +188,7 @@ module Arel
         @seen[node.id] = node
         @nodes << node
         with_node node do
-          send "visit_#{o.class.name.gsub('::', '_')}", o
+          super
         end
       end
 

data/lib/arel/visitors/join_sql.rb

@@ -9,6 +9,8 @@ module Arel
     # This visitor is used in SelectManager#join_sql and is for backwards
     # compatibility with Arel V1.0
     class JoinSql < Arel::Visitors::ToSql
+      private
+
       def visit_Arel_Nodes_SelectCore o
         [o.froms].grep(Nodes::Join).map { |x| visit x }.join ', '
       end

data/lib/arel/visitors/mysql.rb

@@ -1,6 +1,20 @@
 module Arel
   module Visitors
     class MySQL < Arel::Visitors::ToSql
+      private
+      ###
+      # :'(
+      # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
+      def visit_Arel_Nodes_SelectStatement o
+        o.limit = 18446744073709551615 if o.offset && !o.limit
+        super
+      end
+
+      def visit_Arel_Nodes_SelectCore o
+        o.froms ||= Arel.sql('DUAL')
+        super
+      end
+
       def visit_Arel_Nodes_UpdateStatement o
         [
           "UPDATE #{visit o.relation}",

data/lib/arel/visitors/oracle.rb

@@ -40,6 +40,20 @@ module Arel
           return "SELECT * FROM (#{super(o)}) WHERE ROWNUM <= #{limit}"
         end
 
+        if o.offset
+          o        = o.dup
+          offset   = o.offset
+          o.offset = nil
+          sql = super(o)
+          return <<-eosql
+              SELECT * FROM (
+                SELECT raw_sql_.*, rownum raw_rnum_
+                FROM (#{sql}) raw_sql_
+              )
+              WHERE #{visit offset}
+          eosql
+        end
+
         super
       end
 
@@ -56,7 +70,23 @@ module Arel
             /DISTINCT.*FIRST_VALUE/ === projection
           end
         end
-        orders   = o.orders.map { |x| visit x }.join(', ').split(',')
+        # FIXME: previous version with join and split broke ORDER BY clause
+        # if it contained functions with several arguments (separated by ',').
+        # Currently splitting is done only if there is no function calls
+        #
+        # orders   = o.orders.map { |x| visit x }.join(', ').split(',')
+        orders   = o.orders.map do |x|
+          string = visit x
+          # if there is function call
+          if string.include?('(')
+            string
+          # if no function call then comma splits several ORDER BY columns
+          elsif string.include?(',')
+            string.split(',')
+          else
+            string
+          end
+        end.flatten
         o.orders = []
         orders.each_with_index do |order, i|
           o.orders <<

data/lib/arel/visitors/order_clauses.rb

@@ -1,6 +1,8 @@
 module Arel
   module Visitors
     class OrderClauses < Arel::Visitors::ToSql
+      private
+
       def visit_Arel_Nodes_SelectStatement o
         o.orders.map { |x| visit x }
       end

data/lib/arel/visitors/sqlite.rb

@@ -0,0 +1,11 @@
+module Arel
+  module Visitors
+    class SQLite < Arel::Visitors::ToSql
+      private
+      def visit_Arel_Nodes_SelectStatement o
+        o.limit = -1 if o.offset && !o.limit
+        super
+      end
+    end
+  end
+end

data/lib/arel/visitors/to_sql.rb

@@ -3,7 +3,7 @@ require 'date'
 
 module Arel
   module Visitors
-    class ToSql
+    class ToSql < Arel::Visitors::Visitor
       def initialize engine
         @engine         = engine
         @connection     = nil
@@ -16,7 +16,7 @@ module Arel
         @last_column = nil
         @engine.connection_pool.with_connection do |conn|
           @connection = conn
-          visit object
+          super
         end
       end
 
@@ -48,6 +48,7 @@ module Arel
           ("WHERE #{wheres.map { |x| visit x }.join ' AND '}" unless wheres.empty?)
         ].compact.join ' '
       end
+
       def visit_Arel_Nodes_InsertStatement o
         [
           "INSERT INTO #{visit o.relation}",
@@ -61,7 +62,8 @@ module Arel
       end
 
       def visit_Arel_Nodes_Exists o
-        "EXISTS (#{visit o.select_stmt})"
+        "EXISTS (#{visit o.select_stmt})#{
+          o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
       def visit_Arel_Nodes_Values o
@@ -263,6 +265,7 @@ module Arel
       def visit_Fixnum o; o end
       alias :visit_Arel_Nodes_SqlLiteral :visit_Fixnum
       alias :visit_Arel_SqlLiteral :visit_Fixnum # This is deprecated
+      alias :visit_Bignum :visit_Fixnum
 
       def visit_String o; quote(o, @last_column) end
 
@@ -276,14 +279,8 @@ module Arel
       alias :visit_Symbol :visit_String
       alias :visit_Time :visit_String
       alias :visit_TrueClass :visit_String
-
-      DISPATCH = Hash.new do |hash, klass|
-        hash[klass] = "visit_#{klass.name.gsub('::', '_')}"
-      end
-
-      def visit object
-        send DISPATCH[object.class], object
-      end
+      alias :visit_NilClass :visit_String
+      alias :visit_ActiveSupport_StringInquirer :visit_String
 
       def quote value, column = nil
         @connection.quote value, column

data/lib/arel/visitors/visitor.rb

@@ -0,0 +1,19 @@
+module Arel
+  module Visitors
+    class Visitor
+      def accept object
+        visit object
+      end
+
+      private
+
+      DISPATCH = Hash.new do |hash, klass|
+        hash[klass] = "visit_#{klass.name.gsub('::', '_')}"
+      end
+
+      def visit object
+        send DISPATCH[object.class], object
+      end
+    end
+  end
+end

data/{spec/attributes/attribute_spec.rb → test/attributes/test_attribute.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'helper'
 
 module Arel
   module Attributes
@@ -6,14 +6,14 @@ module Arel
       describe '#not_eq' do
         it 'should create a NotEqual node' do
           relation = Table.new(:users)
-          relation[:id].not_eq(10).should be_kind_of Nodes::NotEqual
+          relation[:id].not_eq(10).must_be_kind_of Nodes::NotEqual
         end
 
         it 'should generate != in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].not_eq(10)
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" != 10
           }
         end
@@ -22,7 +22,7 @@ module Arel
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].not_eq(nil)
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" IS NOT NULL
           }
         end
@@ -31,14 +31,14 @@ module Arel
       describe '#not_eq_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].not_eq_any([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].not_eq_any([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].not_eq_any([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 OR "users"."id" != 2)
           }
         end
@@ -47,14 +47,14 @@ module Arel
       describe '#not_eq_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].not_eq_all([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].not_eq_all([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].not_eq_all([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 AND "users"."id" != 2)
           }
         end
@@ -63,14 +63,14 @@ module Arel
       describe '#gt' do
         it 'should create a GreaterThan node' do
           relation = Table.new(:users)
-          relation[:id].gt(10).should be_kind_of Nodes::GreaterThan
+          relation[:id].gt(10).must_be_kind_of Nodes::GreaterThan
         end
 
         it 'should generate >= in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].gt(10)
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" > 10
           }
         end
@@ -79,14 +79,14 @@ module Arel
       describe '#gt_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].gt_any([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].gt_any([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].gt_any([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 OR "users"."id" > 2)
           }
         end
@@ -95,14 +95,14 @@ module Arel
       describe '#gt_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].gt_all([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].gt_all([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].gt_all([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 AND "users"."id" > 2)
           }
         end
@@ -111,14 +111,14 @@ module Arel
       describe '#gteq' do
         it 'should create a GreaterThanOrEqual node' do
           relation = Table.new(:users)
-          relation[:id].gteq(10).should be_kind_of Nodes::GreaterThanOrEqual
+          relation[:id].gteq(10).must_be_kind_of Nodes::GreaterThanOrEqual
         end
 
         it 'should generate >= in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].gteq(10)
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" >= 10
           }
         end
@@ -127,14 +127,14 @@ module Arel
       describe '#gteq_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].gteq_any([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].gteq_any([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].gteq_any([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 OR "users"."id" >= 2)
           }
         end
@@ -143,14 +143,14 @@ module Arel
       describe '#gteq_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].gteq_all([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].gteq_all([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].gteq_all([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 AND "users"."id" >= 2)
           }
         end
@@ -159,14 +159,14 @@ module Arel
       describe '#lt' do
         it 'should create a LessThan node' do
           relation = Table.new(:users)
-          relation[:id].lt(10).should be_kind_of Nodes::LessThan
+          relation[:id].lt(10).must_be_kind_of Nodes::LessThan
         end
 
         it 'should generate < in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].lt(10)
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" < 10
           }
         end
@@ -175,14 +175,14 @@ module Arel
       describe '#lt_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].lt_any([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].lt_any([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].lt_any([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 OR "users"."id" < 2)
           }
         end
@@ -191,14 +191,14 @@ module Arel
       describe '#lt_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].lt_all([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].lt_all([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].lt_all([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 AND "users"."id" < 2)
           }
         end
@@ -207,14 +207,14 @@ module Arel
       describe '#lteq' do
         it 'should create a LessThanOrEqual node' do
           relation = Table.new(:users)
-          relation[:id].lteq(10).should be_kind_of Nodes::LessThanOrEqual
+          relation[:id].lteq(10).must_be_kind_of Nodes::LessThanOrEqual
         end
 
         it 'should generate <= in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].lteq(10)
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" <= 10
           }
         end
@@ -223,14 +223,14 @@ module Arel
       describe '#lteq_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].lteq_any([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].lteq_any([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].lteq_any([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 OR "users"."id" <= 2)
           }
         end
@@ -239,14 +239,14 @@ module Arel
       describe '#lteq_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].lteq_all([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].lteq_all([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].lteq_all([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 AND "users"."id" <= 2)
           }
         end
@@ -255,14 +255,14 @@ module Arel
       describe '#average' do
         it 'should create a AVG node' do
           relation = Table.new(:users)
-          relation[:id].average.should be_kind_of Nodes::Avg
+          relation[:id].average.must_be_kind_of Nodes::Avg
         end
 
         # FIXME: backwards compat. Is this really necessary?
         it 'should set the alias to "avg_id"' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id].average
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT AVG("users"."id") AS avg_id
             FROM "users"
           }
@@ -272,14 +272,14 @@ module Arel
       describe '#maximum' do
         it 'should create a MAX node' do
           relation = Table.new(:users)
-          relation[:id].maximum.should be_kind_of Nodes::Max
+          relation[:id].maximum.must_be_kind_of Nodes::Max
         end
 
         # FIXME: backwards compat. Is this really necessary?
         it 'should set the alias to "max_id"' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id].maximum
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT MAX("users"."id") AS max_id
             FROM "users"
           }
@@ -289,21 +289,21 @@ module Arel
       describe '#minimum' do
         it 'should create a Min node' do
           relation = Table.new(:users)
-          relation[:id].minimum.should be_kind_of Nodes::Min
+          relation[:id].minimum.must_be_kind_of Nodes::Min
         end
       end
 
       describe '#sum' do
         it 'should create a SUM node' do
           relation = Table.new(:users)
-          relation[:id].sum.should be_kind_of Nodes::Sum
+          relation[:id].sum.must_be_kind_of Nodes::Sum
         end
 
         # FIXME: backwards compat. Is this really necessary?
         it 'should set the alias to "sum_id"' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id].sum
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT SUM("users"."id") AS sum_id
             FROM "users"
           }
@@ -313,14 +313,14 @@ module Arel
       describe '#count' do
         it 'should return a count node' do
           relation = Table.new(:users)
-          relation[:id].count.should be_kind_of Nodes::Count
+          relation[:id].count.must_be_kind_of Nodes::Count
         end
 
         it 'should take a distinct param' do
           relation = Table.new(:users)
           count = relation[:id].count(nil)
-          count.should be_kind_of Nodes::Count
-          count.distinct.should be_nil
+          count.must_be_kind_of Nodes::Count
+          count.distinct.must_be_nil
         end
       end
 
@@ -328,16 +328,16 @@ module Arel
         it 'should return an equality node' do
           attribute = Attribute.new nil, nil, nil
           equality = attribute.eq 1
-          check equality.left.should == attribute
-          check equality.right.should == 1
-          equality.should be_kind_of Nodes::Equality
+          equality.left.must_equal attribute
+          equality.right.must_equal 1
+          equality.must_be_kind_of Nodes::Equality
         end
 
         it 'should generate = in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].eq(10)
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" = 10
           }
         end
@@ -346,7 +346,7 @@ module Arel
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].eq(nil)
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" IS NULL
           }
         end
@@ -355,14 +355,14 @@ module Arel
       describe '#eq_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].eq_any([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].eq_any([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].eq_any([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 OR "users"."id" = 2)
           }
         end
@@ -371,14 +371,14 @@ module Arel
       describe '#eq_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].eq_all([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].eq_all([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].eq_all([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
           }
         end
@@ -387,14 +387,14 @@ module Arel
       describe '#matches' do
         it 'should create a Matches node' do
           relation = Table.new(:users)
-          relation[:name].matches('%bacon%').should be_kind_of Nodes::Matches
+          relation[:name].matches('%bacon%').must_be_kind_of Nodes::Matches
         end
 
         it 'should generate LIKE in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:name].matches('%bacon%')
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."name" LIKE '%bacon%'
           }
         end
@@ -403,14 +403,14 @@ module Arel
       describe '#matches_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:name].matches_any(['%chunky%','%bacon%']).should be_kind_of Nodes::Grouping
+          relation[:name].matches_any(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:name].matches_any(['%chunky%','%bacon%'])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' OR "users"."name" LIKE '%bacon%')
           }
         end
@@ -419,14 +419,14 @@ module Arel
       describe '#matches_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:name].matches_all(['%chunky%','%bacon%']).should be_kind_of Nodes::Grouping
+          relation[:name].matches_all(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:name].matches_all(['%chunky%','%bacon%'])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' AND "users"."name" LIKE '%bacon%')
           }
         end
@@ -435,14 +435,14 @@ module Arel
       describe '#does_not_match' do
         it 'should create a DoesNotMatch node' do
           relation = Table.new(:users)
-          relation[:name].does_not_match('%bacon%').should be_kind_of Nodes::DoesNotMatch
+          relation[:name].does_not_match('%bacon%').must_be_kind_of Nodes::DoesNotMatch
         end
 
         it 'should generate NOT LIKE in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:name].does_not_match('%bacon%')
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."name" NOT LIKE '%bacon%'
           }
         end
@@ -451,14 +451,14 @@ module Arel
       describe '#does_not_match_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:name].does_not_match_any(['%chunky%','%bacon%']).should be_kind_of Nodes::Grouping
+          relation[:name].does_not_match_any(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:name].does_not_match_any(['%chunky%','%bacon%'])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' OR "users"."name" NOT LIKE '%bacon%')
           }
         end
@@ -467,14 +467,14 @@ module Arel
       describe '#does_not_match_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:name].does_not_match_all(['%chunky%','%bacon%']).should be_kind_of Nodes::Grouping
+          relation[:name].does_not_match_all(['%chunky%','%bacon%']).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:name].does_not_match_all(['%chunky%','%bacon%'])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' AND "users"."name" NOT LIKE '%bacon%')
           }
         end
@@ -487,15 +487,15 @@ module Arel
         it 'should return an in node' do
           attribute = Attribute.new nil, nil, nil
           node = Nodes::In.new attribute, [1,2,3]
-          check node.left.should  == attribute
-          check node.right.should == [1, 2, 3]
+          node.left.must_equal attribute
+          node.right.must_equal [1, 2, 3]
         end
 
         it 'should generate IN in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].in([1,2,3])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" IN (1, 2, 3)
           }
         end
@@ -504,14 +504,14 @@ module Arel
       describe '#in_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].in_any([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].in_any([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].in_any([[1,2], [3,4]])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) OR "users"."id" IN (3, 4))
           }
         end
@@ -520,14 +520,14 @@ module Arel
       describe '#in_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].in_all([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].in_all([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].in_all([[1,2], [3,4]])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) AND "users"."id" IN (3, 4))
           }
         end
@@ -540,15 +540,15 @@ module Arel
         it 'should return a NotIn node' do
           attribute = Attribute.new nil, nil, nil
           node = Nodes::NotIn.new attribute, [1,2,3]
-          check node.left.should  == attribute
-          check node.right.should == [1, 2, 3]
+          node.left.must_equal attribute
+          node.right.must_equal [1, 2, 3]
         end
 
         it 'should generate NOT IN in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].not_in([1,2,3])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE "users"."id" NOT IN (1, 2, 3)
           }
         end
@@ -557,14 +557,14 @@ module Arel
       describe '#not_in_any' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].not_in_any([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].not_in_any([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ORs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].not_in_any([[1,2], [3,4]])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) OR "users"."id" NOT IN (3, 4))
           }
         end
@@ -573,14 +573,14 @@ module Arel
       describe '#not_in_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].not_in_all([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].not_in_all([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].not_in_all([[1,2], [3,4]])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) AND "users"."id" NOT IN (3, 4))
           }
         end
@@ -589,14 +589,14 @@ module Arel
       describe '#eq_all' do
         it 'should create a Grouping node' do
           relation = Table.new(:users)
-          relation[:id].eq_all([1,2]).should be_kind_of Nodes::Grouping
+          relation[:id].eq_all([1,2]).must_be_kind_of Nodes::Grouping
         end
 
         it 'should generate ANDs in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].eq_all([1,2])
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
           }
         end
@@ -605,14 +605,14 @@ module Arel
       describe '#asc' do
         it 'should create an Ordering node' do
           relation = Table.new(:users)
-          relation[:id].asc.should be_kind_of Nodes::Ordering
+          relation[:id].asc.must_be_kind_of Nodes::Ordering
         end
 
         it 'should generate ASC in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.order relation[:id].asc
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" ORDER BY "users"."id" ASC
           }
         end
@@ -621,14 +621,14 @@ module Arel
       describe '#desc' do
         it 'should create an Ordering node' do
           relation = Table.new(:users)
-          relation[:id].desc.should be_kind_of Nodes::Ordering
+          relation[:id].desc.must_be_kind_of Nodes::Ordering
         end
 
         it 'should generate DESC in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.order relation[:id].desc
-          mgr.to_sql.should be_like %{
+          mgr.to_sql.must_be_like %{
             SELECT "users"."id" FROM "users" ORDER BY "users"."id" DESC
           }
         end
@@ -640,7 +640,7 @@ module Arel
         it 'should produce sql' do
           table = Table.new :users
           condition = table['id'].eq 1
-          condition.to_sql.should == '"users"."id" = 1'
+          condition.to_sql.must_equal '"users"."id" = 1'
         end
       end
     end