arel_extensions 2.4.0 → 2.5.0

data/lib/arel_extensions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'arel'
 require 'arel_extensions/constants'
 require 'base64'
@@ -20,7 +22,7 @@ class Arel::Nodes::Casted
   # They forget to define hash.
   if ArelExtensions::AREL_VERSION < ArelExtensions::V10
     def hash
-      [self.class, self.val, self.attribute].hash
+      [self.class, val, attribute].hash
     end
   end
 end
@@ -36,8 +38,8 @@ class Arel::Nodes::Grouping
 end
 
 class Arel::Nodes::Ordering
-  def eql? other
-    self.hash.eql? other.hash
+  def eql?(other)
+    hash.eql? other.hash
   end
 end
 
@@ -88,7 +90,7 @@ require 'arel_extensions/nodes/select'
 # adapter behave differently. It doesn't always proc, so we added this for
 # coverage.
 if defined?(Arel::Visitors::SQLServer)
-  Arel::Visitors.const_set('MSSQL', Arel::Visitors::SQLServer)
+  Arel::Visitors.const_set(:MSSQL, Arel::Visitors::SQLServer)
   require 'arel_extensions/visitors/mssql'
   class Arel::Visitors::SQLServer
     include ArelExtensions::Visitors::MSSQL
@@ -96,11 +98,11 @@ if defined?(Arel::Visitors::SQLServer)
 end
 
 module Arel
-  def self.column_of table_name, column_name
+  def self.column_of(table_name, column_name)
     ArelExtensions.column_of(table_name, column_name)
   end
 
-  def self.duration s, expr
+  def self.duration(s, expr)
     ArelExtensions::Nodes::Duration.new("#{s}i", expr)
   end
 
@@ -109,11 +111,11 @@ module Arel
     Arel::Nodes::Equality.new(1, 0)
   end
 
-  def self.grouping *v
+  def self.grouping(*v)
     Arel::Nodes::Grouping.new(*v)
   end
 
