arel_extensions 2.0.21 → 2.2.2

data/test/real_db_test.rb

@@ -8,16 +8,20 @@ require 'arel_extensions'
 def setup_db
   ActiveRecord::Base.configurations = YAML.load_file('test/database.yml')
   ActiveRecord::Base.establish_connection(ENV['DB'].try(:to_sym) || (RUBY_PLATFORM == 'java' ? :"jdbc-sqlite" : :sqlite))
-  ActiveRecord::Base.default_timezone = :utc
+  if ActiveRecord::VERSION::MAJOR >= 7
+    ActiveRecord.default_timezone = :utc
+  else
+    ActiveRecord::Base.default_timezone = :utc
+  end
   @cnx = ActiveRecord::Base.connection
-  if ActiveRecord::Base.connection.adapter_name =~ /sqlite/i
+  if /sqlite/i.match?(ActiveRecord::Base.connection.adapter_name)
     $sqlite = true
     db = @cnx.raw_connection
     if !$load_extension_disabled
       begin
         db.enable_load_extension(1)
-        db.load_extension("/usr/lib/sqlite3/pcre.so")
-        db.load_extension("/usr/lib/sqlite3/extension-functions.so")
+        db.load_extension('/usr/lib/sqlite3/pcre.so')
+        db.load_extension('/usr/lib/sqlite3/extension-functions.so')
         db.enable_load_extension(0)
       rescue => e
         $load_extension_disabled = true
@@ -25,17 +29,18 @@ def setup_db
       end
     end
     # function find_in_set
-    db.create_function("find_in_set", 1) do |func, value1, value2|
+    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.create_table :users do |t|
-      t.column :age, :integer
+    t.column :age, :integer
       t.column :name, :string
       t.column :created_at, :date
       t.column :updated_at, :date
       t.column :score, :decimal
+      t.column :updated_at, :datetime
   end
 end
 
@@ -48,17 +53,18 @@ end
 
 class ListTest < Minitest::Test
   def setup
-    d = Date.new(2016,05,23)
+    d = Date.new(2016, 05, 23)
+    dt = Time.new(2016, 05, 23, 12, 34, 56)
     setup_db
-    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
-    u = User.create :age => 23, :name => "Myung", :created_at => d, :score => 20.16
-    @myung = User.where(:id => u.id)
-    User.create :age => 25, :name => "Laure", :created_at => d, :score =>20.16
-    User.create :age =>nil, :name => "Test", :created_at => d, :score => 1.62
-    User.create :age =>-0, :name => "Negatif", :created_at => d, :score => 0.17
+    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, updated_at: dt
+    u = User.create age: 23, name: 'Myung', created_at: d, score: 20.16
+    @myung = User.where(id: u.id)
+    User.create age: 25, name: 'Laure', created_at: d, score: 20.16
+    User.create age: nil, name: 'Test', created_at: d, score: 1.62
+    User.create age: -0, name: 'Negatif', created_at: d, score: 0.17
   end
 
   def teardown
@@ -66,83 +72,95 @@ class ListTest < Minitest::Test
   end
 
   def test_abs
-    assert_equal 0,User.where(User.arel_table[:name].eq("Negatif")).select((User.arel_table[:age].abs).as("res")).first.res
-    assert_equal 14,User.where(User.arel_table[:name].eq("Laure")).select(((User.arel_table[:age] - 39).abs).as("res")).first.res
+    assert_equal 0, User.where(User.arel_table[:name].eq('Negatif')).select((User.arel_table[:age].abs).as('res')).first.res
+    assert_equal 14, User.where(User.arel_table[:name].eq('Laure')).select(((User.arel_table[:age] - 39).abs).as('res')).first.res
   end
 
   def test_ceil
     if !$sqlite || !$load_extension_disabled
-      assert_equal 1,User.where(User.arel_table[:name].eq("Negatif")).select((User.arel_table[:score].ceil).as("res")).first.res
-      assert_equal 66,User.where(User.arel_table[:name].eq("Arthur")).select((User.arel_table[:score].ceil).as("res")).first.res
+      assert_equal 1, User.where(User.arel_table[:name].eq('Negatif')).select((User.arel_table[:score].ceil).as('res')).first.res
+      assert_equal 66, User.where(User.arel_table[:name].eq('Arthur')).select((User.arel_table[:score].ceil).as('res')).first.res
     end
   end
 
   def test_coalesce
