arel_extensions 2.1.4 → 2.1.5

data/test/support/fake_record.rb

@@ -66,7 +66,7 @@ module FakeRecord
     end
 
     def in_clause_length
-      10000
+      10_000
     end
 
     def quote thing, column = nil

data/test/visitors/test_bulk_insert_oracle.rb

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

data/test/visitors/test_bulk_insert_sqlite.rb

@@ -8,7 +8,7 @@ module ArelExtensions
         @visitor = Arel::Visitors::SQLite.new @conn.connection
         @table = Arel::Table.new(:users)
         Arel::Table.engine = @conn
-        @cols = ['id', 'name', 'comments', 'created_at']
+        @cols = %w[id name comments created_at]
         @data = [
           [23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'],
           [25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']

data/test/visitors/test_bulk_insert_to_sql.rb

@@ -8,7 +8,7 @@ module ArelExtensions
         Arel::Table.engine = @conn
         @visitor = Arel::Visitors::ToSql.new @conn.connection
         @table = Arel::Table.new(:users)
-        @cols = ['id', 'name', 'comments', 'created_at']
+        @cols = %w[id name comments created_at]
         @data = [
           [23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'],
           [25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']

data/test/visitors/test_to_sql.rb

@@ -11,7 +11,7 @@ module ArelExtensions
           # test become flaky.
           #
           # The first time `Arel::Table.engine` is called
-          # from `ArelExtenstions::column_of_via_arel_table(table_name, column_name)`
+          # from `ArelExtensions.column_of_via_arel_table(table_name, column_name)`
           # in   `lib/arel_extensions/helpers.rb`
           # will almost always fail. It's important to note that when the test
           # fails, it's always on 1 test case, and every subsequent test that
@@ -273,13 +273,13 @@ module ArelExtensions
         c = @table.project(@table[:name])
         _(compile(c.union_all(c)))
           .must_be_like %{(SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users")}
-        _((c.union_all(c)).to_sql)
+        _(c.union_all(c).to_sql)
           .must_be_like %{(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)
+        _((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)).as('union_table').to_sql)
           .must_be_like %{((SELECT "users"."name" FROM "users") UNION ALL (SELECT "users"."name" FROM "users")) union_table}
@@ -576,7 +576,7 @@ module ArelExtensions
         end
       end
 
-      puts 'AREL VERSION : ' + Arel::VERSION.to_s
+      puts "AREL VERSION: #{Arel::VERSION}"
     end
   end
 end

data/test/with_ar/all_agnostic_test.rb

@@ -193,16 +193,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
@@ -419,27 +419,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 +468,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 +485,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 +496,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 +518,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
@@ -602,8 +609,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 +665,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)
 
@@ -747,8 +754,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 +793,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 +818,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
@@ -915,7 +922,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 +963,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 +988,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.5'.freeze
 end

data/version_v2.rb

@@ -1,3 +1,3 @@
 module ArelExtensions
-  VERSION = '2.1.4'.freeze
+  VERSION = '2.1.5'.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.5
 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-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -90,6 +90,7 @@ files:
 - Rakefile
 - SQL_Challenges.md
 - TODO
+- appveyor.yml
 - arel_extensions.gemspec
 - functions.html
 - gemfiles/rails3.gemfile