activesupport 5.1.1 → 6.1.1

data/lib/active_support/core_ext/numeric/conversions.rb

@@ -1,138 +1,140 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/big_decimal/conversions"
 require "active_support/number_helper"
-require "active_support/core_ext/module/deprecation"
 
-module ActiveSupport::NumericWithFormat
-  # Provides options for converting numbers into formatted strings.
-  # Options are provided for phone numbers, currency, percentage,
-  # precision, positional notation, file size and pretty printing.
-  #
-  # ==== Options
-  #
-  # For details on which formats use which options, see ActiveSupport::NumberHelper
-  #
-  # ==== Examples
-  #
-  #  Phone Numbers:
-  #  5551234.to_s(:phone)                                     # => "555-1234"
-  #  1235551234.to_s(:phone)                                  # => "123-555-1234"
-  #  1235551234.to_s(:phone, area_code: true)                 # => "(123) 555-1234"
-  #  1235551234.to_s(:phone, delimiter: ' ')                  # => "123 555 1234"
-  #  1235551234.to_s(:phone, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
-  #  1235551234.to_s(:phone, country_code: 1)                 # => "+1-123-555-1234"
-  #  1235551234.to_s(:phone, country_code: 1, extension: 1343, delimiter: '.')
-  #  # => "+1.123.555.1234 x 1343"
-  #
-  #  Currency:
-  #  1234567890.50.to_s(:currency)                 # => "$1,234,567,890.50"
-  #  1234567890.506.to_s(:currency)                # => "$1,234,567,890.51"
-  #  1234567890.506.to_s(:currency, precision: 3)  # => "$1,234,567,890.506"
-  #  1234567890.506.to_s(:currency, locale: :fr)   # => "1 234 567 890,51 €"
-  #  -1234567890.50.to_s(:currency, negative_format: '(%u%n)')
-  #  # => "($1,234,567,890.50)"
-  #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '')
-  #  # => "£1234567890,50"
-  #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '', format: '%n %u')
-  #  # => "1234567890,50 £"
-  #
-  #  Percentage:
-  #  100.to_s(:percentage)                                  # => "100.000%"
-  #  100.to_s(:percentage, precision: 0)                    # => "100%"
-  #  1000.to_s(:percentage, delimiter: '.', separator: ',') # => "1.000,000%"
-  #  302.24398923423.to_s(:percentage, precision: 5)        # => "302.24399%"
-  #  1000.to_s(:percentage, locale: :fr)                    # => "1 000,000%"
-  #  100.to_s(:percentage, format: '%n  %')                 # => "100.000  %"
-  #
-  #  Delimited:
-  #  12345678.to_s(:delimited)                     # => "12,345,678"
-  #  12345678.05.to_s(:delimited)                  # => "12,345,678.05"
-  #  12345678.to_s(:delimited, delimiter: '.')     # => "12.345.678"
-  #  12345678.to_s(:delimited, delimiter: ',')     # => "12,345,678"
-  #  12345678.05.to_s(:delimited, separator: ' ')  # => "12,345,678 05"
-  #  12345678.05.to_s(:delimited, locale: :fr)     # => "12 345 678,05"
-  #  98765432.98.to_s(:delimited, delimiter: ' ', separator: ',')
-  #  # => "98 765 432,98"
-  #
-  #  Rounded:
-  #  111.2345.to_s(:rounded)                                      # => "111.235"
-  #  111.2345.to_s(:rounded, precision: 2)                        # => "111.23"
-  #  13.to_s(:rounded, precision: 5)                              # => "13.00000"
-  #  389.32314.to_s(:rounded, precision: 0)                       # => "389"
-  #  111.2345.to_s(:rounded, significant: true)                   # => "111"
-  #  111.2345.to_s(:rounded, precision: 1, significant: true)     # => "100"
-  #  13.to_s(:rounded, precision: 5, significant: true)           # => "13.000"
-  #  111.234.to_s(:rounded, locale: :fr)                          # => "111,234"
-  #  13.to_s(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
-  #  # => "13"
-  #  389.32314.to_s(:rounded, precision: 4, significant: true)    # => "389.3"
-  #  1111.2345.to_s(:rounded, precision: 2, separator: ',', delimiter: '.')
-  #  # => "1.111,23"
-  #
-  #  Human-friendly size in Bytes:
-  #  123.to_s(:human_size)                                   # => "123 Bytes"
-  #  1234.to_s(:human_size)                                  # => "1.21 KB"
-  #  12345.to_s(:human_size)                                 # => "12.1 KB"
-  #  1234567.to_s(:human_size)                               # => "1.18 MB"
-  #  1234567890.to_s(:human_size)                            # => "1.15 GB"
-  #  1234567890123.to_s(:human_size)                         # => "1.12 TB"
-  #  1234567890123456.to_s(:human_size)                      # => "1.1 PB"
-  #  1234567890123456789.to_s(:human_size)                   # => "1.07 EB"
-  #  1234567.to_s(:human_size, precision: 2)                 # => "1.2 MB"
-  #  483989.to_s(:human_size, precision: 2)                  # => "470 KB"
-  #  1234567.to_s(:human_size, precision: 2, separator: ',') # => "1,2 MB"
-  #  1234567890123.to_s(:human_size, precision: 5)           # => "1.1228 TB"
-  #  524288000.to_s(:human_size, precision: 5)               # => "500 MB"
-  #
-  #  Human-friendly format:
-  #  123.to_s(:human)                                       # => "123"
-  #  1234.to_s(:human)                                      # => "1.23 Thousand"
-  #  12345.to_s(:human)                                     # => "12.3 Thousand"
-  #  1234567.to_s(:human)                                   # => "1.23 Million"
-  #  1234567890.to_s(:human)                                # => "1.23 Billion"
-  #  1234567890123.to_s(:human)                             # => "1.23 Trillion"
-  #  1234567890123456.to_s(:human)                          # => "1.23 Quadrillion"
-  #  1234567890123456789.to_s(:human)                       # => "1230 Quadrillion"
-  #  489939.to_s(:human, precision: 2)                      # => "490 Thousand"
-  #  489939.to_s(:human, precision: 4)                      # => "489.9 Thousand"
-  #  1234567.to_s(:human, precision: 4,
-  #                   significant: false)                   # => "1.2346 Million"
-  #  1234567.to_s(:human, precision: 1,
-  #                   separator: ',',
-  #                   significant: false)                   # => "1,2 Million"
-  def to_s(format = nil, options = nil)
-    case format
-    when nil
-      super()
-    when Integer, String
-      super(format)
-    when :phone
-      return ActiveSupport::NumberHelper.number_to_phone(self, options || {})
-    when :currency
-      return ActiveSupport::NumberHelper.number_to_currency(self, options || {})
-    when :percentage
-      return ActiveSupport::NumberHelper.number_to_percentage(self, options || {})
-    when :delimited
-      return ActiveSupport::NumberHelper.number_to_delimited(self, options || {})
-    when :rounded
-      return ActiveSupport::NumberHelper.number_to_rounded(self, options || {})
-    when :human
-      return ActiveSupport::NumberHelper.number_to_human(self, options || {})
-    when :human_size
-      return ActiveSupport::NumberHelper.number_to_human_size(self, options || {})
-    when Symbol
-      super()
-    else
-      super(format)
+module ActiveSupport
+  module NumericWithFormat
+    # Provides options for converting numbers into formatted strings.
+    # Options are provided for phone numbers, currency, percentage,
+    # precision, positional notation, file size and pretty printing.
+    #
+    # ==== Options
+    #
+    # For details on which formats use which options, see ActiveSupport::NumberHelper
+    #
+    # ==== Examples
+    #
+    #  Phone Numbers:
+    #  5551234.to_s(:phone)                                     # => "555-1234"
+    #  1235551234.to_s(:phone)                                  # => "123-555-1234"
+    #  1235551234.to_s(:phone, area_code: true)                 # => "(123) 555-1234"
+    #  1235551234.to_s(:phone, delimiter: ' ')                  # => "123 555 1234"
+    #  1235551234.to_s(:phone, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
+    #  1235551234.to_s(:phone, country_code: 1)                 # => "+1-123-555-1234"
+    #  1235551234.to_s(:phone, country_code: 1, extension: 1343, delimiter: '.')
+    #  # => "+1.123.555.1234 x 1343"
+    #
+    #  Currency:
+    #  1234567890.50.to_s(:currency)                     # => "$1,234,567,890.50"
+    #  1234567890.506.to_s(:currency)                    # => "$1,234,567,890.51"
+    #  1234567890.506.to_s(:currency, precision: 3)      # => "$1,234,567,890.506"
+    #  1234567890.506.to_s(:currency, round_mode: :down) # => "$1,234,567,890.50"
+    #  1234567890.506.to_s(:currency, locale: :fr)       # => "1 234 567 890,51 €"
+    #  -1234567890.50.to_s(:currency, negative_format: '(%u%n)')
+    #  # => "($1,234,567,890.50)"
+    #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '')
+    #  # => "£1234567890,50"
+    #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '', format: '%n %u')
+    #  # => "1234567890,50 £"
+    #
+    #  Percentage:
+    #  100.to_s(:percentage)                                  # => "100.000%"
+    #  100.to_s(:percentage, precision: 0)                    # => "100%"
+    #  1000.to_s(:percentage, delimiter: '.', separator: ',') # => "1.000,000%"
+    #  302.24398923423.to_s(:percentage, precision: 5)        # => "302.24399%"
+    #  302.24398923423.to_s(:percentage, round_mode: :down)   # => "302.243%"
+    #  1000.to_s(:percentage, locale: :fr)                    # => "1 000,000%"
+    #  100.to_s(:percentage, format: '%n  %')                 # => "100.000  %"
+    #
+    #  Delimited:
+    #  12345678.to_s(:delimited)                     # => "12,345,678"
+    #  12345678.05.to_s(:delimited)                  # => "12,345,678.05"
+    #  12345678.to_s(:delimited, delimiter: '.')     # => "12.345.678"
+    #  12345678.to_s(:delimited, delimiter: ',')     # => "12,345,678"
+    #  12345678.05.to_s(:delimited, separator: ' ')  # => "12,345,678 05"
+    #  12345678.05.to_s(:delimited, locale: :fr)     # => "12 345 678,05"
+    #  98765432.98.to_s(:delimited, delimiter: ' ', separator: ',')
+    #  # => "98 765 432,98"
+    #
+    #  Rounded:
+    #  111.2345.to_s(:rounded)                                      # => "111.235"
+    #  111.2345.to_s(:rounded, precision: 2)                        # => "111.23"
+    #  111.2345.to_s(:rounded, precision: 2, round_mode: :up)       # => "111.24"
+    #  13.to_s(:rounded, precision: 5)                              # => "13.00000"
+    #  389.32314.to_s(:rounded, precision: 0)                       # => "389"
+    #  111.2345.to_s(:rounded, significant: true)                   # => "111"
+    #  111.2345.to_s(:rounded, precision: 1, significant: true)     # => "100"
+    #  13.to_s(:rounded, precision: 5, significant: true)           # => "13.000"
+    #  111.234.to_s(:rounded, locale: :fr)                          # => "111,234"
+    #  13.to_s(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
+    #  # => "13"
+    #  389.32314.to_s(:rounded, precision: 4, significant: true)    # => "389.3"
+    #  1111.2345.to_s(:rounded, precision: 2, separator: ',', delimiter: '.')
+    #  # => "1.111,23"
+    #
+    #  Human-friendly size in Bytes:
+    #  123.to_s(:human_size)                                    # => "123 Bytes"
+    #  1234.to_s(:human_size)                                   # => "1.21 KB"
+    #  12345.to_s(:human_size)                                  # => "12.1 KB"
+    #  1234567.to_s(:human_size)                                # => "1.18 MB"
+    #  1234567890.to_s(:human_size)                             # => "1.15 GB"
+    #  1234567890123.to_s(:human_size)                          # => "1.12 TB"
+    #  1234567890123456.to_s(:human_size)                       # => "1.1 PB"
+    #  1234567890123456789.to_s(:human_size)                    # => "1.07 EB"
+    #  1234567.to_s(:human_size, precision: 2)                  # => "1.2 MB"
+    #  1234567.to_s(:human_size, precision: 2, round_mode: :up) # => "1.3 MB"
+    #  483989.to_s(:human_size, precision: 2)                   # => "470 KB"
+    #  1234567.to_s(:human_size, precision: 2, separator: ',')  # => "1,2 MB"
+    #  1234567890123.to_s(:human_size, precision: 5)            # => "1.1228 TB"
+    #  524288000.to_s(:human_size, precision: 5)                # => "500 MB"
+    #
+    #  Human-friendly format:
+    #  123.to_s(:human)                                       # => "123"
+    #  1234.to_s(:human)                                      # => "1.23 Thousand"
+    #  12345.to_s(:human)                                     # => "12.3 Thousand"
+    #  1234567.to_s(:human)                                   # => "1.23 Million"
+    #  1234567890.to_s(:human)                                # => "1.23 Billion"
+    #  1234567890123.to_s(:human)                             # => "1.23 Trillion"
+    #  1234567890123456.to_s(:human)                          # => "1.23 Quadrillion"
+    #  1234567890123456789.to_s(:human)                       # => "1230 Quadrillion"
+    #  489939.to_s(:human, precision: 2)                      # => "490 Thousand"
+    #  489939.to_s(:human, precision: 2, round_mode: :down)   # => "480 Thousand"
+    #  489939.to_s(:human, precision: 4)                      # => "489.9 Thousand"
+    #  1234567.to_s(:human, precision: 4,
+    #                   significant: false)                   # => "1.2346 Million"
+    #  1234567.to_s(:human, precision: 1,
+    #                   separator: ',',
+    #                   significant: false)                   # => "1,2 Million"
+    def to_s(format = nil, options = nil)
+      case format
+      when nil
+        super()
+      when Integer, String
+        super(format)
+      when :phone
+        ActiveSupport::NumberHelper.number_to_phone(self, options || {})
+      when :currency
+        ActiveSupport::NumberHelper.number_to_currency(self, options || {})
+      when :percentage
+        ActiveSupport::NumberHelper.number_to_percentage(self, options || {})
+      when :delimited
+        ActiveSupport::NumberHelper.number_to_delimited(self, options || {})
+      when :rounded
+        ActiveSupport::NumberHelper.number_to_rounded(self, options || {})
+      when :human
+        ActiveSupport::NumberHelper.number_to_human(self, options || {})
+      when :human_size
+        ActiveSupport::NumberHelper.number_to_human_size(self, options || {})
+      when Symbol
+        super()
+      else
+        super(format)
+      end
     end
   end
 end
 