-    if @cnx.adapter_name =~ /pgsql/i
-        assert_equal 100,User.where(User.arel_table[:name].eq("Test")).select((User.arel_table[:age].coalesce(100)).as("res")).first.res
-        assert_equal "Camille",User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].coalesce("Null","default")).as("res")).first.res
+    if /pgsql/i.match?(@cnx.adapter_name)
+      assert_equal 100, User.where(User.arel_table[:name].eq('Test')).select((User.arel_table[:age].coalesce(100)).as('res')).first.res
+        assert_equal 'Camille', User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:name].coalesce('Null', 'default')).as('res')).first.res
     else
-      assert_equal "Camille",User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].coalesce("Null",20)).as("res")).first.res
-      assert_equal 20,User.where(User.arel_table[:name].eq("Test")).select((User.arel_table[:age].coalesce(nil,20)).as("res")).first.res
+      assert_equal 'Camille', User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:name].coalesce('Null', 20)).as('res')).first.res
+      assert_equal 20, User.where(User.arel_table[:name].eq('Test')).select((User.arel_table[:age].coalesce(nil, 20)).as('res')).first.res
     end
   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
+  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
+  end
+
+  def test_date_date_comparator
+    d = Date.new(2016, 05, 24) #after created_at in db
+    assert_equal 8, User.where(User.arel_table[:age] < d).count
+    assert_equal 0, User.where(User.arel_table[:age] > d).count
+    assert_equal 0, User.where(User.arel_table[:age] == d).count
+    d = Date.new(2016, 05, 23)
+    assert_equal 8, User.where(User.arel_table[:age] == d).count
+    dt = Time.new(2016, 05, 23, 12, 35, 00) #after updated_at in db
+    assert_equal 1, User.where(User.arel_table[:update_at] < dt).count
+    assert_equal 0, User.where(User.arel_table[:update_at] > dt).count
   end
 
   def test_date_duration
     # 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
+    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
-    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
+    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
-    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
+    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
-    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
+    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
+    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
   end
 
   def test_locate
     if !$sqlite || !$load_extension_disabled
-      assert_equal 1, User.where(User.arel_table[:name].eq("Camille")).select((User.arel_table[:name].locate("C")).as("res")).first.res
-      assert_equal 0, User.where(User.arel_table[:name].eq("Lucas")).select((User.arel_table[:name].locate("z")).as("res")).first.res
-      assert_equal 5, User.where(User.arel_table[:name].eq("Lucas")).select((User.arel_table[:name].locate("s")).as("res")).first.res
+      assert_equal 1, User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:name].locate('C')).as('res')).first.res
+      assert_equal 0, User.where(User.arel_table[:name].eq('Lucas')).select((User.arel_table[:name].locate('z')).as('res')).first.res
+      assert_equal 5, User.where(User.arel_table[:name].eq('Lucas')).select((User.arel_table[:name].locate('s')).as('res')).first.res
     end
   end
 
   def test_isnull
-    if ActiveRecord::Base.connection.adapter_name =~ /pgsql/i
-      assert_equal 100,User.where(User.arel_table[:name].eq("Test")).select((User.arel_table[:age].isnull(100)).as("res")).first.res
+    if /pgsql/i.match?(ActiveRecord::Base.connection.adapter_name)
+      assert_equal 100, User.where(User.arel_table[:name].eq('Test')).select((User.arel_table[:age].isnull(100)).as('res')).first.res
     else
-      assert_equal "default",User.where(User.arel_table[:name].eq("Test")).select((User.arel_table[:age].isnull('default')).as("res")).first.res
-      assert_equal "Test",User.where((User.arel_table[:age].isnull('default')).eq('default')).select(User.arel_table[:name]).first.name.to_s
+      assert_equal 'default', User.where(User.arel_table[:name].eq('Test')).select((User.arel_table[:age].isnull('default')).as('res')).first.res
+      assert_equal 'Test', User.where((User.arel_table[:age].isnull('default')).eq('default')).select(User.arel_table[:name]).first.name.to_s
     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
