arel_extensions 2.1.5 → 2.1.7

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)
@@ -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,124 +419,152 @@ module ArelExtensions
         assert_equal 'true', t(@neg, @comments.not_blank.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'))
-        assert_equal '12:42%', t(@lucas, @updated_at.format('%R%%'))
-
-        # The following tests will ensure proper conversion of timestamps to
-        # requested timezones.
-        #
-        # The names of the timezones is highly dependant on the underlying
-        # operating system, and this is why we need to handle each database
-        # separately: the images we're using to test these databases are
-        # different. So don't rely on the provided examples. Your setup is your
-        # reference.
-        #
-        # One could always have portable code if s/he uses standard
-        # abbreviations, like:
-        #
-        # 1. CET  => Central European Time
-        # 2. CEST => Central European Summer Time
-        #
-        # Which implies that the caller should handle daylight saving detection.
-        # In fact, CET will handle daylight saving in MySQL but not Postgres.
-        #
-        # It looks like the posix convention is supported by mysql and
-        # postgresql, e.g.:
-        #
-        # posix/Europe/Paris
-        # posix/America/Nipigon
-        #
-        # so it looks like a more reliably portable way of specifying it.
-        time_zones = {
-          'mssql'       => {
-                            'utc'       => 'UTC',
-                            'sao_paulo' => 'Argentina Standard Time',
-                            'tahiti'    => 'Hawaiian Standard Time',
-                            'paris'     => 'Central European Standard Time'
-                           },
-          'posix'       => {
-                            'utc'       => 'UTC',
-                            'sao_paulo' => 'America/Sao_Paulo',
-                            'tahiti'    => 'Pacific/Tahiti',
-                            'paris'     => 'Europe/Paris'
-                           }
-        }
-
-        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"
+      # 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
 
-        tz = ENV['DB'] == 'mssql' ? time_zones['mssql'] : time_zones['posix']
+        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
 
-        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']}))
+      def test_format
+        %i[format format_date].each do |method|
+          assert_equal '2016-05-23', t(@lucas, @created_at.send(method, '%Y-%m-%d'))
+          assert_equal '2014/03/03 12:42:00', t(@lucas, @updated_at.send(method, '%Y/%m/%d %H:%M:%S'))
+          assert_equal '12:42%', t(@lucas, @updated_at.send(method, '%R%%'))
+
+          # The following tests will ensure proper conversion of timestamps to
+          # requested timezones.
+          #
+          # The names of the timezones is highly dependant on the underlying
+          # operating system, and this is why we need to handle each database
+          # separately: the images we're using to test these databases are
+          # different. So don't rely on the provided examples. Your setup is your
+          # reference.
+          #
+          # One could always have portable code if s/he uses standard
+          # abbreviations, like:
+          #
+          # 1. CET  => Central European Time
+          # 2. CEST => Central European Summer Time
+          #
+          # Which implies that the caller should handle daylight saving detection.
+          # In fact, CET will handle daylight saving in MySQL but not Postgres.
+          #
+          # It looks like the posix convention is supported by mysql and
+          # postgresql, e.g.:
+          #
+          # posix/Europe/Paris
+          # posix/America/Nipigon
+          #
+          # so it looks like a more reliably portable way of specifying it.
+          time_zones = {
+            'mssql'       => {
+              'utc'       => 'UTC',
+              'sao_paulo' => 'Argentina Standard Time',
+              'tahiti'    => 'Hawaiian Standard Time',
+              'paris'     => 'Central European Standard Time'
+            },
+            'posix'       => {
+              'utc'       => 'UTC',
+              'sao_paulo' => 'America/Sao_Paulo',
+              'tahiti'    => 'Pacific/Tahiti',
+              'paris'     => 'Europe/Paris'
+            }
+          }
+
+          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
 
-        # 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']}))
-        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']}))
-        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']}))
-        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']))
+          tz = ENV['DB'] == 'mssql' ? time_zones['mssql'] : time_zones['posix']
+
+          assert_equal '2014/03/03 12:42:00', t(@lucas, @updated_at.send(method, '%Y/%m/%d %H:%M:%S', tz['utc']))
+          assert_equal '2014/03/03 09:42:00', t(@lucas, @updated_at.send(method, '%Y/%m/%d %H:%M:%S', {tz['utc'] => tz['sao_paulo']}))
+          assert_equal '2014/03/03 02:42:00', t(@lucas, @updated_at.send(method, '%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.send(method, '%Y/%m/%d %H:%M:%S', {tz['utc'] => tz['paris']}))
+          refute_equal '2014/03/03 13:42:00', t(@lucas, @updated_at.send(method, '%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).send(method, '%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).send(method, '%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).send(method, '%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).send(method, '%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).send(method, '%Y/%m/%d %H:%M:%S', tz['paris']))
+          end
         end
       end
 
       def test_format_iso_week
-        skip "Unsupported ISO week number for DB=#{ENV['DB']}" if ['sqlite'].include?(ENV['DB'])
-        assert_equal '10', t(@lucas, @updated_at.format('%V'))
-        {
-          '2024-01-01 10:42:00' => '01', # Monday
-          '2030-01-01 10:42:00' => '01', # Tuesday
-          '2025-01-01 10:42:00' => '01', # Wednesday
-          '2026-01-01 10:42:00' => '01', # Thursday
-          '2027-01-01 10:42:00' => '53', # Friday
-          '2028-01-01 10:42:00' => '52', # Saturday
-          '2034-01-01 10:42:00' => '52', # Sunday
-        }.each do |date, exp|
-          assert_equal exp, t(@lucas, Arel.quoted(date).cast(:datetime).format('%V'))
+        %i[format format_date].each do |method|
+          skip "Unsupported ISO week number for DB=#{ENV['DB']}" if ['sqlite'].include?(ENV['DB'])
+          assert_equal '10', t(@lucas, @updated_at.send(method, '%V'))
+          {
+            '2024-01-01 10:42:00' => '01', # Monday
+            '2030-01-01 10:42:00' => '01', # Tuesday
+            '2025-01-01 10:42:00' => '01', # Wednesday
+            '2026-01-01 10:42:00' => '01', # Thursday
+            '2027-01-01 10:42:00' => '53', # Friday
+            '2028-01-01 10:42:00' => '52', # Saturday
+            '2034-01-01 10:42:00' => '52', # Sunday
+          }.each do |date, exp|
+            assert_equal exp, t(@lucas, Arel.quoted(date).cast(:datetime).send(method, '%V'))
+          end
         end
       end
 
       def test_format_iso_year_of_week
         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'))
-
-        {
-          '2024-01-01 10:42:00' => '2024', # Monday
-          '2030-01-01 10:42:00' => '2030', # Tuesday
-          '2025-01-01 10:42:00' => '2025', # Wednesday
-          '2026-01-01 10:42:00' => '2026', # Thursday
-          '2027-01-01 10:42:00' => '2026', # Friday
-          '2028-01-01 10:42:00' => '2027', # Saturday
-          '2034-01-01 10:42:00' => '2033', # Sunday
-        }.each do |date, exp|
-          assert_equal exp, t(@lucas, Arel.quoted(date).cast(:datetime).format('%G'))
+        %i[format format_date].each do |method|
+          assert_equal '2014', t(@lucas, @updated_at.send(method, '%G'))
+
+          {
+            '2024-01-01 10:42:00' => '2024', # Monday
+            '2030-01-01 10:42:00' => '2030', # Tuesday
+            '2025-01-01 10:42:00' => '2025', # Wednesday
+            '2026-01-01 10:42:00' => '2026', # Thursday
+            '2027-01-01 10:42:00' => '2026', # Friday
+            '2028-01-01 10:42:00' => '2027', # Saturday
+            '2034-01-01 10:42:00' => '2033', # Sunday
+          }.each do |date, exp|
+            assert_equal exp, t(@lucas, Arel.quoted(date).cast(:datetime).send(method, '%G'))
+          end
         end
       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 %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'))
+        %i[format format_date].each do |method|
+          assert_equal 'Mon, 03 Mar 14', t(@lucas, @updated_at.send(method, '%a, %d %b %y'))
+          assert_equal 'Monday, 03 March 14', t(@lucas, @updated_at.send(method, '%A, %d %B %y'))
+        end
 
         skip "#{ENV['DB']} does not support ALLCAPS month and day names" if ['mysql'].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'))
+        %i[format format_date].each do |method|
+
+          assert_equal 'Mon, 03 MAR 14', t(@lucas, @updated_at.send(method, '%a, %d %^b %y'))
+          assert_equal 'Monday, 03 MARCH 14', t(@lucas, @updated_at.send(method, '%A, %d %^B %y'))
+        end
       end
 
       def switch_to_lang(lang)
@@ -518,28 +591,30 @@ 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.
-        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'))
+        %i[format format_date].each do |method|
+          begin
+            switch_to_lang(:en)
+            case ENV['DB']
+            when 'mysql', 'postgresql'
+              assert_equal 'Mon, 03 Mar 14', t(@lucas, @updated_at.send(method, '%a, %d %b %y'))
+              assert_equal 'Monday, 03 March 14', t(@lucas, @updated_at.send(method, '%A, %d %B %y'))
+            when 'mssql'
+              assert_equal 'Monday, 03 March 2014', t(@lucas, @updated_at.send(method, '%A, %d %B %y'))
+            end
+            switch_to_lang(:fr)
+            case ENV['DB']
+            when 'mysql'
+              assert_equal 'lun, 03 mar 14', t(@lucas, @updated_at.send(method, '%a, %d %b %y'))
+              assert_equal 'lundi, 03 mars 14', t(@lucas, @updated_at.send(method, '%A, %d %B %y'))
+            when 'postgresql'
+              assert_equal 'Lun., 03 Mars 14', t(@lucas, @updated_at.send(method, '%a, %d %b %y'))
+              assert_equal 'Lundi, 03 Mars 14', t(@lucas, @updated_at.send(method, '%A, %d %B %y'))
+            when 'mssql'
+              assert_equal 'lundi, 03 mars 2014', t(@lucas, @updated_at.send(method, '%A, %d %B %y'))
+            end
+          ensure
+            switch_to_lang(:en)
           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
       end
 
@@ -565,6 +640,25 @@ 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 '2016-05-23', t(@myung, @created_at.coalesce_blank(Date.new(2022, 1, 1)).format_date('%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
@@ -577,7 +671,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
@@ -654,8 +748,10 @@ module ArelExtensions
                         t(@lucas, (@updated_at + Arel.duration('mn', (@updated_at.hour * 60 + @updated_at.minute))))
 
         assert_includes ['2024-03-03'], t(@lucas, (@updated_at + durPos).format('%Y-%m-%d'))
+        assert_includes ['2024-03-03'], t(@lucas, (@updated_at + durPos).format_date('%Y-%m-%d'))
         # puts (@updated_at - durPos).to_sql
         assert_includes ['2004-03-03'], t(@lucas, (@updated_at - durPos).format('%Y-%m-%d'))
+        assert_includes ['2004-03-03'], t(@lucas, (@updated_at - durPos).format_date('%Y-%m-%d'))
 
 
         # we test with the ruby object or the string because some adapters don't return an object Date
@@ -690,6 +786,30 @@ 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_equal '2016-05-23', t(@myung, @created_at.if_present.format_date('%Y-%m-%d'))
+        assert_nil t(@laure, @comments.if_present)
+
+        assert_nil t(@nilly, @duration.if_present.format('%Y-%m-%d'))
+        assert_nil t(@nilly, @duration.if_present.format_date('%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'))
+          assert_nil t(@laure, @comments.cast(:date).if_present.format_date('%Y-%m-%d'))
+        else
+          assert_nil t(@laure, @comments.if_present.format('%Y-%m-%d'))
+          assert_nil t(@laure, @comments.if_present.format_date('%Y-%m-%d'))
+        end
+      end
+
       def test_is_null
         # puts User.where(@age.is_null).select(@name).to_sql
         # puts @age.is_null
@@ -725,7 +845,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
@@ -845,8 +965,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

data/version_v1.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = '1.3.5'.freeze
+  VERSION = '1.3.7'.freeze
 end

data/version_v2.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = '2.1.5'.freeze
+  VERSION = '2.1.7'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arel_extensions
 version: !ruby/object:Gem::Version
-  version: 2.1.5
+  version: 2.1.7
 platform: ruby
 authors:
 - Yann Azoury
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-25 00:00:00.000000000 Z
+date: 2023-01-27 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,6 +72,7 @@ files:
 - ".rubocop.yml"
 - Gemfile
 - MIT-LICENSE.txt
+- NEWS.md
 - README.md
 - Rakefile
 - SQL_Challenges.md
@@ -94,8 +81,8 @@ files:
 - 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
@@ -136,6 +123,7 @@ files:
 - lib/arel_extensions/nodes/find_in_set.rb
 - lib/arel_extensions/nodes/floor.rb
 - lib/arel_extensions/nodes/format.rb
+- lib/arel_extensions/nodes/formatted_date.rb
 - lib/arel_extensions/nodes/formatted_number.rb
 - lib/arel_extensions/nodes/function.rb
 - lib/arel_extensions/nodes/is_null.rb
@@ -150,7 +138,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
@@ -218,7 +208,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.5
 signing_key: 
 specification_version: 4
 summary: Extending Arel