-# Ruby 2.4+ unifies Fixnum & Bignum into Integer.
-if 0.class == Integer
-  Integer.prepend ActiveSupport::NumericWithFormat
-else
-  Fixnum.prepend ActiveSupport::NumericWithFormat
-  Bignum.prepend ActiveSupport::NumericWithFormat
-end
+Integer.prepend ActiveSupport::NumericWithFormat
 Float.prepend ActiveSupport::NumericWithFormat
 BigDecimal.prepend ActiveSupport::NumericWithFormat

data/lib/active_support/core_ext/numeric/time.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/duration"
 require "active_support/core_ext/time/calculations"
 require "active_support/core_ext/time/acts_like"
@@ -5,19 +7,9 @@ require "active_support/core_ext/date/calculations"
 require "active_support/core_ext/date/acts_like"
 
 class Numeric
-  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
-  #
-  # These methods use Time#advance for precise date calculations when using from_now, ago, etc.
-  # as well as adding or subtracting their results from a Time object. For example:
-  #
-  #   # equivalent to Time.current.advance(months: 1)
-  #   1.month.from_now
-  #
-  #   # equivalent to Time.current.advance(years: 2)
-  #   2.years.from_now
+  # Returns a Duration instance matching the number of seconds provided.
   #
-  #   # equivalent to Time.current.advance(months: 4, years: 5)
-  #   (4.months + 5.years).from_now
+  #   2.seconds # => 2 seconds
   def seconds
     ActiveSupport::Duration.seconds(self)
   end