-      assert_equal 65,User.where(User.arel_table[:name].eq("Arthur")).select((User.arel_table[:score].floor).as("res")).first.res
+      assert_equal 0, User.where(User.arel_table[:name].eq('Negatif')).select((User.arel_table[:score].floor).as('res')).first.res
+      assert_equal 65, User.where(User.arel_table[:name].eq('Arthur')).select((User.arel_table[:score].floor).as('res')).first.res
     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
+    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]))
@@ -150,38 +168,38 @@ class ListTest < Minitest::Test
   end
 
   def test_math_plus
-    d = Date.new(1997,06,15)
+    d = Date.new(1997, 06, 15)
     # 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 "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
+    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 '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
     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] + '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)
-    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
+    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)
+    d = Date.new(2016, 05, 20)
     # 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
+    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
     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
+    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
+    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
-    assert_equal 8,User.select(User.arel_table[:name]).order(Arel.rand).take(50).count
+    assert_equal 8, User.select(User.arel_table[:name]).order(Arel.rand).take(50).count
   end
 
   def test_regexp_not_regex
@@ -192,8 +210,8 @@ class ListTest < Minitest::Test
   end
 
   def test_replace
-    assert_equal "LucaX",User.where(User.arel_table[:name].eq("Lucas")).select(((User.arel_table[:name]).replace("s","X")).as("res")).first.res
-    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
+    assert_equal 'LucaX', User.where(User.arel_table[:name].eq('Lucas')).select((User.arel_table[:name].replace('s', 'X')).as('res')).first.res
+    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
@@ -203,30 +221,30 @@ class ListTest < Minitest::Test
 
   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
-      assert_equal 8,User.where((User.arel_table[:name].soundex).eq(User.arel_table[:name].soundex)).count
+      assert_equal 'C540', User.where(User.arel_table[:name].eq('Camille')).select((User.arel_table[:name].soundex).as('res')).first.res.to_s
+      assert_equal 8, User.where((User.arel_table[:name].soundex).eq(User.arel_table[:name].soundex)).count
     end
   end
 
   def test_Sum
     # .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
+    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
-    assert_equal "yung",User.where(User.arel_table[:name].eq("Myung")).select((User.arel_table[:name] + "M").trim("M").as("res")).first.res
-    assert_equal "",User.where(User.arel_table[:name].eq("Myung")).select(User.arel_table[:name].rtrim(User.arel_table[:name]).as("res")).first.res
+    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
+    assert_equal 'yung', User.where(User.arel_table[:name].eq('Myung')).select((User.arel_table[:name] + 'M').trim('M').as('res')).first.res
+    assert_equal '', User.where(User.arel_table[:name].eq('Myung')).select(User.arel_table[:name].rtrim(User.arel_table[:name]).as('res')).first.res
 
   end
 
   def test_wday
-      d = Date.new(2016,06,26)
-      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
+    d = Date.new(2016, 06, 26)
+      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

@@ -66,7 +66,7 @@ module FakeRecord
     end
 
     def in_clause_length
-      10000
+      10_000
     end
 
     def quote thing, column = nil
@@ -105,7 +105,7 @@ module FakeRecord
     attr_reader :spec, :connection
 
     def initialize
-      @spec = Spec.new(:adapter => 'america')
+      @spec = Spec.new({adapter: 'america'})
       @connection = Connection.new
       @connection.visitor = Arel::Visitors::ToSql.new(connection)
     end
@@ -145,5 +145,11 @@ module FakeRecord
     def connection
       connection_pool.connection
     end
+
+    if ActiveRecord.version >= Gem::Version.create('7.2')
+      def with_connection(*args, **kwargs, &block)
+        connection_pool.with_connection(*args, **kwargs, &block)
+      end
+    end
   end
 end

data/test/test_comparators.rb

