arel_extensions 2.1.4 → 2.1.6

data/test/with_ar/all_agnostic_test.rb

@@ -73,6 +73,8 @@ module ArelExtensions
         @neg = User.where(id: u.id)
         u = User.create age: 15, name: 'Justin', created_at: d, score: 11.0
         @justin = User.where(id: u.id)
+        u = User.create age: nil, name: 'nilly', created_at: nil, score: nil
+        @nilly = User.where(id: u.id)
 
         @age = User.arel_table[:age]
         @name = User.arel_table[:name]
@@ -149,7 +151,7 @@ module ArelExtensions
       def test_rand
         assert 42 != User.select(Arel.rand.as('res')).first.res
         assert 0 <= User.select(Arel.rand.abs.as('res')).first.res
-        assert_equal 9, User.order(Arel.rand).limit(50).count
+        assert_equal 10, User.order(Arel.rand).limit(50).count
       end
 
       def test_round
@@ -186,6 +188,49 @@ module ArelExtensions
         assert User.group(:score).count(:id).values.all?{|e| !e.nil?}
       end
 
+      def test_rollup
+        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]]))
+        assert q.to_a.length > 0
+
+        # multi
+        q = User.select(at[:name], at[:score], at[:age].sum).group(Arel::Nodes::RollUp.new([at[:score], at[:name]]))
+        assert q.to_a.length > 0
+
+        # hybrid
+        q = User.select(at[:name], at[:score], at[:age].sum).group(at[:score], Arel::Nodes::RollUp.new([at[:name]]))
+        assert q.to_a.length > 0
+
+        ## Using Arel.rollup which is less verbose than the original way
+
+        # simple
+        q = User.select(at[:name], at[:age].sum).group(Arel.rollup(at[:name]))
+        assert q.to_a.length > 0
+
+        # multi
+        q = User.select(at[:name], at[:score], at[:age].sum).group(Arel.rollup([at[:score], at[:name]]))
+        assert q.to_a.length > 0
+
+        # hybrid
+        q = User.select(at[:name], at[:score], at[:age].sum).group(at[:score], Arel.rollup([at[:name]]))
+        assert q.to_a.length > 0
+
+        ## Using at[:col].rollup which is handy for single column rollups
+
+        # simple
+        q = User.select(at[:name], at[:age].sum).group(at[:name].rollup)
+        assert q.to_a.length > 0
+
+        q = User.select(at[:name], at[:score], at[:age].sum).group(at[:name].rollup, at[:score].rollup)
+        assert q.to_a.length > 0
+
+        # hybrid
+        q = User.select(at[:name], at[:score], at[:age].sum).group(at[:name], at[:score].rollup)
+        assert q.to_a.length > 0
+      end
+
       # String Functions
       def test_concat
         assert_equal 'Camille Camille', t(@camille, @name + ' ' + @name)
@@ -193,16 +238,16 @@ module ArelExtensions
         assert_equal 'Test Laure', t(@laure, Arel.quoted('Test ') + @name)
 
         skip 'No group_concat in SqlServer before 2017' if @env_db == 'mssql'