@@ -64,10 +56,10 @@ class Numeric
   alias :fortnight :fortnights
 
   # Returns the number of milliseconds equivalent to the seconds provided.
-  # Used with the standard time durations, like 1.hour.in_milliseconds --
-  # so we can feed them to JavaScript functions like getTime().
+  # Used with the standard time durations.
   #
-  #   2.in_milliseconds # => 2_000
+  #   2.in_milliseconds # => 2000
+  #   1.hour.in_milliseconds # => 3600000
   def in_milliseconds
     self * 1000
   end

data/lib/active_support/core_ext/numeric.rb

@@ -1,4 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/numeric/bytes"
 require "active_support/core_ext/numeric/time"
-require "active_support/core_ext/numeric/inquiry"
 require "active_support/core_ext/numeric/conversions"

data/lib/active_support/core_ext/object/acts_like.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Object
   # A duck-type assistant method. For example, Active Support extends Date
   # to define an <tt>acts_like_date?</tt> method, and extends Time to define
@@ -5,6 +7,15 @@ class Object
   # <tt>x.acts_like?(:date)</tt> to do duck-type-safe comparisons, since classes that
   # we want to act like Time simply need to define an <tt>acts_like_time?</tt> method.
   def acts_like?(duck)
-    respond_to? :"acts_like_#{duck}?"
+    case duck
+    when :time
+      respond_to? :acts_like_time?
+    when :date
+      respond_to? :acts_like_date?
+    when :string
+      respond_to? :acts_like_string?
+    else
+      respond_to? :"acts_like_#{duck}?"
+    end
   end
 end

