arel_extensions 1.2.23 → 2.0.0.rc3

data/test/database.yml

@@ -10,8 +10,6 @@ mysql:
   adapter: mysql2
   database: arext_test
   username: travis
-  host: 127.0.0.1
-  port: 3306
   encoding: utf8
 jdbc-mysql:
   adapter: jdbcmysql

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'fileutils'
+require 'arel'
+require 'active_record'
+
+require 'arel_extensions'
+
+require 'support/fake_record'
+Arel::Table.engine = FakeRecord::Base.new
+
+$arel_silence_type_casting_deprecation = true
+
+class Object
+  def must_be_like other
+    gsub(/\s+/, ' ').strip.must_equal other.gsub(/\s+/, ' ').strip
+  end
+end

data/test/real_db_test.rb

@@ -21,15 +21,15 @@ def setup_db
         db.enable_load_extension(0)
       rescue => e
         $load_extension_disabled = true
-        $stderr << "cannot load extensions #{e.inspect}\n"
+        $stderr << "can not load extensions #{e.inspect}\n"
       end
     end
-    # function find_in_set
+    #function find_in_set
     db.create_function("find_in_set", 1) do |func, value1, value2|
       func.result = value1.index(value2)
     end
   end
-  @cnx.drop_table(:users) rescue nil
+  @cnx.drop_table(:users) rescue nil 
   @cnx.create_table :users do |t|
       t.column :age, :integer
       t.column :name, :string
@@ -44,13 +44,15 @@ def teardown_db
 end
 
 class User < ActiveRecord::Base
+
 end
 
 class ListTest < Minitest::Test
+
   def setup
     d = Date.new(2016,05,23)
     setup_db
-    User.create :age => 5, :name => "Lucas", :created_at => d, :score => 20.16
+    User.create :age => 5, :name => "Lucas", :created_at => d , :score => 20.16
     User.create :age => 15, :name => "Sophie", :created_at => d, :score => 20.16
     User.create :age => 20, :name => "Camille", :created_at => d, :score => 20.16
     User.create :age => 21, :name => "Arthur", :created_at => d, :score => 65.62
@@ -88,28 +90,30 @@ class ListTest < Minitest::Test
   end
 
   def test_Comparator
-    assert_equal 2,User.where(User.arel_table[:age] < 6).count
-    assert_equal 2,User.where(User.arel_table[:age] <=10).count
-    assert_equal 3,User.where(User.arel_table[:age] > 20).count
-    assert_equal 4,User.where(User.arel_table[:age] >=20).count
-    assert_equal 1,User.where(User.arel_table[:age] > 5).where(User.arel_table[:age] < 20).count
+    assert_equal 2,User.where(User.arel_table[:age] < 6 ).count
+    assert_equal 2,User.where(User.arel_table[:age] <=10 ).count
+    assert_equal 3,User.where(User.arel_table[:age] > 20 ).count
+    assert_equal 4,User.where(User.arel_table[:age] >=20 ).count
+    assert_equal 1,User.where(User.arel_table[:age] > 5 ).where(User.arel_table[:age] < 20 ).count
   end
 
   def test_date_duration
-    # Year
+    #Year
     assert_equal 2016,User.where(User.arel_table[:name].eq("Lucas")).select((User.arel_table[:created_at].year).as("res")).first.res.to_i
     assert_equal 0,User.where(User.arel_table[:created_at].year.eq("2012")).count
-    # Month
+    #Month
     assert_equal 5,User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:created_at].month).as("res")).first.res.to_i
     assert_equal 8,User.where(User.arel_table[:created_at].month.eq("05")).count
-    # Week
+    #Week
     assert_equal 21,User.where(User.arel_table[:name].eq("Arthur")).select((User.arel_table[:created_at].week).as("res")).first.res.to_i
     assert_equal 8,User.where(User.arel_table[:created_at].month.eq("05")).count
-    # Day
+    #Day
     assert_equal 23,User.where(User.arel_table[:name].eq("Laure")).select((User.arel_table[:created_at].day).as("res")).first.res.to_i
     assert_equal 0,User.where(User.arel_table[:created_at].day.eq("05")).count
   end
 
+
+
   def test_length
     assert_equal 7,User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].length).as("res")).first.res
     assert_equal 5,User.where(User.arel_table[:name].eq("Laure")).select((User.arel_table[:name].length).as("res")).first.res
@@ -132,6 +136,7 @@ class ListTest < Minitest::Test
     end
   end
 
