arel_extensions 2.1.3 → 2.1.4

data/lib/arel_extensions/visitors.rb

@@ -32,9 +32,9 @@ if defined?(Arel::Visitors::MSSQL)
       else
         collector = visit o.left, collector
       end
-      collector << " AS ["
+      collector << ' AS ['
       collector = visit o.right, collector
-      collector << "]"
+      collector << ']'
       collector
     end
 
@@ -44,7 +44,7 @@ if defined?(Arel::Visitors::MSSQL)
         o = o.dup
         o.orders = []
       end
-      old_visit_Arel_Nodes_SelectStatement(o,collector)
+      old_visit_Arel_Nodes_SelectStatement(o, collector)
     end
   end
 
@@ -61,7 +61,7 @@ if defined?(Arel::Visitors::MSSQL)
               o = o.dup
               o.orders = []
             end
-            old_visit_Arel_Nodes_SelectStatement(o,collector)
+            old_visit_Arel_Nodes_SelectStatement(o, collector)
           end
 
           alias_method(:old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As) rescue nil
@@ -73,9 +73,9 @@ if defined?(Arel::Visitors::MSSQL)
             else
               collector = visit o.left, collector
             end
-            collector << " AS ["
+            collector << ' AS ['
             collector = visit o.right, collector
-            collector << "]"
+            collector << ']'
             collector
           end
 
@@ -92,6 +92,6 @@ if defined?(Arel::Visitors::MSSQL)
     end
   rescue LoadError
   rescue => e
-      e
+    e
   end
 end

data/lib/arel_extensions.rb

@@ -16,7 +16,7 @@ class Arel::Nodes::Casted
   include Arel::AliasPredication
 
   # They forget to define hash.
-  if Gem::Version.new(Arel::VERSION) < Gem::Version.new("10.0.0")
+  if Gem::Version.new(Arel::VERSION) < Gem::Version.new('10.0.0')
     def hash
       [self.class, self.val, self.attribute].hash
     end
@@ -44,13 +44,14 @@ class Arel::Nodes::Function
   include Arel::Expressions
 end
 
-if Gem::Version.new(Arel::VERSION) >= Gem::Version.new("7.1.0")
+if Gem::Version.new(Arel::VERSION) >= Gem::Version.new('7.1.0')
   class Arel::Nodes::Case
     include Arel::Math
     include Arel::Expressions
   end
 end
 
+require 'arel_extensions/helpers'
 require 'arel_extensions/version'
 require 'arel_extensions/aliases'
 require 'arel_extensions/attributes'
@@ -90,12 +91,21 @@ if defined?(Arel::Visitors::SQLServer)
 end
 
 module Arel
-  def self.rand
-    ArelExtensions::Nodes::Rand.new
+  def self.column_of table_name, column_name
+    ArelExtensions.column_of(table_name, column_name)
   end
 
-  def self.shorten s
-    Base64.urlsafe_encode64(Digest::MD5.new.digest(s)).tr('=', '').tr('-', '_')
+  def self.duration s, expr
+    ArelExtensions::Nodes::Duration.new("#{s}i", expr)
+  end
+
+  # The FALSE pseudo literal.
+  def self.false
+    Arel::Nodes::Equality.new(1, 0)
+  end
+
+  def self.grouping *v
+    Arel::Nodes::Grouping.new(*v)
   end
 
   def self.json *expr
@@ -108,16 +118,21 @@ module Arel
     )
   end
 
-  def self.when condition
-    ArelExtensions::Nodes::Case.new.when(condition)
+  # The NULL literal.
+  def self.null
+    Arel.quoted(nil)
   end
 
-  def self.duration s, expr
-    ArelExtensions::Nodes::Duration.new("#{s}i", expr)
+  def self.quoted *args
+    Arel::Nodes.build_quoted(*args)
   end
 
-  def self.grouping *v
-    Arel::Nodes::Grouping.new(*v)
+  def self.rand
+    ArelExtensions::Nodes::Rand.new
+  end
+
+  def self.shorten s
+    Base64.urlsafe_encode64(Digest::MD5.new.digest(s)).tr('=', '').tr('-', '_')
   end
 
   # The TRUE pseudo literal.
@@ -125,20 +140,19 @@ module Arel
     Arel::Nodes::Equality.new(1, 1)
   end
 
-  # The FALSE pseudo literal.
-  def self.false
-    Arel::Nodes::Equality.new(1, 0)
-  end
-
-  # The NULL literal.
-  def self.null
-    Arel::Nodes.build_quoted(nil)
-  end
-
   def self.tuple *v
     tmp = Arel.grouping(nil)
     Arel.grouping v.map{|e| tmp.convert_to_node(e)}
   end
+
+  # For instance
+  #
+  # ```
+  # Arel.when(at[field].is_null).then(0).else(1)
+  # ```
+  def self.when condition
+    ArelExtensions::Nodes::Case.new.when(condition)
+  end
 end
 
 class Arel::Attributes::Attribute