-        assert_equal 'Lucas Sophie', t(User.where(name: ['Lucas', 'Sophie']), @name.group_concat(' '))
-        assert_equal 'Lucas,Sophie', t(User.where(name: ['Lucas', 'Sophie']), @name.group_concat(','))
-        assert_equal 'Lucas,Sophie', t(User.where(name: ['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(','))
+        assert_equal 'Lucas,Sophie', t(User.where(name: %w[Lucas Sophie]), @name.group_concat)
 
         skip 'No order in group_concat in SqlLite' if $sqlite
-        assert_equal 'Arthur,Lucas,Sophie', t(User.where(name: ['Lucas', 'Sophie', 'Arthur']), @name.group_concat(',', @name.asc))
-        assert_equal 'Sophie,Lucas,Arthur', t(User.where(name: ['Lucas', 'Sophie', 'Arthur']), @name.group_concat(',', @name.desc))
-        assert_equal 'Lucas,Sophie,Arthur', t(User.where(name: ['Lucas', 'Sophie', 'Arthur']), @name.group_concat(',', [@score.asc, @name.asc]))
-        assert_equal 'Lucas,Sophie,Arthur', t(User.where(name: ['Lucas', 'Sophie', 'Arthur']), @name.group_concat(',', @score.asc, @name.asc))
-        assert_equal 'Lucas,Sophie,Arthur', t(User.where(name: ['Lucas', 'Sophie', 'Arthur']), @name.group_concat(',', order: [@score.asc, @name.asc]))
+        assert_equal 'Arthur,Lucas,Sophie', t(User.where(name: %w[Lucas Sophie Arthur]), @name.group_concat(',', @name.asc))
+        assert_equal 'Sophie,Lucas,Arthur', t(User.where(name: %w[Lucas Sophie Arthur]), @name.group_concat(',', @name.desc))
+        assert_equal 'Lucas,Sophie,Arthur', t(User.where(name: %w[Lucas Sophie Arthur]), @name.group_concat(',', [@score.asc, @name.asc]))
+        assert_equal 'Lucas,Sophie,Arthur', t(User.where(name: %w[Lucas Sophie Arthur]), @name.group_concat(',', @score.asc, @name.asc))
+        assert_equal 'Lucas,Sophie,Arthur', t(User.where(name: %w[Lucas Sophie Arthur]), @name.group_concat(',', order: [@score.asc, @name.asc]))
       end
 
       def test_length
@@ -294,16 +339,16 @@ module ArelExtensions
         skip "Sqlite version can't load extension for regexp" if $sqlite && $load_extension_disabled
         skip 'SQL Server does not know about REGEXP without extensions' if @env_db == 'mssql'
         assert_equal 1, User.where(@name =~ '^M').count
-        assert_equal 7, User.where(@name !~ '^L').count
+        assert_equal 8, User.where(@name !~ '^L').count
         assert_equal 1, User.where(@name =~ /^M/).count
-        assert_equal 7, User.where(@name !~ /^L/).count
+        assert_equal 8, User.where(@name !~ /^L/).count
       end
 
       def test_imatches
         # puts User.where(@name.imatches('m%')).to_sql
         assert_equal 1, User.where(@name.imatches('m%')).count
         assert_equal 4, User.where(@name.imatches_any(['L%', '%e'])).count
-        assert_equal 7, User.where(@name.idoes_not_match('L%')).count
+        assert_equal 8, User.where(@name.idoes_not_match('L%')).count
       end
 
       def test_replace
@@ -328,8 +373,8 @@ module ArelExtensions
         skip "Sqlite version can't load extension for soundex" if $sqlite && $load_extension_disabled
         skip "PostgreSql version can't load extension for soundex" if @env_db == 'postgresql'
         assert_equal 'C540', t(@camille, @name.soundex)
-        assert_equal 9, User.where(@name.soundex.eq(@name.soundex)).count
-        assert_equal 9, User.where(@name.soundex == @name.soundex).count
+        assert_equal 10, User.where(@name.soundex.eq(@name.soundex)).count
+        assert_equal 10, User.where(@name.soundex == @name.soundex).count
       end
 
       def test_change_case
@@ -374,6 +419,23 @@ module ArelExtensions
         assert_equal 'true', t(@neg, @comments.not_blank.then('true', 'false'))
       end
 
+      # This test repeats a lot of `test_blank` cases.
+      def test_present
+        if @env_db == 'postgresql'
+          assert_includes [true, 't'], t(@myung, @name.present) # depends of adapter
+          assert_includes [false, 'f'], t(@myung, @comments.present)
+        end
+        assert_equal 1, @myung.where(@name.present).count
+        assert_equal 0, @myung.where(@comments.present).count
+        assert_equal 0, @sophie.where(@comments.present).count
+        assert_equal 0, @camille.where(@comments.present).count
+
+        assert_equal 1, @neg.where(@comments.present).count
+        assert_equal 'true', t(@myung, @name.present.then('true', 'false'))
+        assert_equal 'false', t(@myung, @comments.present.then('true', 'false'))
+        assert_equal 'true', t(@neg, @comments.present.then('true', 'false'))
+      end
+
       def test_format
         assert_equal '2016-05-23', t(@lucas, @created_at.format('%Y-%m-%d'))
         assert_equal '2014/03/03 12:42:00', t(@lucas, @updated_at.format('%Y/%m/%d %H:%M:%S'))
@@ -419,27 +481,32 @@ module ArelExtensions
                            }
         }
 
-        skip "Unsupported timezone conversion for DB=#{ENV['DB']}" if !['mssql', 'mysql', 'oracle', 'postgresql'].include?(ENV['DB'])
+        skip "Unsupported timezone conversion for DB=#{ENV['DB']}" if !%w[mssql mysql oracle postgresql].include?(ENV['DB'])
+        # 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"
+        end
 
         tz = ENV['DB'] == 'mssql' ? time_zones['mssql'] : time_zones['posix']
 
         assert_equal '2014/03/03 12:42:00', t(@lucas, @updated_at.format('%Y/%m/%d %H:%M:%S', tz['utc']))
-        assert_equal '2014/03/03 09:42:00', t(@lucas, @updated_at.format('%Y/%m/%d %H:%M:%S', { tz['utc'] => tz['sao_paulo'] }))
-        assert_equal '2014/03/03 02:42:00', t(@lucas, @updated_at.format('%Y/%m/%d %H:%M:%S', { tz['utc'] => tz['tahiti'] }))
+        assert_equal '2014/03/03 09:42:00', t(@lucas, @updated_at.format('%Y/%m/%d %H:%M:%S', {tz['utc'] => tz['sao_paulo']}))
+        assert_equal '2014/03/03 02:42:00', t(@lucas, @updated_at.format('%Y/%m/%d %H:%M:%S', {tz['utc'] => tz['tahiti']}))
 
         # Skipping conversion from UTC to the desired timezones fails in SQL
         # Server and Postgres. This is mainly due to the fact that timezone
         # information is not preserved in the column itself.
         #
         # MySQL is happy to consider that times by default are in UTC.
-        assert_equal '2014/03/03 13:42:00', t(@lucas, @updated_at.format('%Y/%m/%d %H:%M:%S', { tz['utc'] => tz['paris'] }))
+        assert_equal '2014/03/03 13:42:00', t(@lucas, @updated_at.format('%Y/%m/%d %H:%M:%S', {tz['utc'] => tz['paris']}))
         refute_equal '2014/03/03 13:42:00', t(@lucas, @updated_at.format('%Y/%m/%d %H:%M:%S', tz['paris'])) if !['mysql'].include?(ENV['DB'])
 
         # Winter/Summer time
-        assert_equal '2014/08/03 14:42:00', t(@lucas, (@updated_at + 5.months).format('%Y/%m/%d %H:%M:%S', { tz['utc'] => tz['paris'] }))
+        assert_equal '2014/08/03 14:42:00', t(@lucas, (@updated_at + 5.months).format('%Y/%m/%d %H:%M:%S', {tz['utc'] => tz['paris']}))
         if ENV['DB'] == 'mssql'
-          assert_equal '2022/02/01 11:42:00', t(@lucas, Arel.quoted('2022-02-01 10:42:00').cast(:datetime).format('%Y/%m/%d %H:%M:%S', { tz['utc'] => tz['paris'] }))
-          assert_equal '2022/08/01 12:42:00', t(@lucas, Arel.quoted('2022-08-01 10:42:00').cast(:datetime).format('%Y/%m/%d %H:%M:%S', { tz['utc'] => tz['paris'] }))
+          assert_equal '2022/02/01 11:42:00', t(@lucas, Arel.quoted('2022-02-01 10:42:00').cast(:datetime).format('%Y/%m/%d %H:%M:%S', {tz['utc'] => tz['paris']}))
+          assert_equal '2022/08/01 12:42:00', t(@lucas, Arel.quoted('2022-08-01 10:42:00').cast(:datetime).format('%Y/%m/%d %H:%M:%S', {tz['utc'] => tz['paris']}))
         else
           assert_equal '2022/02/01 11:42:00', t(@lucas, Arel.quoted('2022-02-01 10:42:00').cast(:datetime).format('%Y/%m/%d %H:%M:%S', tz['paris']))
           assert_equal '2022/08/01 12:42:00', t(@lucas, Arel.quoted('2022-08-01 10:42:00').cast(:datetime).format('%Y/%m/%d %H:%M:%S', tz['paris']))
@@ -463,7 +530,7 @@ module ArelExtensions
       end
 
       def test_format_iso_year_of_week
-        skip "Unsupported ISO year of week for DB=#{ENV['DB']}" if ['mssql', 'sqlite'].include?(ENV['DB'])
+        skip "Unsupported ISO year of week for DB=#{ENV['DB']}" if %w[mssql sqlite].include?(ENV['DB'])
         assert_equal '2014', t(@lucas, @updated_at.format('%G'))
 
         {
@@ -480,7 +547,7 @@ module ArelExtensions
       end
 
       def test_format_date_with_names
-        skip "#{ENV['DB']} does not support a variety of word-based formatting for month and day names" if ['mssql'].include?(ENV['DB'])
+        skip "#{ENV['DB']} does not support a variety of word-based formatting for month and day names" if %w[mssql sqlite].include?(ENV['DB'])
         assert_equal 'Mon, 03 Mar 14', t(@lucas, @updated_at.format('%a, %d %b %y'))
         assert_equal 'Monday, 03 March 14', t(@lucas, @updated_at.format('%A, %d %B %y'))
 
@@ -491,9 +558,9 @@ module ArelExtensions
 
       def switch_to_lang(lang)
         languages = {
-          'mssql'      => { :en => 'English',    :fr => 'French'     },
-          'mysql'      => { :en => 'en_US',      :fr => 'fr_FR'      },
-          'postgresql' => { :en => 'en_US.utf8', :fr => 'fr_FR.utf8' }
+          'mssql'      => {en: 'English',    fr: 'French'},
+          'mysql'      => {en: 'en_US',      fr: 'fr_FR'},
+          'postgresql' => {en: 'en_US.utf8', fr: 'fr_FR.utf8'}
         }
 
         sql = {
@@ -513,27 +580,29 @@ module ArelExtensions
         #
         # Tests should assert one single thing in principle, but until we
         # refactor this whole thing, we'll have to do tricks of this sort.
-        switch_to_lang(:en)
-        case ENV['DB']
-        when 'mysql', 'postgresql'
-          assert_equal 'Mon, 03 Mar 14', t(@lucas, @updated_at.format('%a, %d %b %y'))
-          assert_equal 'Monday, 03 March 14', t(@lucas, @updated_at.format('%A, %d %B %y'))
-        when 'mssql'
-          assert_equal 'Monday, 03 March 2014', t(@lucas, @updated_at.format('%A, %d %B %y'))
-        end
-        switch_to_lang(:fr)
-        case ENV['DB']
-        when 'mysql'
-          assert_equal 'lun, 03 mar 14', t(@lucas, @updated_at.format('%a, %d %b %y'))
-          assert_equal 'lundi, 03 mars 14', t(@lucas, @updated_at.format('%A, %d %B %y'))
-        when 'postgresql'
-          assert_equal 'Lun., 03 Mars 14', t(@lucas, @updated_at.format('%a, %d %b %y'))
-          assert_equal 'Lundi, 03 Mars 14', t(@lucas, @updated_at.format('%A, %d %B %y'))
-        when 'mssql'
-          assert_equal 'lundi, 03 mars 2014', t(@lucas, @updated_at.format('%A, %d %B %y'))
+        begin
+          switch_to_lang(:en)
+          case ENV['DB']
+          when 'mysql', 'postgresql'
+            assert_equal 'Mon, 03 Mar 14', t(@lucas, @updated_at.format('%a, %d %b %y'))
+            assert_equal 'Monday, 03 March 14', t(@lucas, @updated_at.format('%A, %d %B %y'))
+          when 'mssql'
+            assert_equal 'Monday, 03 March 2014', t(@lucas, @updated_at.format('%A, %d %B %y'))
+          end
+          switch_to_lang(:fr)
+          case ENV['DB']
+          when 'mysql'
+            assert_equal 'lun, 03 mar 14', t(@lucas, @updated_at.format('%a, %d %b %y'))
+            assert_equal 'lundi, 03 mars 14', t(@lucas, @updated_at.format('%A, %d %B %y'))
+          when 'postgresql'
+            assert_equal 'Lun., 03 Mars 14', t(@lucas, @updated_at.format('%a, %d %b %y'))
+            assert_equal 'Lundi, 03 Mars 14', t(@lucas, @updated_at.format('%A, %d %B %y'))
+          when 'mssql'
+            assert_equal 'lundi, 03 mars 2014', t(@lucas, @updated_at.format('%A, %d %B %y'))
+          end
+        ensure
+          switch_to_lang(:en)
         end
-      ensure
-        switch_to_lang(:en)
       end
 
       def test_coalesce
@@ -558,6 +627,24 @@ module ArelExtensions
         assert_equal 'Laure10', t(@laure, @comments.coalesce('Laure') + 10)
       end
 
+      def test_coalesce_blank
+        assert_equal 'Myung', t(@myung, @comments.coalesce_blank('Myung').coalesce_blank('ignored'))
+        assert_equal 'Myung', t(@myung, @comments.coalesce_blank('', ' ', '   ').coalesce_blank('Myung'))
+        assert_equal 'Myung', t(@myung, @comments.coalesce_blank('', ' ', '   ', 'Myung'))
+        assert_equal '2016-05-23', t(@myung, @created_at.coalesce_blank(Date.new(2022, 1, 1)).format('%Y-%m-%d'))
+        assert_equal 'Laure', t(@laure, @comments.coalesce_blank('Laure'))
+        assert_equal 100, t(@test, @age.coalesce_blank(100))
+        assert_equal 20, t(@test, @age.coalesce_blank(20))
+        assert_equal 20, t(@test, @age.coalesce_blank(10) + 10)
+        assert_equal 'Laure10', t(@laure, @comments.coalesce_blank('Laure') + 10)
+
+        skip 'mssql does not support null in case results' if @env_db == 'mssql'
+
+        assert_equal 'Camille concat', t(@camille, @name.coalesce_blank(Arel.null, 'default') + ' concat')
+        assert_equal 'Myung', t(@myung, @comments.coalesce_blank(Arel.null, 'Myung'))
+        assert_equal 'Camille', t(@camille, @name.coalesce_blank(Arel.null, 'default'))
+      end
+
       # Comparators
       def test_number_comparator
         assert_equal 2, User.where(@age < 6).count
@@ -570,7 +657,7 @@ module ArelExtensions
       def test_date_comparator
         d = Date.new(2016, 5, 23)
         assert_equal 0, User.where(@created_at < d).count
-        assert_equal 9, User.where(@created_at >= d).count
+        assert_equal 10, User.where(@created_at >= d).count
       end
 
       def test_date_duration
@@ -602,8 +689,8 @@ module ArelExtensions
       def test_datetime_diff
         assert_equal 0, t(@lucas, @updated_at - Time.utc(2014, 3, 3, 12, 42)).to_i
         if @env_db == 'oracle' && Arel::VERSION.to_i > 6 # in rails 5, result is multiplied by 24*60*60 = 86400...
-          assert_equal 42 * 86400, t(@lucas, @updated_at - Time.utc(2014, 3, 3, 12, 41, 18)).to_i
-          assert_equal(-3600 * 86400, t(@lucas, @updated_at - Time.utc(2014, 3, 3, 13, 42)).to_i)
+          assert_equal 42 * 86_400, t(@lucas, @updated_at - Time.utc(2014, 3, 3, 12, 41, 18)).to_i
+          assert_equal(-3600 * 86_400, t(@lucas, @updated_at - Time.utc(2014, 3, 3, 13, 42)).to_i)
         else
           assert_equal 42, t(@lucas, @updated_at - Time.utc(2014, 3, 3, 12, 41, 18)).to_i
           assert_equal(-3600, t(@lucas, @updated_at - Time.utc(2014, 3, 3, 13, 42)).to_i)
@@ -658,12 +745,12 @@ module ArelExtensions
       # TODO; cast types
       def test_cast_types
         assert_equal '5', t(@lucas, @age.cast(:string))
-        skip 'jdbc adapters does not work properly here (v52 works fine)' if RUBY_PLATFORM =~ /java/i
+        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'
           assert_equal 1, t(@laure, Arel.when(@duration.cast(:time).eq('12:42:21')).then(1).else(0)) unless @env_db == 'oracle'
-          assert_equal '20.16', t(@laure, @score.cast(:string)).gsub(/[0]*\z/, '')
-          assert_equal '20.161', t(@laure, @score.cast(:string) + 1).gsub(/[0]*1\z/, '1')
+          assert_equal '20.16', t(@laure, @score.cast(:string)).gsub(/0*\z/, '')
+          assert_equal '20.161', t(@laure, @score.cast(:string) + 1).gsub(/0*1\z/, '1')
           assert_equal 21.16, t(@laure, @score.cast(:string).cast(:decimal) + 1)
           assert_equal 21, t(@laure, @score.cast(:string).cast(:int) + 1)
 
@@ -683,6 +770,26 @@ module ArelExtensions
         end
       end
 
+      def test_if_present
+        assert_nil t(@myung, @comments.if_present)
+        assert_equal 0, t(@myung, @comments.if_present.count)
+        assert_equal 20.16, t(@myung, @score.if_present)
+        assert_equal '2016-05-23', t(@myung, @created_at.if_present.format('%Y-%m-%d'))
+        assert_nil t(@laure, @comments.if_present)
+
+        assert_nil t(@nilly, @duration.if_present.format('%Y-%m-%d'))
+
+        # NOTE: here we're testing the capacity to format a nil value,
+        # however, @comments is a text field, and not a date/datetime field,
+        # so Postgres will rightfully complain when we format the text:
+        # we need to cast it first.
+        if @env_db == 'postgresql'
+          assert_nil t(@laure, @comments.cast(:date).if_present.format('%Y-%m-%d'))
+        else
+          assert_nil t(@laure, @comments.if_present.format('%Y-%m-%d'))
+        end
+      end
+
       def test_is_null
         # puts User.where(@age.is_null).select(@name).to_sql
         # puts @age.is_null
@@ -718,7 +825,7 @@ module ArelExtensions
       def test_math_minus
         d = Date.new(2016, 5, 20)
         # Datediff
-        assert_equal 9, User.where((@created_at - @created_at).eq(0)).count
+        assert_equal 10, User.where((@created_at - @created_at).eq(0)).count
         assert_equal 3, @laure.select((@created_at - d).as('res')).first.res.abs.to_i
         # Substraction
         assert_equal 0, User.where((@age - 10).eq(50)).count
@@ -747,8 +854,8 @@ module ArelExtensions
         assert_equal 3, User.select('*').from((@ut.project(@age).where(@age.eq(20)) + @ut.project(@age).where(@age.eq(23)) + @ut.project(@age).where(@age.eq(21))).as('my_union')).length
         assert_equal 2, User.select('*').from((@ut.project(@age).where(@age.eq(20)) + @ut.project(@age).where(@age.eq(20)) + @ut.project(@age).where(@age.eq(21))).as('my_union')).length
 
-        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.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
@@ -786,10 +893,10 @@ module ArelExtensions
         assert_includes ['$ 6,56e1 €', '$ 6,56e+01 €'], t(@arthur, @score.format_number('$ %.2e €', 'fr_FR'))
         assert_includes ['$ 6,56E1 €', '$ 6,56E+01 €'], t(@arthur, @score.format_number('$ %.2E €', 'fr_FR'))
         assert_includes ['$ 6,562E1 €', '$ 6,562E+01 €'], t(@arthur, @score.format_number('$ %.3E €', 'fr_FR'))
-        assert_equal '123 456 765,6', t(@arthur, (@score + 123456700).format_number('%.1f', 'sv_SE')).gsub("\u00A0", ' ') # some DBMS put no-break space here (it makes sense thus)
-        assert_equal '123456765,6', t(@arthur, (@score + 123456700).format_number('%.1f', 'fr_FR')).gsub("\u00A0", '') # because SqlServer does it like no one else
-        assert_equal '123,456,765.6', t(@arthur, (@score + 123456700).format_number('%.1f', 'en_US'))
-        assert_equal '   123,456,765.6', t(@arthur, (@score + 123456700).format_number('%16.1f', 'en_US'))
+        assert_equal '123 456 765,6', t(@arthur, (@score + 123_456_700).format_number('%.1f', 'sv_SE')).tr("\u00A0", ' ') # some DBMS put no-break space here (it makes sense thus)
+        assert_equal '123456765,6', t(@arthur, (@score + 123_456_700).format_number('%.1f', 'fr_FR')).delete("\u00A0") # because SqlServer does it like no one else
+        assert_equal '123,456,765.6', t(@arthur, (@score + 123_456_700).format_number('%.1f', 'en_US'))
+        assert_equal '   123,456,765.6', t(@arthur, (@score + 123_456_700).format_number('%16.1f', 'en_US'))
         assert_equal '$ 0,00 €', t(@arthur, @score.when(65.62).then(Arel.sql('null')).else(1).format_number('$ %.2f €', 'fr_FR'))
         assert_equal '$ 0,00 €', t(@arthur, (@score - 65.62).format_number('$ %.2f €', 'fr_FR'))
       end
@@ -811,7 +918,7 @@ module ArelExtensions
           assert_equal '1', t(@arthur, Arel.when(@comments.ai_matches('arrete')).then('1').else('0'))
           assert_equal '1', t(@arthur, Arel.when(@comments.ai_matches('àrrétè')).then('1').else('0'))
           assert_equal '0', t(@arthur, Arel.when(@comments.ai_matches('arretez')).then('1').else('0'))
-          if !['oracle', 'postgresql', 'mysql'].include?(@env_db) # AI => CI
+          if !%w[oracle postgresql mysql].include?(@env_db) # AI => CI
             assert_equal '0', t(@arthur, Arel.when(@comments.ai_matches('Arrete')).then('1').else('0'))
             assert_equal '0', t(@arthur, Arel.when(@comments.ai_matches('Arrêté')).then('1').else('0'))
           end
@@ -838,8 +945,8 @@ module ArelExtensions
 
       def test_subquery_with_order
         skip if ['mssql'].include?(@env_db) && Arel::VERSION.to_i < 10
-        assert_equal 9, User.where(name: User.select(:name).order(:name)).count
-        assert_equal 9, User.where(@ut[:name].in(@ut.project(@ut[:name]).order(@ut[:name]))).count
+        assert_equal 10, User.where(name: User.select(:name).order(:name)).count
+        assert_equal 10, User.where(@ut[:name].in(@ut.project(@ut[:name]).order(@ut[:name]))).count
         if !['mysql'].include?(@env_db) # MySql can't have limit in IN subquery
           assert_equal 2, User.where(name: User.select(:name).order(:name).limit(2)).count
           # assert_equal 6, User.where(name: User.select(:name).order(:name).offset(2)).count
@@ -915,7 +1022,7 @@ module ArelExtensions
       end
 
       def test_alias_shortened
-        if ['postgresql', 'oracle'].include?(@env_db)
+        if %w[postgresql oracle].include?(@env_db)
           new_alias = Arel.shorten('azerty' * 15)
           at = User.arel_table.alias('azerty' * 15)
           assert_equal "\"user_tests\" \"#{new_alias}\"".downcase, User.arel_table.alias('azerty' * 15).to_sql.downcase
@@ -956,23 +1063,23 @@ module ArelExtensions
         skip "Can't be tested on travis"
         # creation
         assert_equal 'Arthur', t(@arthur, Arel.json(@name))
-        assert_equal ['Arthur', 'Arthur'], parse_json(t(@arthur, Arel.json(@name, @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}])))
+        assert_equal [{'age' => 21}, {'name' => 'Arthur', 'score' => 65.62}], parse_json(t(@arthur, Arel.json([{age: @age}, {name: @name, score: @score}])))
 
         # 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)))
         assert_equal ({'5' => 'Lucas', '15' => 'Sophie', '23' => 'Myung', '25' => 'Laure', 'Laure' => 25, 'Lucas' => 5, 'Myung' => 23, 'Sophie' => 15}),
                      parse_json(t(User.group(:score).where(@age.is_not_null).where(@score == 20.16), Arel.json({@age => @name, @name => @age}).group(false)))
-        assert_equal ([{'5' => 'Lucas'}, { '15' => 'Sophie'}, { '23' => 'Myung'}, { '25' => 'Laure'}]),
+        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).select(@score), Arel.json({@age => @name}).group(true, [@age])))
 
         # 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
 