+
   def test_floor
     if !$sqlite || !$load_extension_disabled
       assert_equal 0,User.where(User.arel_table[:name].eq("Negatif")).select((User.arel_table[:score].floor).as("res")).first.res
@@ -139,51 +144,57 @@ class ListTest < Minitest::Test
     end
   end
 
+
   def test_findinset
     db = ActiveRecord::Base.connection.raw_connection
-    assert_equal 3,db.get_first_value("select find_in_set(name,'i') from users where name = 'Camille'")
-    assert_equal "",db.get_first_value("select find_in_set(name,'p') from users where name = 'Camille'").to_s
-    # number
-    # assert_equal 1,User.select(User.arel_table[:name] & ("l")).count
-    # assert_equal 3,(User.select(User.arel_table[:age] & [5,15,20]))
-    # string
+    assert_equal 3,db.get_first_value( "select find_in_set(name,'i') from users where name = 'Camille'" )
+    assert_equal "",db.get_first_value( "select find_in_set(name,'p') from users where name = 'Camille'" ).to_s
+    #number
+    #assert_equal 1,User.select(User.arel_table[:name] & ("l")).count
+    #assert_equal 3,(User.select(User.arel_table[:age] & [5,15,20]))
+    #string
   end
 
+
   def test_math_plus
     d = Date.new(1997,06,15)
-    # Concat String
+    #Concat String
     assert_equal "SophiePhan",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + "Phan").as("res")).first.res
-    assert_equal "Sophie2",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + 2).as("res")).first.res
+    assert_equal "Sophie2",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + 2 ).as("res")).first.res
     assert_equal "Sophie1997-06-15",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + d).as("res")).first.res
     assert_equal "Sophie15",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + User.arel_table[:age]).as("res")).first.res
     assert_equal "SophieSophie",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + User.arel_table[:name]).as("res")).first.res
     assert_equal "Sophie2016-05-23",User.where(User.arel_table[:name].eq("Sophie")).select((User.arel_table[:name] + User.arel_table[:created_at]).as("res")).first.res
-    # concat Integer
+    #concat Integer
     assert_equal 1, User.where((User.arel_table[:age] + 10).eq(33)).count
     assert_equal 1, User.where((User.arel_table[:age] + "1").eq(6)).count
     assert_equal 1, User.where((User.arel_table[:age] + User.arel_table[:age]).eq(10)).count
-    # concat Date
-    #    puts((User.arel_table[:created_at] + 1).as("res").to_sql.inspect)
+    #concat Date
+#    puts((User.arel_table[:created_at] + 1).as("res").to_sql.inspect)
     assert_equal "2016-05-24", @myung.select((User.arel_table[:created_at] + 1).as("res")).first.res.to_date.to_s
     assert_equal "2016-05-25", @myung.select((User.arel_table[:created_at] + 2.day).as("res")).first.res.to_date.to_s
   end
 
+
   def test_math_moins
     d = Date.new(2016,05,20)
-    # Datediff
+    #Datediff
     assert_equal 8,User.where((User.arel_table[:created_at] - User.arel_table[:created_at]).eq(0)).count
     assert_equal 3,User.where(User.arel_table[:name].eq("Laure")).select((User.arel_table[:created_at] - d).as("res")).first.res.abs.to_i
-    # Substraction
+    #Substraction
     assert_equal 0, User.where((User.arel_table[:age] - 10).eq(50)).count
     assert_equal 0, User.where((User.arel_table[:age] - "10").eq(50)).count
   end
 
+
+
   def test_rand
     assert_equal 5,User.where(User.arel_table[:score].eq(20.16)).select(User.arel_table[:id]).order(Arel.rand).take(50).count
-    # test_alias  :random  :rand
+    #test_alias  :random  :rand
     assert_equal 8,User.select(User.arel_table[:name]).order(Arel.rand).take(50).count
   end
 
+
   def test_regexp_not_regex
     if !$sqlite || !$load_extension_disabled
       assert_equal 1, User.where(User.arel_table[:name] =~ '^M').count
@@ -196,11 +207,13 @@ class ListTest < Minitest::Test
     assert_equal "replace",User.where(User.arel_table[:name].eq("Lucas")).select(((User.arel_table[:name]).replace(User.arel_table[:name],"replace")).as("res")).first.res
   end
 