data/lib/active_support/core_ext/object/blank.rb

@@ -1,8 +1,10 @@
-require "active_support/core_ext/regexp"
+# frozen_string_literal: true
+
+require "concurrent/map"
 
 class Object
   # An object is blank if it's false, empty, or a whitespace string.
-  # For example, +false+, '', '   ', +nil+, [], and {} are all blank.
+  # For example, +nil+, '', '   ', [], {}, and +false+ are all blank.
   #
   # This simplifies
   #
@@ -100,6 +102,9 @@ end
 
 class String
   BLANK_RE = /\A[[:space:]]*\z/
+  ENCODED_BLANKS = Concurrent::Map.new do |h, enc|
+    h[enc] = Regexp.new(BLANK_RE.source.encode(enc), BLANK_RE.options | Regexp::FIXEDENCODING)
+  end
 
   # A string is blank if it's empty or contains whitespaces only:
   #
@@ -117,7 +122,12 @@ class String
     # The regexp that matches blank strings is expensive. For the case of empty
     # strings we can speed up this method (~3.5x) with an empty? call. The
     # penalty for the rest of strings is marginal.
-    empty? || BLANK_RE.match?(self)
+    empty? ||
+      begin
+        BLANK_RE.match?(self)
+      rescue Encoding::CompatibilityError
+        ENCODED_BLANKS[self.encoding].match?(self)
+      end
   end
 end
 