-        skip 'Not Yet Implemented' if $sqlite || ['oracle', 'mssql'].include?(@env_db)
+        skip 'Not Yet Implemented' if $sqlite || %w[oracle mssql].include?(@env_db)
         # get
         h1 = Arel.json({@name => @name + @name, @name + '2' => 1})
         assert_equal 'ArthurArthur', parse_json(t(@arthur, h1.get(@name)))
@@ -981,13 +1088,13 @@ module ArelExtensions
         assert_equal 21, parse_json(t(@arthur, h2.get(0).get('age')))
         assert_nil t(@arthur, h2.get('age'))
         # set
-        assert_equal ({'Arthur' => ['toto', 'tata'], 'Arthur2' => 1}), parse_json(t(@arthur, h1.set(@name, ['toto', 'tata'])))
+        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})))
         # merge
-        assert_equal ({'Arthur' => ['toto', 'tata'], 'Arthur2' => 1, 'Arthur3' => 2}), parse_json(t(@arthur, h1.merge({@name => ['toto', 'tata']}, {@name + '3' => 2})))
-        assert_equal ({'Arthur' => ['toto', 'tata'], 'Arthur2' => 1, 'Arthur3' => 2}), parse_json(t(@arthur, h1.merge({@name => ['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' => %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
 

data/test/with_ar/insert_agnostic_test.rb

@@ -58,15 +58,15 @@ END;])
         connect_db
         setup_db
         @table = Arel::Table.new(:user_tests)
-        @cols = ['id', 'name', 'comments', 'created_at']
+        @cols = %w[id name comments created_at]
         @data = [
           [23, 'nom1', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse lectus tortor, dignissim sit amet, adipiscing nec, ultricies sed, dolor.', '2016-01-01'],
           [25, 'nom2', 'sdfdsfdsfsdf', '2016-01-02']
         ]
-        @cols2 = ['name', 'comments', 'created_at']
+        @cols2 = %w[name comments created_at]
         @data2 = [
           ['nom3', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse lectus tortor, dignissim sit amet, adipiscing nec, ultricies sed, dolor.', '2016-01-01'],
-          ['nom4', 'sdfdsfdsfsdf', '2016-01-04']
+          %w[nom4 sdfdsfdsfsdf 2016-01-04]
         ]
       end
 

data/test/with_ar/test_bulk_sqlite.rb

@@ -27,7 +27,7 @@ module ArelExtensions
           t.column :price, :decimal
         end
         @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']

data/version_v1.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = '1.3.4'.freeze
+  VERSION = '1.3.6'.freeze
 end

data/version_v2.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = '2.1.4'.freeze
+  VERSION = '2.1.6'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arel_extensions
 version: !ruby/object:Gem::Version
-  version: 2.1.4
+  version: 2.1.6
 platform: ruby
 authors:
 - Yann Azoury
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-24 00:00:00.000000000 Z
+date: 2022-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -40,20 +40,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.9'
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 6.3.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 6.3.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -86,15 +72,17 @@ files:
 - ".rubocop.yml"
 - Gemfile
 - MIT-LICENSE.txt
+- NEWS.md
 - README.md
 - Rakefile
 - SQL_Challenges.md
 - TODO
+- appveyor.yml
 - arel_extensions.gemspec
 - functions.html
 - gemfiles/rails3.gemfile
-- gemfiles/rails4.gemfile
-- gemfiles/rails5_0.gemfile
+- gemfiles/rails4_2.gemfile
+- gemfiles/rails5.gemfile
 - gemfiles/rails5_1_4.gemfile
 - gemfiles/rails5_2.gemfile
 - gemfiles/rails6.gemfile
@@ -149,7 +137,9 @@ files:
 - lib/arel_extensions/nodes/rand.rb
 - lib/arel_extensions/nodes/repeat.rb
 - lib/arel_extensions/nodes/replace.rb
+- lib/arel_extensions/nodes/rollup.rb
 - lib/arel_extensions/nodes/round.rb
+- lib/arel_extensions/nodes/select.rb
 - lib/arel_extensions/nodes/soundex.rb
 - lib/arel_extensions/nodes/std.rb
 - lib/arel_extensions/nodes/substring.rb

data/gemfiles/rails4.gemfile

@@ -1,29 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'arel', '~> 6.0'
-
-group :development, :test do
-  gem 'activesupport', '~> 4.0'
-  gem 'activemodel', '~> 4.0'
-  gem 'activerecord', '~> 4.0'
-
-  gem 'sqlite3', '<= 1.3.13', platforms: [:mri, :mswin, :mingw]
-  gem 'mysql2', '0.4.10', platforms: [:mri, :mswin, :mingw]
-  gem 'pg', '< 1.0.0', platforms: [:mri, :mingw]
-
-  gem 'tiny_tds', platforms: [:mri, :mingw, :mswin] if RUBY_PLATFORM =~ /windows/
-  gem 'activerecord-sqlserver-adapter', '~> 4.2.0', platforms: [:mri, :mingw, :mswin] if RUBY_PLATFORM =~ /windows/
-
-  gem 'ruby-oci8', platforms: [:mri, :mswin, :mingw] if ENV.has_key? 'ORACLE_HOME'
-  gem 'activerecord-oracle_enhanced-adapter', '~> 1.6.0' if ENV.has_key? 'ORACLE_HOME'
-
-  # for JRuby
-  gem 'activerecord-jdbc-adapter', '~> 1.3', platforms: :jruby
-  gem 'jdbc-sqlite3', platforms: :jruby
-  gem 'activerecord-jdbcsqlite3-adapter', platforms: :jruby
-  gem 'activerecord-jdbcmysql-adapter', platforms: :jruby
-  gem 'activerecord-jdbcpostgresql-adapter', platforms: :jruby
-  gem 'activerecord-jdbcmssql-adapter', platforms: :jruby
-end
-
-gemspec path: '../'