+
   def test_round
     assert_equal 1, User.where(((User.arel_table[:age]).round(0)).eq(5.0)).count
     assert_equal 0, User.where(((User.arel_table[:age]).round(-1)).eq(6.0)).count
   end
 
+
   def test_Soundex
     if !$sqlite || !$load_extension_disabled
       assert_equal "C540",User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].soundex).as("res")).first.res.to_s
@@ -209,13 +222,14 @@ class ListTest < Minitest::Test
   end
 
   def test_Sum
-    # .take(50) because of limit by ORDER BY
+    #.take(50) because of limit by ORDER BY
     assert_equal 110,User.select((User.arel_table[:age].sum + 1).as("res")).take(50).first.res
     assert_equal 218,User.select((User.arel_table[:age].sum + User.arel_table[:age].sum).as("res")).take(50).first.res
     assert_equal 327,User.select(((User.arel_table[:age] * 3).sum).as("res")).take(50).first.res
     assert_equal 2245,User.select(((User.arel_table[:age] * User.arel_table[:age]).sum).as("res")).take(50).first.res
   end
 
+
   def test_trim
     assert_equal "Myun",User.where(User.arel_table[:name].eq("Myung")).select(User.arel_table[:name].rtrim("g").as("res")).first.res
     assert_equal "yung",User.where(User.arel_table[:name].eq("Myung")).select(User.arel_table[:name].ltrim("M").as("res")).first.res
@@ -229,4 +243,5 @@ class ListTest < Minitest::Test
       assert_equal 1,User.where(User.arel_table[:name].eq("Myung")).select((User.arel_table[:created_at].wday).as("res")).first.res.to_i
       assert_equal 0,User.select(d.wday).as("res").first.to_i
   end
+
 end

data/test/support/fake_record.rb

@@ -7,7 +7,7 @@ module FakeRecord
     attr_accessor :visitor
 
     def initialize(visitor = nil)