-  def self.json *expr
+  def self.json(*expr)
     ArelExtensions::Nodes::Json.new(
       if expr.length == 1
         expr.first
@@ -148,7 +150,7 @@ module Arel
     Arel.quoted(nil)
   end
 
-  def self.quoted *args
+  def self.quoted(*args)
     Arel::Nodes.build_quoted(*args)
   end
 
@@ -160,7 +162,7 @@ module Arel
     Arel::Nodes::RollUp.new(args)
   end
 
-  def self.shorten s
+  def self.shorten(s)
     Base64.urlsafe_encode64(Digest::MD5.new.digest(s)).tr('=', '').tr('-', '_')
   end
 
@@ -169,9 +171,9 @@ module Arel
     Arel::Nodes::Equality.new(1, 1)
   end
 
-  def self.tuple *v
+  def self.tuple(*v)
     tmp = Arel.grouping(nil)
-    Arel.grouping v.map{|e| tmp.convert_to_node(e)}
+    Arel.grouping(v.map { |e| tmp.convert_to_node(e) })
   end
 
   # For instance
@@ -179,7 +181,7 @@ module Arel
   # ```
   # Arel.when(at[field].is_null).then(0).else(1)
   # ```
-  def self.when condition
+  def self.when(condition)
     ArelExtensions::Nodes::Case.new.when(condition)
   end
 end
@@ -202,7 +204,7 @@ class Arel::Nodes::Function
 
   if ArelExtensions::ACTIVE_RECORD_VERSION >= ArelExtensions::V8_1
     attr_accessor :alias
-    alias_method :old_initialize, :initialize
+    alias old_initialize initialize
 
     def initialize(expr, aliaz = nil)
       old_initialize(expr)
@@ -210,9 +212,9 @@ class Arel::Nodes::Function
     end
   end
 
-  alias_method(:old_as, :as) rescue nil
-  def as other
-    res = Arel::Nodes::As.new(self.clone, Arel.sql(other))
+  alias old_as as rescue nil
+  def as(other)
+    res = Arel::Nodes::As.new(clone, Arel.sql(other))
     self.alias = Arel.sql(other)
     res
   end
@@ -234,7 +236,8 @@ class Arel::Nodes::Unary
   include ArelExtensions::MathFunctions
   include ArelExtensions::Comparators
   include ArelExtensions::Predications
-  def eql? other
+
+  def eql?(other)
     hash == other.hash
   end
 end
@@ -246,7 +249,8 @@ class Arel::Nodes::Binary
   include ArelExtensions::Comparators
   include ArelExtensions::BooleanFunctions
   include ArelExtensions::Predications
-  def eql? other
+
+  def eql?(other)
     hash == other.hash
   end
 end
@@ -267,12 +271,12 @@ class Arel::SelectManager
   include ArelExtensions::Nodes
 
   remove_method(:as) if method_defined?(:as)
-  def as table_name
+  def as(table_name)
     Arel::Nodes::TableAlias.new(self, table_name)
   end
 
   # Install an alias, if present.
-  def xas table_name
+  def xas(table_name)
     if table_name.present?
       as table_name
     else
@@ -286,12 +290,12 @@ class Arel::Nodes::As
 end
 
 class Arel::Table
-  alias_method(:old_alias, :alias) rescue nil
+  alias old_alias alias rescue nil
 
   # activerecord 7.1 removed the alias. We might need to remove our dependency
   # on the alias if it proves problematic.
-  if !self.respond_to?(:table_name)
-    alias :table_name :name
+  if !respond_to?(:table_name)
+    alias table_name name
   end
 
   def alias(name = "#{self.name}_2")
@@ -306,14 +310,17 @@ end
 class Arel::Nodes::TableAlias
   def method_missing(*args)
     met = args.shift.to_sym
-    if self.relation.respond_to?(met)
-      self.relation.send(met, args)
+    if relation.respond_to?(met)
+      relation.send(met, args)
     else
       super(met, *args)
     end
   end
-end
 
+  def respond_to_missing?(method_name, include_private = false)
+    relation.respond_to?(method_name) || super
+  end
+end
 
 class Arel::Attributes::Attribute
   def to_sql(engine = Arel::Table.engine)

data/test/real_db_test.rb

@@ -72,24 +72,24 @@ 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 /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
+      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
 
@@ -115,45 +115,45 @@ class ListTest < Minitest::Test
 
   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 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 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 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 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 /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
+      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
 
@@ -210,19 +210,19 @@ 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
-    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
+    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
-      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
 
@@ -230,8 +230,8 @@ class ListTest < Minitest::Test
     # .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 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
@@ -244,7 +244,7 @@ class ListTest < Minitest::Test
 
   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 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/visitors/test_to_sql.rb

@@ -277,11 +277,11 @@ module ArelExtensions
           .must_be_like %{(SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users")}
         _(c.union_all(c.union_all(c)).to_sql)
           .must_be_like %{(SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users")}
-        _((c.union_all(c)).union_all(c).to_sql)
+        _(c.union_all(c).union_all(c).to_sql)
           .must_be_like %{(SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users")}
         _(c.union_all(c).union_all(c).to_sql)
           .must_be_like %{(SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users")}
-        _((c.union_all(c)).as('union_table').to_sql)
+        _(c.union_all(c).as('union_table').to_sql)
           .must_be_like %{((SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users")) union_table}
       end
 

data/test/with_ar/all_agnostic_test.rb

@@ -52,6 +52,7 @@ module ArelExtensions
           t.column :duration, :time
           t.column :other, :string
           t.column :score, :decimal, precision: 20, scale: 10
+          t.column :enabled, :boolean
         end
         @cnx.drop_table(:product_tests) rescue nil
         @cnx.create_table :product_tests do |t|
@@ -74,9 +75,9 @@ module ArelExtensions
         @lucas = User.where(id: u.id)
         u = User.create age: 15, name: 'Sophie', created_at: d, score: 20.16
         @sophie = User.where(id: u.id)
-        u = User.create age: 20, name: 'Camille', created_at: d, score: -20.16, comments: ''
+        u = User.create age: 20, name: 'Camille', created_at: d, score: -20.16, comments: '', enabled: false
         @camille = User.where(id: u.id)
-        u = User.create age: 21, name: 'Arthur', created_at: d, score: 65.62, comments: 'arrêté'
+        u = User.create age: 21, name: 'Arthur', created_at: d, score: 65.62, comments: 'arrêté', enabled: true
         @arthur = User.where(id: u.id)
         u = User.create age: 23, name: 'Myung', created_at: d, score: 20.16, comments: ' '
         @myung = User.where(id: u.id)
@@ -107,6 +108,7 @@ module ArelExtensions
         @duration = User.arel_table[:duration]
         @price = Product.arel_table[:price]
         @other = User.arel_table[:other]
+        @enabled = User.arel_table[:enabled]
         @not_in_table = User.arel_table[:not_in_table]
 
         @ut = User.arel_table
@@ -190,13 +192,13 @@ module ArelExtensions
           skip 'SQL Server forces order?' # TODO
           assert_equal 83, User.select((@age.sum + 1).as('res'), User.arel_table[:id].sum).take(50).reorder(@age).first.res
           assert_equal 164, User.reorder(nil).select((@age.sum + @age.sum).as('res'), User.arel_table[:id].sum).take(50).first.res
-          assert_equal 246, User.reorder(nil).select(((@age * 3).sum).as('res'), User.arel_table[:id].sum).take(50).first.res
-          assert_equal 4234, User.reorder(nil).select(((@age * @age).sum).as('res'), User.arel_table[:id].sum).take(50).first.res
+          assert_equal 246, User.reorder(nil).select((@age * 3).sum.as('res'), User.arel_table[:id].sum).take(50).first.res
+          assert_equal 4234, User.reorder(nil).select((@age * @age).sum.as('res'), User.arel_table[:id].sum).take(50).first.res
         else
           assert_equal 83, User.select((@age.sum + 1).as('res')).take(50).first.res
           assert_equal 164, User.select((@age.sum + @age.sum).as('res')).take(50).first.res
           assert_equal 246, User.select((@age * 3).sum.as('res')).take(50).first.res
-          assert_equal 4234, User.select(((@age * @age).sum).as('res')).take(50).first.res
+          assert_equal 4234, User.select((@age * @age).sum.as('res')).take(50).first.res
         end
       end
 
@@ -213,7 +215,7 @@ module ArelExtensions
       end
 
       def test_rollup
-        skip "sqlite not supported" if $sqlite
+        skip 'sqlite not supported' if $sqlite
         at = User.arel_table
         # single
         q = User.select(at[:name], at[:age].sum).group(Arel::Nodes::RollUp.new([at[:name]]))
@@ -260,8 +262,9 @@ module ArelExtensions
         assert_equal 'Camille Camille', t(@camille, @name + ' ' + @name)
         assert_equal 'Laure 2', t(@laure, @name + ' ' + 2)
         assert_equal 'Test Laure', t(@laure, Arel.quoted('Test ') + @name)
+      end
 
-        skip 'No group_concat in SqlServer before 2017' if @env_db == 'mssql'
+      def test_group_concat
         assert_equal 'Lucas Sophie', t(User.where(name: %w[Lucas Sophie]), @name.group_concat(' '))
         assert_equal 'Lucas,Sophie', t(User.where(name: %w[Lucas Sophie]), @name.group_concat(','))
         assert_equal 'Lucas,Sophie', t(User.where(name: %w[Lucas Sophie]), @name.group_concat)
@@ -298,6 +301,7 @@ module ArelExtensions
         skip "Sqlite can't do md5" if $sqlite
         assert_equal 'e2cf99ca82a7e829d2a4ac85c48154d0', t(@camille, @name.md5)
         assert_equal 'c3d41bf5efb468a1bcce53bd53726c85', t(@lucas, @name.md5)
+        assert_equal '6eb6a030bcce166534b95bc2ab45d9cf', t(@lucas, Arel.quoted('a' * 50).md5)
       end
 
       def test_locate
@@ -323,14 +327,96 @@ module ArelExtensions
         else
           assert_equal('', t(@lucas, @name[42]))
         end
-        assert_equal 'Lu', t(@lucas, @name[0, 2])
-        assert_equal 'Lu', t(@lucas, @name[0..1])
 
         # substring should accept string function
         assert_equal 'Ce', t(@camille, @name.substring(1, 1).concat('e'))
         assert_equal 'Ce', t(@camille, @name.substring(1, 1) + 'e')
       end
 
+      def assert_substring(expected, scope, node)
+        expected = nil if expected == '' && @env_db == 'oracle'
+        actual = t(scope, node)
+        # Ruby 3.0+ requires assert_nil
+        expected.nil? ? assert_nil(actual) : assert_equal(expected, actual)
+      end
+
+      def test_substring_range
+        # exclusive end
+        assert_substring 'uc', @lucas, @name[1...3]
+        assert_substring 'uca', @lucas, @name[1...-1]
+
+        # boundary: begin exactly at length is valid (empty result),
+        # begin one past length is out of range (nil)
+        assert_substring '', @lucas, @name[5..6]
+        assert_substring nil, @lucas, @name[6..7]
+        assert_substring nil, @lucas, @name[100..200]
+        assert_substring nil, @lucas, @name[-100..-1]
+
+        # reversed / empty-result ranges, same-sign and mixed-sign
+        assert_substring '', @lucas, @name[3..1]
+        assert_substring '', @lucas, @name[-3..1]
+
+        # singleton slices
+        assert_substring 'L', @lucas, @name[0..0]
+        assert_substring 's', @lucas, @name[4..4]
+
+        # a second fixture, sanity-checking against a longer string
+        assert_substring 'mil', @camille, @name[2..4]
+        assert_substring 'lle', @camille, @name[-3..-1]
+
+        # NULL column
+        assert_nil t(@all_nil, @name[0..2])
+
+        # trailing whitespace
+        assert_substring ' ', @esme2, @name[4..4]
+        assert_substring 'esmé ', @esme2, @name[0..-1]
+
+        # passing a Range and an explicit length together is contradictory.
+        assert_raises(ArgumentError) { @name.substring(1..2, 5) }
+
+      end
+
+      def endless_range_supported?
+        Range.new(0, nil)
+        true
+      rescue ArgumentError
+        false
+      end
+
+      def beginless_range_supported?
+        Range.new(nil, 0)
+        true
+      rescue ArgumentError
+        false
+      end
+
+      def test_substring_range_endless
+        skip 'endless ranges not supported on this interpreter' if !endless_range_supported?
+
+        assert_substring 'as', @lucas, @name[Range.new(-2, nil)]
+        assert_substring 'Lucas', @lucas, @name[Range.new(-5, nil)]  # begin == -length: still in range
+        assert_substring nil, @lucas, @name[Range.new(-6, nil)]      # begin == -length - 1: out of range
+        assert_substring nil, @lucas, @name[Range.new(-100, nil)]
+
+        assert_nil t(@all_nil, @name[Range.new(-2, nil)])
+        assert_substring ' ', @esme2, @name[Range.new(-1, nil)]
+
+        assert_substring 'as', @lucas, @name.substring(Range.new(-2, nil))
+      end
+
+      def test_substring_range_beginless
+        skip 'beginless ranges not supported on this interpreter' if !beginless_range_supported?
+
+        assert_substring 'Luc', @lucas, @name[Range.new(nil, 2)]
+        assert_substring 'Lucas', @lucas, @name[Range.new(nil, -1)]
+        assert_substring 'Luca', @lucas, @name[Range.new(nil, -2)]
+
+        assert_nil t(@all_nil, @name[Range.new(nil, 3)])
+        assert_substring 'esmé', @esme2, @name[Range.new(nil, 3)]
+
+        assert_substring 'Luc', @lucas, @name.substring(Range.new(nil, 2))
+      end
+
       def test_find_in_set
         skip "Sqlite version can't load extension for find_in_set" if $sqlite && $load_extension_disabled
         skip 'SQL Server does not know about FIND_IN_SET' if @env_db == 'mssql'
@@ -538,7 +624,7 @@ module ArelExtensions
           # TODO: Standarize timezone conversion across all databases.
           #       This test case will be refactored and should work the same across all vendors.
           if ENV['DB'] == 'mssql' && /Microsoft SQL Server (\d+)/.match(ActiveRecord::Base.connection.select_value('SELECT @@version'))[1].to_i < 2016
-            skip "SQL Server < 2016 is not currently supported"
+            skip 'SQL Server < 2016 is not currently supported'
           end
 
           tz = ENV['DB'] == 'mssql' ? time_zones['mssql'] : time_zones['posix']
@@ -822,6 +908,7 @@ module ArelExtensions
       # TODO; cast types
       def test_cast_types
         assert_equal '5', t(@lucas, @age.cast(:string))
+        assert_equal 'a' * 50, t(@lucas, Arel.quoted('a' * 50).cast(:string))
         skip 'jdbc adapters does not work properly here (v52 works fine)' if RUBY_PLATFORM.match?(/java/i)
         if @env_db == 'mysql' || @env_db == 'postgresql' || @env_db == 'oracle' || @env_db == 'mssql'
           assert_equal 1, t(@laure, Arel.when(@duration.cast(:time).cast(:string).eq('12:42:21')).then(1).else(0)) unless @env_db == 'oracle' || @env_db == 'mssql'
@@ -937,9 +1024,9 @@ module ArelExtensions
 
         assert_equal 3, User.find_by_sql(@ut.project(@age).where(@age.gt(22)).union_all(@ut.project(@age).where(@age.lt(0))).to_sql).length
         assert_equal 3, User.find_by_sql(@ut.project(@age).where(@age.eq(20)).union_all(@ut.project(@age).where(@age.eq(20))).union_all(@ut.project(@age).where(@age.eq(21))).to_sql).length
-        assert_equal 3, User.select('*').from((@ut.project(@age).where(@age.gt(22)).union_all(@ut.project(@age).where(@age.lt(0)))).as('my_union')).length
-        assert_equal 3, User.select('*').from((@ut.project(@age).where(@age.eq(20)).union_all(@ut.project(@age).where(@age.eq(23))).union_all(@ut.project(@age).where(@age.eq(21)))).as('my_union')).length
-        assert_equal 3, User.select('*').from((@ut.project(@age).where(@age.eq(20)).union_all(@ut.project(@age).where(@age.eq(20))).union_all(@ut.project(@age).where(@age.eq(21)))).as('my_union')).length
+        assert_equal 3, User.select('*').from(@ut.project(@age).where(@age.gt(22)).union_all(@ut.project(@age).where(@age.lt(0))).as('my_union')).length
+        assert_equal 3, User.select('*').from(@ut.project(@age).where(@age.eq(20)).union_all(@ut.project(@age).where(@age.eq(23))).union_all(@ut.project(@age).where(@age.eq(21))).as('my_union')).length
+        assert_equal 3, User.select('*').from(@ut.project(@age).where(@age.eq(20)).union_all(@ut.project(@age).where(@age.eq(20))).union_all(@ut.project(@age).where(@age.eq(21))).as('my_union')).length
 
         assert (@ut.project(@age) + @ut.project(@age)).as('toto').table_name # as on union should answer to table_name (TableAlias)
       end
@@ -1145,15 +1232,16 @@ module ArelExtensions
         assert_equal 1,  t(@arthur, @name.levenshtein_distance('Artehur'))
       end
 
-      def test_json
-        skip "Can't be tested on travis"
+      def test_json_create
         # creation
         assert_equal 'Arthur', t(@arthur, Arel.json(@name))
         assert_equal %w[Arthur Arthur], parse_json(t(@arthur, Arel.json(@name, @name)))
         assert_equal ({'Arthur' => 'Arthur', 'Arthur2' => 'ArthurArthur'}), parse_json(t(@arthur, Arel.json({@name => @name, @name + '2' => @name + @name})))
         assert_equal ({'Arthur' => 'Arthur', 'Arthur2' => 1}), parse_json(t(@arthur, Arel.json({@name => @name, @name + '2' => 1})))
         assert_equal [{'age' => 21}, {'name' => 'Arthur', 'score' => 65.62}], parse_json(t(@arthur, Arel.json([{age: @age}, {name: @name, score: @score}])))
+      end
 
+      def test_json_aggregate
         # aggregate
         assert_equal ({'5' => 'Lucas', '15' => 'Sophie', '23' => 'Myung', '25' => 'Laure'}),
                      parse_json(t(User.group(:score).where(@age.is_not_null).where(@score == 20.16), Arel.json({@age => @name}).group(false)))
@@ -1164,7 +1252,10 @@ module ArelExtensions
 
         # puts User.group(:score).where(@age.is_not_null).where(@score == 20.16).select(@score, Arel.json({@age => @name}).group(true,[@age])).to_sql
         # puts User.group(:score).where(@age.is_not_null).where(@score == 20.16).select(@score, Arel.json({@age => @name}).group(true,[@age])).to_a
+      end
 
+      def test_json_get
+        skip 'Known failure: postgres ->> returns text, not parsed JSON' if @env_db == 'postgresql'
         skip 'Not Yet Implemented' if $sqlite || %w[oracle mssql].include?(@env_db)
         # get
         h1 = Arel.json({@name => @name + @name, @name + '2' => 1})
@@ -1173,17 +1264,60 @@ module ArelExtensions
         assert_equal ({'age' => 21}), parse_json(t(@arthur, h2.get(0)))
         assert_equal 21, parse_json(t(@arthur, h2.get(0).get('age')))
         assert_nil t(@arthur, h2.get('age'))
+      end
+
+      def test_json_set
+        skip 'Not Yet Implemented' if $sqlite || %w[oracle mssql].include?(@env_db)
         # set
+        h1 = Arel.json({@name => @name + @name, @name + '2' => 1})
         assert_equal ({'Arthur' => %w[toto tata], 'Arthur2' => 1}), parse_json(t(@arthur, h1.set(@name, %w[toto tata])))
         assert_equal ({'Arthur' => 'ArthurArthur', 'Arthur2' => 1, 'Arthur3' => 2}), parse_json(t(@arthur, h1.set(@name + '3', 2)))
         assert_equal ({'Arthur' => 'ArthurArthur', 'Arthur2' => 1, 'Arthur3' => nil}), parse_json(t(@arthur, h1.set(@name + '3', nil)))
         assert_equal ({'Arthur' => 'ArthurArthur', 'Arthur2' => 1, 'Arthur3' => {'a' => 2}}), parse_json(t(@arthur, h1.set(@name + '3', {a: 2})))
+      end
+
+      def test_json_merge
+        skip 'Not Yet Implemented' if $sqlite || %w[oracle mssql].include?(@env_db)
         # merge
+        h1 = Arel.json({@name => @name + @name, @name + '2' => 1})
         assert_equal ({'Arthur' => %w[toto tata], 'Arthur2' => 1, 'Arthur3' => 2}), parse_json(t(@arthur, h1.merge({@name => %w[toto tata]}, {@name + '3' => 2})))
         assert_equal ({'Arthur' => %w[toto tata], 'Arthur2' => 1, 'Arthur3' => 2}), parse_json(t(@arthur, h1.merge({@name => %w[toto tata], @name + '3' => 2})))
         assert_equal ({'Arthur' => 'ArthurArthur', 'Arthur2' => 1}), parse_json(t(@arthur, h1.merge({})))
       end
 
+      def test_json_scalar_values
+        assert_nil t(@arthur, Arel.json(nil))
+
+        assert_equal 42, parse_json(t(@arthur, Arel.json(42)))
+        assert_equal({}, parse_json(t(@arthur, Arel.json({}))))
+        assert_equal [], parse_json(t(@arthur, Arel.json([])))
+
+        assert_equal true, parse_json(t(@arthur, Arel.json(true)))
+        assert_equal ({'Arthur' => false}), parse_json(t(@arthur, Arel.json({@name => false})))
+
+        assert_equal ({'Arthur' => true}), parse_json(t(@arthur, Arel.json({@name => @enabled})))
+        assert_equal ({'Camille' => false}), parse_json(t(@camille, Arel.json({@name => @enabled})))
+        assert_equal ({'Lucas' => nil}), parse_json(t(@lucas, Arel.json({@name => @enabled})))
+      end
+
+      def test_json_special_chars
+        assert_equal ({'Arthur' => 'say "hi"'}), parse_json(t(@arthur, Arel.json({@name => 'say "hi"'})))
+        assert_equal ({'Arthur' => 'a\\b'}), parse_json(t(@arthur, Arel.json({@name => 'a\\b'})))
+        assert_equal ({'Arthur' => "line1\nline2"}), parse_json(t(@arthur, Arel.json({@name => "line1\nline2"})))
+        assert_equal ({'we"ird' => 'Arthur'}), parse_json(t(@arthur, Arel.json({'we"ird' => @name})))
+      end
+
+      def test_json_date_values
+        assert_equal ({'Arthur' => '2016-05-23'}), parse_json(t(@arthur, Arel.json({@name => @created_at})))
+        res = parse_json(t(@laure, Arel.json({@name => @duration})))['Laure']
+        assert_equal '12:42:21', res.sub(/\.\d+\z/, '') # MySQL (unlinke MariaDB) adds `.\d+` to a datetime column inside a json.
+
+        # the generic builder's `:datetime` branch is only used by sqlite and mssql.
+        if $sqlite || @env_db == 'mssql'
+          assert_equal ({'Lucas' => '2014-03-03T12:42:00'}), parse_json(t(@lucas, Arel.json({@name => @updated_at})))
+        end
+      end
+
       def test_as_on_everything
         name = @arthur.select(@name.as('NaMe')).first.attributes
         assert_equal 'Arthur', name['NaMe'] || name['name'] # because of Oracle

data/version_v1.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArelExtensions
-  VERSION = '1.6.0'.freeze
+  VERSION = '1.7.0'
 end

data/version_v2.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArelExtensions
-  VERSION = '2.4.0'.freeze
+  VERSION = '2.5.0'
 end