@@ -17,23 +17,23 @@ module ArelExtensions
         @visitor.accept(node, Arel::Collectors::SQLString.new).value
       end
 
-      it "< is equal lt" do
+      it '< is equal lt' do
         _(compile(@table[:id] < 10)).must_be_like('"users"."id" < 10')
       end
 
-      it "<= is equal lteq" do
+      it '<= is equal lteq' do
         _(compile(@table[:id] <= 10)).must_be_like('"users"."id" <= 10')
       end
 
-      it "> is equal gt" do
+      it '> is equal gt' do
         _(compile(@table[:id] > 10)).must_be_like('"users"."id" > 10')
       end
 
-      it "< is equal gteq" do
+      it '< is equal gteq' do
         _(compile(@table[:id] >= 10)).must_be_like('"users"."id" >= 10')
       end
 
-      it "should compare with dates" do
+      it 'should compare with dates' do
         _(compile(@table[:created_at] >= Date.new(2016, 3, 31)))
           .must_be_like %{"users"."created_at" >= '2016-03-31'}
       end

data/test/visitors/test_bulk_insert_oracle.rb

@@ -7,10 +7,10 @@ module ArelExtensions
         @conn = FakeRecord::Base.new
         @visitor = Arel::Visitors::Oracle.new @conn.connection
         @table = Arel::Table.new(:users)
-        @cols = ['name', 'comments', 'created_at']
+        @cols = %w[name comments created_at]
         @data = [
-          ['nom1', "sdfdsfdsfsdf", '2016-01-01'],
-          ['nom2', "sdfdsfdsfsdf", '2016-01-01']
+          %w[nom1 sdfdsfdsfsdf 2016-01-01],
+          %w[nom2 sdfdsfdsfsdf 2016-01-01]
         ]
       end
 
@@ -22,8 +22,8 @@ module ArelExtensions
         end
       end
 
-      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)
+      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")

data/test/visitors/test_bulk_insert_sqlite.rb

@@ -8,10 +8,10 @@ module ArelExtensions
         @visitor = Arel::Visitors::SQLite.new @conn.connection
         @table = Arel::Table.new(:users)
         Arel::Table.engine = @conn
-        @cols = ['id', 'name', 'comments', 'created_at']
+        @cols = %w[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
 
@@ -23,8 +23,8 @@ module ArelExtensions
         end
       end
 
-      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)
+      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")

data/test/visitors/test_bulk_insert_to_sql.rb

@@ -8,10 +8,10 @@ module ArelExtensions
         Arel::Table.engine = @conn
         @visitor = Arel::Visitors::ToSql.new @conn.connection
         @table = Arel::Table.new(:users)
-        @cols = ['id', 'name', 'comments', 'created_at']
+        @cols = %w[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
 
@@ -24,8 +24,8 @@ module ArelExtensions
       end
 
 
-      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)
+      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')]

data/test/visitors/test_oracle.rb

@@ -22,7 +22,7 @@ module ArelExtensions
 
       # Comparators
 
-      it "should accept comparators on integers" do
+      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}
@@ -34,7 +34,7 @@ module ArelExtensions
         _(compile((@table[:id] <= 42).as('new_name'))).must_match %{("users"."id" <= 42) AS new_name}
       end
 
-      it "should accept comparators on dates" do
+      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'}
@@ -42,7 +42,7 @@ module ArelExtensions
         _(compile(c < u)).must_be_like %{"users"."created_at" < "users"."updated_at"}
       end
 
-      it "should accept comparators on strings" do
+      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'}
@@ -60,41 +60,41 @@ module ArelExtensions
 
       # Maths
       # DateDiff
-      it "should diff date col and date" do
+      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')}
       end
 
-      it "should diff date col and datetime col" do
+      it 'should diff date col and datetime col' do
         _(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
+      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}
       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])))
+      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')")
       end
 
-      it "should diff between time values and time col" do
-        d1 = DateTime.new(2015,6,2)
+      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"}
       end
 
-      it "should accept operators on dates with numbers" do
+      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")}
       end
 
       # Maths on sums
-      it "should accept math operators on anything" do
+      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'}