-      @tables = %w{users photos developers products}
+      @tables = %w{ users photos developers products}
       @columns = {
         'users' => [
           Column.new('id', :integer),
@@ -66,7 +66,7 @@ module FakeRecord
     end
 
     def in_clause_length
-      10000
+      6
     end
 
     def quote thing, column = nil

data/test/test_comparators.rb

@@ -1,8 +1,10 @@
-require 'arelx_test_helper'
+require 'helper'
 
 module ArelExtensions
   module Nodes
+
     describe ArelExtensions::Comparators do
+
       before do
         @conn = FakeRecord::Base.new
         Arel::Table.engine = @conn
@@ -18,25 +20,26 @@ module ArelExtensions
       end
 
       it "< is equal lt" do
-        _(compile(@table[:id] < 10)).must_be_like('"users"."id" < 10')
+        compile(@table[:id] < 10).must_be_like('"users"."id" < 10')
       end
-
+      
       it "<= is equal lteq" do
-        _(compile(@table[:id] <= 10)).must_be_like('"users"."id" <= 10')
+        compile(@table[:id] <= 10).must_be_like('"users"."id" <= 10')
       end
 
       it "> is equal gt" do
-        _(compile(@table[:id] > 10)).must_be_like('"users"."id" > 10')
+        compile(@table[:id] > 10).must_be_like('"users"."id" > 10')
       end
 
       it "< is equal gteq" do
-        _(compile(@table[:id] >= 10)).must_be_like('"users"."id" >= 10')
+        compile(@table[:id] >= 10).must_be_like('"users"."id" >= 10')
       end
 
       it "should compare with dates" do
-        _(compile(@table[:created_at] >= Date.new(2016, 3, 31)))
-          .must_be_like %{"users"."created_at" >= '2016-03-31'}
+        compile(@table[:created_at] >= Date.new(2016, 3, 31)).must_be_like %{"users"."created_at" >= '2016-03-31'}
       end
+
     end
+
   end
-end
+end

data/test/visitors/test_bulk_insert_oracle.rb

@@ -1,4 +1,4 @@
-require 'arelx_test_helper'
+require 'helper'
 
 module ArelExtensions
   module BulkInsertOracle
@@ -9,8 +9,8 @@ module ArelExtensions
         @table = Arel::Table.new(:users)
         @cols = ['name', 'comments', 'created_at']
         @data = [
-          ['nom1', "sdfdsfdsfsdf", '2016-01-01'],
-          ['nom2', "sdfdsfdsfsdf", '2016-01-01']
+        	['nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	['nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
 
@@ -24,11 +24,11 @@ module ArelExtensions
 
       it "should import large set of data in Oracle" do
         insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new().into(@table) : Arel::InsertManager.new(@conn).into(@table)
-        insert_manager.bulk_insert(@cols, @data)
-        _(compile(insert_manager.ast))
-          .must_be_like %Q[INSERT INTO "users" ("name", "comments", "created_at")
-                        ((SELECT 'nom1', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL) UNION ALL (SELECT 'nom2', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL))]
+      	insert_manager.bulk_insert(@cols, @data)
+      	sql = compile(insert_manager.ast)
+      	sql.must_be_like %Q[INSERT INTO "users" ("name", "comments", "created_at") ((SELECT 'nom1', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL) UNION ALL (SELECT 'nom2', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL))]
       end
-    end
+
+	  end
   end
 end

data/test/visitors/test_bulk_insert_sqlite.rb

@@ -1,7 +1,8 @@
-require 'arelx_test_helper'
+require 'helper'
 
 module ArelExtensions
   module BulkInsertSQLlite
+
     describe 'the sqlite visitor can bulk insert' do
       before do
         @conn = FakeRecord::Base.new
@@ -10,11 +11,11 @@ module ArelExtensions
         Arel::Table.engine = @conn
         @cols = ['id', 'name', 'comments', 'created_at']
         @data = [
-          [23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
-          [25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
+        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
-
+      
       def compile node
         if Arel::VERSION.to_i > 5
           @visitor.accept(node, Arel::Collectors::SQLString.new).value
@@ -26,10 +27,10 @@ module ArelExtensions
       it "should import large set of data" do
         insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new().into(@table) : Arel::InsertManager.new(@conn).into(@table)
         insert_manager.bulk_insert(@cols, @data)
-        _(compile(insert_manager.ast))
-          .must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at")
-                         SELECT 23 AS 'id', 'nom1' AS 'name', 'sdfdsfdsfsdf' AS 'comments', '2016-01-01' AS 'created_at' UNION ALL SELECT 25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']
+        sql = compile(insert_manager.ast)
+    	  sql.must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") SELECT 23 AS 'id', 'nom1' AS 'name', 'sdfdsfdsfsdf' AS 'comments', '2016-01-01' AS 'created_at' UNION ALL SELECT 25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']
       end
-    end
+
+	  end
   end
-end
+end

data/test/visitors/test_bulk_insert_to_sql.rb

@@ -1,4 +1,4 @@
-require 'arelx_test_helper'
+require 'helper'
 
 module ArelExtensions
   module BulkInsertToSql
@@ -10,8 +10,8 @@ module ArelExtensions
         @table = Arel::Table.new(:users)
         @cols = ['id', 'name', 'comments', 'created_at']
         @data = [
-          [23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
-          [25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
+        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
 
@@ -26,10 +26,12 @@ module ArelExtensions
 
       it "should import large set of data using ToSql" do
         insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new().into(@table) : Arel::InsertManager.new(@conn).into(@table)
-        insert_manager.bulk_insert(@cols, @data)
-        _(compile(insert_manager.ast))
-          .must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") VALUES (23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'), (25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01')]
+      	insert_manager.bulk_insert(@cols, @data)
+      	sql = compile(insert_manager.ast)
+    	  sql.must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") VALUES (23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'), (25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01')]
       end
-    end
+
+
+	end
   end
-end
+end

data/test/visitors/test_oracle.rb

@@ -1,4 +1,4 @@
-require 'arelx_test_helper'
+require 'helper'
 
 module ArelExtensions
   module VisitorOracle
@@ -23,87 +23,87 @@ module ArelExtensions
       # Comparators
 
       it "should accept comparators on integers" do
-        _(compile(@table[:id] == 42)).must_match %{"users"."id" = 42}
-        _(compile(@table[:id] == @table[:id])).must_be_like %{"users"."id" = "users"."id"}
-        _(compile(@table[:id] != 42)).must_match %{"users"."id" != 42}
-        _(compile(@table[:id] > 42)).must_match %{"users"."id" > 42}
-        _(compile(@table[:id] >= 42)).must_match %{"users"."id" >= 42}
-        _(compile(@table[:id] >= @table[:id])).must_be_like %{"users"."id" >= "users"."id"}
-        _(compile(@table[:id] < 42)).must_match %{"users"."id" < 42}
-        _(compile(@table[:id] <= 42)).must_match %{"users"."id" <= 42}
-        _(compile((@table[:id] <= 42).as('new_name'))).must_match %{("users"."id" <= 42) AS new_name}
+        compile(@table[:id] == 42).must_match %{"users"."id" = 42}
+        compile(@table[:id] == @table[:id]).must_be_like %{"users"."id" = "users"."id"}
+        compile(@table[:id] != 42).must_match %{"users"."id" != 42}
+        compile(@table[:id] > 42).must_match %{"users"."id" > 42}
+        compile(@table[:id] >= 42).must_match %{"users"."id" >= 42}
+        compile(@table[:id] >= @table[:id]).must_be_like %{"users"."id" >= "users"."id"}
+        compile(@table[:id] < 42).must_match %{"users"."id" < 42}
+        compile(@table[:id] <= 42).must_match %{"users"."id" <= 42}
+        compile((@table[:id] <= 42).as('new_name')).must_match %{("users"."id" <= 42) AS new_name}
       end
 
       it "should accept comparators on dates" do
         c = @table[:created_at]
         u = @table[:updated_at]
-        _(compile(c > @date)).must_be_like %{"users"."created_at" > '2016-03-31'}
-        _(compile(u >= @date)).must_be_like %{"users"."updated_at" >= '2016-03-31'}
-        _(compile(c < u)).must_be_like %{"users"."created_at" < "users"."updated_at"}
+        compile(c > @date).must_be_like %{"users"."created_at" > '2016-03-31'}
+        compile(u >= @date).must_be_like %{"users"."updated_at" >= '2016-03-31'}
+        compile(c < u).must_be_like %{"users"."created_at" < "users"."updated_at"}
       end
 
       it "should accept comparators on strings" do
         c = @table[:name]
-        _(compile(c == 'test')).must_be_like %{"users"."name" = 'test'}
-        _(compile(c != 'test')).must_be_like %{"users"."name" != 'test'}
-        _(compile(c > 'test')).must_be_like %{"users"."name" > 'test'}
-        _(compile((c >= 'test').as('new_name'))).must_be_like %{("users"."name" >= 'test') AS new_name}
-        _(compile(c <= @table[:comments])).must_be_like %{"users"."name" <= "users"."comments"}
-        _(compile(c =~ /\Atest\Z/)).must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
-        _(compile(c =~ /\Atest\z/)).must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
-        _(compile(c =~ '^test$')).must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
-        _(compile(c !~ /\Ate\Dst\Z/)).must_be_like %{NOT REGEXP_LIKE("users"."name", '^te[^0-9]st$')}
-        _(compile(c.imatches('%test%'))).must_be_like %{LOWER("users"."name") LIKE LOWER('%test%')}
-        _(compile(c.imatches_any(['%test%', 't2']))).must_be_like %{((LOWER("users"."name") LIKE LOWER('%test%')) OR (LOWER("users"."name") LIKE LOWER('t2')))}
-        _(compile(c.idoes_not_match('%test%'))).must_be_like %{LOWER("users"."name") NOT LIKE LOWER('%test%')}
+        compile(c == 'test').must_be_like %{"users"."name" = 'test'}
+        compile(c != 'test').must_be_like %{"users"."name" != 'test'}
+        compile(c > 'test').must_be_like %{"users"."name" > 'test'}
+        compile((c >= 'test').as('new_name')).must_be_like %{("users"."name" >= 'test') AS new_name}
+        compile(c <= @table[:comments]).must_be_like %{"users"."name" <= "users"."comments"}
+        compile(c =~ /\Atest\Z/).must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
+        compile(c =~ '^test$').must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
+        compile(c !~ /\Ate\Dst\Z/).must_be_like %{NOT REGEXP_LIKE("users"."name", '^te[^0-9]st$')}
+        compile(c.imatches('%test%')).must_be_like %{LOWER("users"."name") LIKE LOWER('%test%')}
+        compile(c.imatches_any(['%test%', 't2'])).must_be_like %{((LOWER("users"."name") LIKE LOWER('%test%')) OR (LOWER("users"."name") LIKE LOWER('t2')))}
+        compile(c.idoes_not_match('%test%')).must_be_like %{LOWER("users"."name") NOT LIKE LOWER('%test%')}
       end
 
       # Maths
       # DateDiff
       it "should diff date col and date" do
-        _(compile(@table[:created_at] - Date.new(2016, 3, 31))).must_match %{"users"."created_at" - TO_DATE('2016-03-31')}
+        compile(@table[:created_at] - Date.new(2016, 3, 31)).must_match %{"users"."created_at" - TO_DATE('2016-03-31')}
       end
 
       it "should diff date col and datetime col" do
-        _(compile(@table[:created_at] - @table[:updated_at])).must_match %{"users"."created_at" - "users"."updated_at"}
+        compile(@table[:created_at] - @table[:updated_at]).must_match %{"users"."created_at" - "users"."updated_at"}
       end
 
       it "should diff date col and datetime col with AS" do
         sql = compile((@table[:updated_at] - @table[:created_at]).as('new_name'))
-        #        sql.must_be_like %{(TO_DATE("users"."updated_at") - "users"."created_at") * 86400 AS new_name}
-        _(sql).must_be_like %{("users"."updated_at" - "users"."created_at") * (CASE WHEN (TRUNC("users"."updated_at", 'DDD') = "users"."updated_at") THEN 1 ELSE 86400 END) AS new_name}
+#        sql.must_be_like %{(TO_DATE("users"."updated_at") - "users"."created_at") * 86400 AS new_name}
+        sql.must_be_like %{("users"."updated_at" - "users"."created_at") * (CASE WHEN (TRUNC("users"."updated_at", 'DDD') = "users"."updated_at") THEN 1 ELSE 86400 END) AS new_name}
       end
 
       it "should diff between time values" do
         d2 = Time.new(2015,6,1)
         d1 = DateTime.new(2015,6,2)
-        _(compile(ArelExtensions::Nodes::DateDiff.new([d1,d2])))
-          .must_match("TO_DATE('2015-06-02') - TO_DATE('2015-06-01')")
+        sql = compile(ArelExtensions::Nodes::DateDiff.new([d1,d2]))
+        sql.must_match("TO_DATE('2015-06-02') - TO_DATE('2015-06-01')")
       end
 
       it "should diff between time values and time col" do
         d1 = DateTime.new(2015,6,2)
-        _(compile(ArelExtensions::Nodes::DateDiff.new([d1, @table[:updated_at]])))
-          .must_match %{TO_DATE('2015-06-02') - "users"."updated_at"}
+        sql = compile(ArelExtensions::Nodes::DateDiff.new([d1, @table[:updated_at]]))
+        sql.must_match %{TO_DATE('2015-06-02') - "users"."updated_at"}
       end
 
       it "should accept operators on dates with numbers" do
         c = @table[:created_at]
-        _(compile(c - 42)).must_be_like %{DATE_SUB("users"."created_at", 42)}
-        _(compile(c - @table[:id])).must_be_like %{DATE_SUB("users"."created_at", "users"."id")}
+        compile(c - 42).must_be_like %{DATE_SUB("users"."created_at", 42)}
+        compile(c - @table[:id]).must_be_like %{DATE_SUB("users"."created_at", "users"."id")}
       end
 
       # Maths on sums
       it "should accept math operators on anything" do
         c = @table[:name]
-        _((c == 'test').to_sql).must_be_like %{"users"."name" = 'test'}
-        _((c != 'test').to_sql).must_be_like %{"users"."name" != 'test'}
-        _((c > 'test').to_sql).must_be_like %{"users"."name" > 'test'}
-        _(compile((c >= 'test').as('new_name'))).must_be_like %{("users"."name" >= 'test') AS new_name}
-        _(compile(c <= @table[:comments])).must_be_like %{"users"."name" <= "users"."comments"}
-        _(compile(c =~ /\Atest\Z/)).must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
-        _(compile(c !~ /\Ate\Dst\Z/)).must_be_like %{NOT REGEXP_LIKE("users"."name", '^te[^0-9]st$')}
+        (c == 'test').to_sql.must_be_like %{"users"."name" = 'test'}
+        (c != 'test').to_sql.must_be_like %{"users"."name" != 'test'}
+        (c > 'test').to_sql.must_be_like %{"users"."name" > 'test'}
+        compile((c >= 'test').as('new_name')).must_be_like %{("users"."name" >= 'test') AS new_name}
+        compile(c <= @table[:comments]).must_be_like %{"users"."name" <= "users"."comments"}
+        compile(c =~ /\Atest\Z/).must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
+        compile(c !~ /\Ate\Dst\Z/).must_be_like %{NOT REGEXP_LIKE("users"."name", '^te[^0-9]st$')}
       end
+
     end
   end
 end