data/lib/active_support/core_ext/object/conversions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/to_param"
 require "active_support/core_ext/object/to_query"
 require "active_support/core_ext/array/conversions"

data/lib/active_support/core_ext/object/deep_dup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/duplicable"
 
 class Object
@@ -41,7 +43,7 @@ class Hash
   def deep_dup
     hash = dup
     each_pair do |key, value|
-      if key.frozen? && ::String === key
+      if (::String === key && key.frozen?) || ::Symbol === key
         hash[key] = value.deep_dup
       else
         hash.delete(key)

data/lib/active_support/core_ext/object/duplicable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #--
 # Most objects are cloneable, but not all. For example you can't dup methods:
 #
@@ -26,93 +28,6 @@ class Object
   end
 end
 
-class NilClass
-  begin
-    nil.dup
-  rescue TypeError
-
-    # +nil+ is not duplicable:
-    #
-    #   nil.duplicable? # => false
-    #   nil.dup         # => TypeError: can't dup NilClass
-    def duplicable?
-      false
-    end
-  end
-end
-
-class FalseClass
-  begin
-    false.dup
-  rescue TypeError
-
-    # +false+ is not duplicable:
-    #
-    #   false.duplicable? # => false
-    #   false.dup         # => TypeError: can't dup FalseClass
-    def duplicable?
-      false
-    end
-  end
-end
-
-class TrueClass
-  begin
-    true.dup
-  rescue TypeError
-
-    # +true+ is not duplicable:
-    #
-    #   true.duplicable? # => false
-    #   true.dup         # => TypeError: can't dup TrueClass
-    def duplicable?
-      false
-    end
-  end
-end
-
-class Symbol
-  begin
-    :symbol.dup # Ruby 2.4.x.
-    "symbol_from_string".to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
-  rescue TypeError
-
-    # Symbols are not duplicable:
-    #
-    #   :my_symbol.duplicable? # => false
-    #   :my_symbol.dup         # => TypeError: can't dup Symbol
-    def duplicable?
-      false
-    end
-  end
-end
-
-class Numeric
-  begin
-    1.dup
-  rescue TypeError
-
-    # Numbers are not duplicable:
-    #
-    #  3.duplicable? # => false
-    #  3.dup         # => TypeError: can't dup Integer
-    def duplicable?
-      false
-    end
-  end
-end
-
-require "bigdecimal"
-class BigDecimal
-  # BigDecimals are duplicable:
-  #
-  # BigDecimal.new("1.2").duplicable? # => true
-  # BigDecimal.new("1.2").dup         # => #<BigDecimal:...,'0.12E1',18(18)>
-  def duplicable?
-    true
-  end
-end
-
 class Method
   # Methods are not duplicable:
   #