@@ -160,7 +174,7 @@ class Arel::Nodes::Function
   alias_method(:old_as, :as) rescue nil
   def as other
     res = Arel::Nodes::As.new(self.clone, Arel.sql(other))
-    if Gem::Version.new(Arel::VERSION) >= Gem::Version.new("9.0.0")
+    if Gem::Version.new(Arel::VERSION) >= Gem::Version.new('9.0.0')
       self.alias = Arel.sql(other)
     end
     res
@@ -168,13 +182,13 @@ class Arel::Nodes::Function
 end
 
 class Arel::Nodes::Grouping
-    include ArelExtensions::Math
-    include ArelExtensions::Comparators
-    include ArelExtensions::DateDuration
-    include ArelExtensions::MathFunctions
-    include ArelExtensions::NullFunctions
-    include ArelExtensions::StringFunctions
-    include ArelExtensions::Predications
+  include ArelExtensions::Math
+  include ArelExtensions::Comparators
+  include ArelExtensions::DateDuration
+  include ArelExtensions::MathFunctions
+  include ArelExtensions::NullFunctions
+  include ArelExtensions::StringFunctions
+  include ArelExtensions::Predications
 end
 
 class Arel::Nodes::Unary
@@ -248,9 +262,9 @@ class Arel::Nodes::TableAlias
   def method_missing(*args)
     met = args.shift.to_sym
     if self.relation.respond_to?(met)
-      self.relation.send(met,args)
+      self.relation.send(met, args)
     else
-      super(met,*args)
+      super(met, *args)
     end
   end
 end

data/test/arelx_test_helper.rb

@@ -7,10 +7,10 @@ require 'active_record'
 require 'support/fake_record'
 
 def colored(color, msg)
-  ENV["TERM"] =~ /^xterm|-256color$/ ? "\x1b[#{color}m#{msg}\x1b[89m\x1b[0m"  : "#{msg}"
+  ENV['TERM'] =~ /^xterm|-256color$/ ? "\x1b[#{color}m#{msg}\x1b[89m\x1b[0m" : "#{msg}"
 end
 
-YELLOW = "33"
+YELLOW = '33'
 
 def warn(msg)
   $stderr.puts(colored(YELLOW, msg))
@@ -26,17 +26,18 @@ end
 #     The issue also seems to be related to arel version: at some point, arel
 #     dropped its wide support for DBs and kept Postgres, MySQL and SQLite.
 #     Here, we're just trying to load the correct ones.
-db_and_gem =  if RUBY_ENGINE == 'jruby'
-                {
-                  'oracle'     => 'activerecord-oracle_enhanced-adapter',
-                  'mssql'      => 'activerecord-jdbcsqlserver-adapter'
-                }
-              else
-                {
-                  'oracle'     => 'activerecord-oracle_enhanced-adapter',
-                  'mssql'      => 'activerecord-sqlserver-adapter'
-                }
-              end
+db_and_gem =
+  if RUBY_ENGINE == 'jruby'
+    {
+      'oracle'     => 'activerecord-oracle_enhanced-adapter',
+      'mssql'      => 'activerecord-jdbcsqlserver-adapter'
+    }
+  else
+    {
+      'oracle'     => 'activerecord-oracle_enhanced-adapter',
+      'mssql'      => 'activerecord-sqlserver-adapter'
+    }
+  end
 
 def load_lib(gem)
   if gem && (RUBY_ENGINE == 'jruby' || Arel::VERSION.to_i > 9)

data/test/database.yml

@@ -8,26 +8,26 @@ jdbc-sqlite:
   timeout: 500
 mysql:
   adapter: mysql2
-  database: arext_test
+  database: arelx_test
   username: root
   host: 127.0.0.1
   port: 3306
   encoding: utf8
 jdbc-mysql:
   adapter: jdbcmysql
-  database: arext_test
+  database: arelx_test
   username: root
   encoding: utf8
 postgresql:
   adapter: postgresql
-  database: arext_test
+  database: arelx_test
   username: postgres
   password: secret
   host: 127.0.0.1
   port: 5432
 jdbc-postgresql:
   adapter: jdbcpostgresql
-  database: arext_test
+  database: arelx_test
   username: postgres
   password: secret
   host: 127.0.0.1
@@ -45,7 +45,7 @@ jdbc-oracle:
 ibm_db:
   adapter:  ibm_db
   username: travis
-  database: arext_test
+  database: arelx_test
 mssql:
   adapter: sqlserver
   host: localhost

data/test/real_db_test.rb

@@ -20,8 +20,8 @@ def setup_db
     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
@@ -29,13 +29,13 @@ 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
@@ -52,17 +52,17 @@ end
 
 class ListTest < Minitest::Test
   def setup
-    d = Date.new(2016,05,23)
+    d = Date.new(2016, 05, 23)
     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
+    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
@@ -70,83 +70,83 @@ 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
+      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
+    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
-    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
+      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]))
@@ -154,38 +154,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
@@ -196,8 +196,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
@@ -207,30 +207,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

@@ -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

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

@@ -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
 
@@ -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")