@@ -123,21 +38,11 @@ class Method
   end
 end
 
-class Complex
-  # Complexes are not duplicable:
-  #
-  # Complex(1).duplicable? # => false
-  # Complex(1).dup         # => TypeError: can't copy Complex
-  def duplicable?
-    false
-  end
-end
-
-class Rational
-  # Rationals are not duplicable:
+class UnboundMethod
+  # Unbound methods are not duplicable:
   #
-  # Rational(1).duplicable? # => false
-  # Rational(1).dup         # => TypeError: can't copy Rational
+  #  method(:puts).unbind.duplicable? # => false
+  #  method(:puts).unbind.dup         # => TypeError: allocator undefined for UnboundMethod
   def duplicable?
     false
   end

data/lib/active_support/core_ext/object/inclusion.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Object
   # Returns true if this object is included in the argument. Argument must be
   # any object which responds to +#include?+. Usage:

data/lib/active_support/core_ext/object/instance_variables.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Object
   # Returns a hash with string keys that maps instance variable names without "@" to their
   # corresponding values.

data/lib/active_support/core_ext/object/json.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 # Hack to load json gem first so we can overwrite its to_json.
 require "json"
 require "bigdecimal"
+require "ipaddr"
 require "uri/generic"
 require "pathname"
 require "active_support/core_ext/big_decimal/conversions" # for #to_s
@@ -12,6 +15,7 @@ require "active_support/core_ext/time/conversions"
 require "active_support/core_ext/date_time/conversions"
 require "active_support/core_ext/date/conversions"
 
+#--
 # The JSON gem adds a few modules to Ruby core classes containing :to_json definition, overwriting
 # their default behavior. That said, we need to define the basic to_json method in all of them,
 # otherwise they will always use to_json gem implementation, which is backwards incompatible in
@@ -42,7 +46,7 @@ module ActiveSupport
   end
 end
 
-[Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass, Enumerable].reverse_each do |klass|
+[Enumerable, Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].reverse_each do |klass|
   klass.prepend(ActiveSupport::ToJsonWithActiveSupportEncoder)
 end
 
@@ -133,6 +137,12 @@ module Enumerable
   end
 end
 
+class IO
+  def as_json(options = nil) #:nodoc:
+    to_s
+  end
+end
+
 class Range
   def as_json(options = nil) #:nodoc:
     to_s
@@ -160,7 +170,11 @@ class Hash
       self
     end
 
-    Hash[subset.map { |k, v| [k.to_s, options ? v.as_json(options.dup) : v.as_json] }]
+    result = {}
+    subset.each do |k, v|
+      result[k.to_s] = options ? v.as_json(options.dup) : v.as_json
+    end
+    result
   end
 end
 
@@ -206,6 +220,12 @@ class Pathname #:nodoc:
   end
 end
 
+class IPAddr # :nodoc:
+  def as_json(options = nil)
+    to_s
+  end
+end
+
 class Process::Status #:nodoc:
   def as_json(options = nil)
     { exitstatus: exitstatus, pid: pid }

data/lib/active_support/core_ext/object/to_param.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/to_query"

data/lib/active_support/core_ext/object/to_query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cgi"
 
 class Object
@@ -73,11 +75,14 @@ class Hash
   #
   # This method is also aliased as +to_param+.
   def to_query(namespace = nil)
-    collect do |key, value|
+    query = collect do |key, value|
       unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
         value.to_query(namespace ? "#{namespace}[#{key}]" : key)
       end
-    end.compact.sort! * "&"
+    end.compact
+
+    query.sort! unless namespace.to_s.include?("[]")
+    query.join("&")
   end
 
   alias_method :to_param, :to_query