activesupport 6.1.0 → 7.0.0

data/lib/active_support/core_ext/name_error.rb

@@ -53,13 +53,7 @@ class NameError
     UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
     private_constant :UNBOUND_METHOD_MODULE_NAME
 
-    if UnboundMethod.method_defined?(:bind_call)
-      def real_mod_name(mod)
-        UNBOUND_METHOD_MODULE_NAME.bind_call(mod)
-      end
-    else
-      def real_mod_name(mod)
-        UNBOUND_METHOD_MODULE_NAME.bind(mod).call
-      end
+    def real_mod_name(mod)
+      UNBOUND_METHOD_MODULE_NAME.bind_call(mod)
     end
 end

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

@@ -9,6 +9,8 @@ module ActiveSupport
     # Options are provided for phone numbers, currency, percentage,
     # precision, positional notation, file size and pretty printing.
     #
+    # This method is aliased to <tt>to_fs</tt>.
+    #
     # ==== Options
     #
     # For details on which formats use which options, see ActiveSupport::NumberHelper
@@ -16,102 +18,102 @@ module ActiveSupport
     # ==== 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: '.')
+    #  5551234.to_formatted_s(:phone)                                     # => "555-1234"
+    #  1235551234.to_formatted_s(:phone)                                  # => "123-555-1234"
+    #  1235551234.to_formatted_s(:phone, area_code: true)                 # => "(123) 555-1234"
+    #  1235551234.to_formatted_s(:phone, delimiter: ' ')                  # => "123 555 1234"
+    #  1235551234.to_formatted_s(:phone, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
+    #  1235551234.to_formatted_s(:phone, country_code: 1)                 # => "+1-123-555-1234"
+    #  1235551234.to_formatted_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)')
+    #  1234567890.50.to_formatted_s(:currency)                     # => "$1,234,567,890.50"
+    #  1234567890.506.to_formatted_s(:currency)                    # => "$1,234,567,890.51"
+    #  1234567890.506.to_formatted_s(:currency, precision: 3)      # => "$1,234,567,890.506"
+    #  1234567890.506.to_formatted_s(:currency, round_mode: :down) # => "$1,234,567,890.50"
+    #  1234567890.506.to_formatted_s(:currency, locale: :fr)       # => "1 234 567 890,51 €"
+    #  -1234567890.50.to_formatted_s(:currency, negative_format: '(%u%n)')
     #  # => "($1,234,567,890.50)"
-    #  1234567890.50.to_s(:currency, unit: '&pound;', separator: ',', delimiter: '')
+    #  1234567890.50.to_formatted_s(:currency, unit: '&pound;', separator: ',', delimiter: '')
     #  # => "&pound;1234567890,50"
-    #  1234567890.50.to_s(:currency, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
+    #  1234567890.50.to_formatted_s(:currency, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
     #  # => "1234567890,50 &pound;"
     #
     #  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  %"
+    #  100.to_formatted_s(:percentage)                                  # => "100.000%"
+    #  100.to_formatted_s(:percentage, precision: 0)                    # => "100%"
+    #  1000.to_formatted_s(:percentage, delimiter: '.', separator: ',') # => "1.000,000%"
+    #  302.24398923423.to_formatted_s(:percentage, precision: 5)        # => "302.24399%"
+    #  302.24398923423.to_formatted_s(:percentage, round_mode: :down)   # => "302.243%"
+    #  1000.to_formatted_s(:percentage, locale: :fr)                    # => "1 000,000%"
+    #  100.to_formatted_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: ',')
+    #  12345678.to_formatted_s(:delimited)                     # => "12,345,678"
+    #  12345678.05.to_formatted_s(:delimited)                  # => "12,345,678.05"
+    #  12345678.to_formatted_s(:delimited, delimiter: '.')     # => "12.345.678"
+    #  12345678.to_formatted_s(:delimited, delimiter: ',')     # => "12,345,678"
+    #  12345678.05.to_formatted_s(:delimited, separator: ' ')  # => "12,345,678 05"
+    #  12345678.05.to_formatted_s(:delimited, locale: :fr)     # => "12 345 678,05"
+    #  98765432.98.to_formatted_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)
+    #  111.2345.to_formatted_s(:rounded)                                      # => "111.235"
+    #  111.2345.to_formatted_s(:rounded, precision: 2)                        # => "111.23"
+    #  111.2345.to_formatted_s(:rounded, precision: 2, round_mode: :up)       # => "111.24"
+    #  13.to_formatted_s(:rounded, precision: 5)                              # => "13.00000"
+    #  389.32314.to_formatted_s(:rounded, precision: 0)                       # => "389"
+    #  111.2345.to_formatted_s(:rounded, significant: true)                   # => "111"
+    #  111.2345.to_formatted_s(:rounded, precision: 1, significant: true)     # => "100"
+    #  13.to_formatted_s(:rounded, precision: 5, significant: true)           # => "13.000"
+    #  111.234.to_formatted_s(:rounded, locale: :fr)                          # => "111,234"
+    #  13.to_formatted_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: '.')
+    #  389.32314.to_formatted_s(:rounded, precision: 4, significant: true)    # => "389.3"
+    #  1111.2345.to_formatted_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"
+    #  123.to_formatted_s(:human_size)                                    # => "123 Bytes"
+    #  1234.to_formatted_s(:human_size)                                   # => "1.21 KB"
+    #  12345.to_formatted_s(:human_size)                                  # => "12.1 KB"
+    #  1234567.to_formatted_s(:human_size)                                # => "1.18 MB"
+    #  1234567890.to_formatted_s(:human_size)                             # => "1.15 GB"
+    #  1234567890123.to_formatted_s(:human_size)                          # => "1.12 TB"
+    #  1234567890123456.to_formatted_s(:human_size)                       # => "1.1 PB"
+    #  1234567890123456789.to_formatted_s(:human_size)                    # => "1.07 EB"
+    #  1234567.to_formatted_s(:human_size, precision: 2)                  # => "1.2 MB"
+    #  1234567.to_formatted_s(:human_size, precision: 2, round_mode: :up) # => "1.3 MB"
+    #  483989.to_formatted_s(:human_size, precision: 2)                   # => "470 KB"
+    #  1234567.to_formatted_s(:human_size, precision: 2, separator: ',')  # => "1,2 MB"
+    #  1234567890123.to_formatted_s(:human_size, precision: 5)            # => "1.1228 TB"
+    #  524288000.to_formatted_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,
+    #  123.to_formatted_s(:human)                                       # => "123"
+    #  1234.to_formatted_s(:human)                                      # => "1.23 Thousand"
+    #  12345.to_formatted_s(:human)                                     # => "12.3 Thousand"
+    #  1234567.to_formatted_s(:human)                                   # => "1.23 Million"
+    #  1234567890.to_formatted_s(:human)                                # => "1.23 Billion"
+    #  1234567890123.to_formatted_s(:human)                             # => "1.23 Trillion"
+    #  1234567890123456.to_formatted_s(:human)                          # => "1.23 Quadrillion"
+    #  1234567890123456789.to_formatted_s(:human)                       # => "1230 Quadrillion"
+    #  489939.to_formatted_s(:human, precision: 2)                      # => "490 Thousand"
+    #  489939.to_formatted_s(:human, precision: 2, round_mode: :down)   # => "480 Thousand"
+    #  489939.to_formatted_s(:human, precision: 4)                      # => "489.9 Thousand"
+    #  1234567.to_formatted_s(:human, precision: 4,
+    #                   significant: false)                             # => "1.2346 Million"
+    #  1234567.to_formatted_s(:human, precision: 1,
     #                   separator: ',',
-    #                   significant: false)                   # => "1,2 Million"
-    def to_s(format = nil, options = nil)
+    #                   significant: false)                             # => "1,2 Million"
+    def to_formatted_s(format = nil, options = nil)
+      return to_s if format.nil?
+
       case format
-      when nil
-        super()
       when Integer, String
-        super(format)
+        to_s(format)
       when :phone
         ActiveSupport::NumberHelper.number_to_phone(self, options || {})
       when :currency
@@ -127,11 +129,12 @@ module ActiveSupport
       when :human_size
         ActiveSupport::NumberHelper.number_to_human_size(self, options || {})
       when Symbol
-        super()
+        to_s
       else
-        super(format)
+        to_s(format)
       end
     end
+    alias_method :to_fs, :to_formatted_s
   end
 end
 

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module DeprecatedNumericWithFormat # :nodoc:
+    def to_s(format = nil, options = nil)
+      return super() if format.nil?
+
+      case format
+      when Integer, String
+        super(format)
+      when :phone
+        ActiveSupport::Deprecation.warn(
+          "#{self.class}#to_s(#{format.inspect}) is deprecated. Please use #{self.class}#to_formatted_s(#{format.inspect}) instead."
+        )
+        ActiveSupport::NumberHelper.number_to_phone(self, options || {})
+      when :currency
+        ActiveSupport::Deprecation.warn(
+          "#{self.class}#to_s(#{format.inspect}) is deprecated. Please use #{self.class}#to_formatted_s(#{format.inspect}) instead."
+        )
+        ActiveSupport::NumberHelper.number_to_currency(self, options || {})
+      when :percentage
+        ActiveSupport::Deprecation.warn(
+          "#{self.class}#to_s(#{format.inspect}) is deprecated. Please use #{self.class}#to_formatted_s(#{format.inspect}) instead."
+        )
+        ActiveSupport::NumberHelper.number_to_percentage(self, options || {})
+      when :delimited
+        ActiveSupport::Deprecation.warn(
+          "#{self.class}#to_s(#{format.inspect}) is deprecated. Please use #{self.class}#to_formatted_s(#{format.inspect}) instead."
+        )
+        ActiveSupport::NumberHelper.number_to_delimited(self, options || {})
+      when :rounded
+        ActiveSupport::Deprecation.warn(
+          "#{self.class}#to_s(#{format.inspect}) is deprecated. Please use #{self.class}#to_formatted_s(#{format.inspect}) instead."
+        )
+        ActiveSupport::NumberHelper.number_to_rounded(self, options || {})
+      when :human
+        ActiveSupport::Deprecation.warn(
+          "#{self.class}#to_s(#{format.inspect}) is deprecated. Please use #{self.class}#to_formatted_s(#{format.inspect}) instead."
+        )
+        ActiveSupport::NumberHelper.number_to_human(self, options || {})
+      when :human_size
+        ActiveSupport::Deprecation.warn(
+          "#{self.class}#to_s(#{format.inspect}) is deprecated. Please use #{self.class}#to_formatted_s(#{format.inspect}) instead."
+        )
+        ActiveSupport::NumberHelper.number_to_human_size(self, options || {})
+      when Symbol
+        ActiveSupport::Deprecation.warn(
+          "#{self.class}#to_s(#{format.inspect}) is deprecated. Please use #{self.class}#to_formatted_s(#{format.inspect}) instead."
+        )
+        super()
+      else
+        super(format)
+      end
+    end
+  end
+end
+
+Integer.prepend ActiveSupport::DeprecatedNumericWithFormat
+Float.prepend ActiveSupport::DeprecatedNumericWithFormat
+BigDecimal.prepend ActiveSupport::DeprecatedNumericWithFormat

data/lib/active_support/core_ext/numeric.rb

@@ -3,3 +3,4 @@
 require "active_support/core_ext/numeric/bytes"
 require "active_support/core_ext/numeric/time"
 require "active_support/core_ext/numeric/conversions"
+require "active_support/core_ext/numeric/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]

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

@@ -131,7 +131,7 @@ class String
   end
 end
 
-class Numeric #:nodoc:
+class Numeric # :nodoc:
   # No number is blank:
   #
   #   1.blank? # => false
@@ -143,7 +143,7 @@ class Numeric #:nodoc:
   end
 end
 
-class Time #:nodoc:
+class Time # :nodoc:
   # No Time is blank:
   #
   #   Time.now.blank? # => false

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

@@ -43,7 +43,7 @@ class Hash
   def deep_dup
     hash = dup
     each_pair do |key, value|
-      if (::String === key && key.frozen?) || ::Symbol === key
+      if ::String === key || ::Symbol === key
         hash[key] = value.deep_dup
       else
         hash.delete(key)

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

@@ -47,3 +47,14 @@ class UnboundMethod
     false
   end
 end
+
+require "singleton"
+
+module Singleton
+  # Singleton instances are not duplicable:
+  #
+  # Class.new.include(Singleton).instance.dup # TypeError (can't dup instance of singleton
+  def duplicable?
+    false
+  end
+end

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

@@ -3,6 +3,7 @@
 # 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
@@ -18,8 +19,7 @@ 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
-# several cases (for instance, the JSON implementation for Hash does not work) with inheritance
-# and consequently classes as ActiveSupport::OrderedHash cannot be serialized to json.
+# several cases (for instance, the JSON implementation for Hash does not work) with inheritance.
 #
 # On the other hand, we should avoid conflict with ::JSON.{generate,dump}(obj). Unfortunately, the
 # JSON gem's encoder relies on its own to_json implementation to encode objects. Since it always
@@ -49,8 +49,14 @@ end
   klass.prepend(ActiveSupport::ToJsonWithActiveSupportEncoder)
 end
 
+class Module
+  def as_json(options = nil) # :nodoc:
+    name
+  end
+end
+
 class Object
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     if respond_to?(:to_hash)
       to_hash.as_json(options)
     else
@@ -59,44 +65,44 @@ class Object
   end
 end
 
-class Struct #:nodoc:
+class Struct # :nodoc:
   def as_json(options = nil)
     Hash[members.zip(values)].as_json(options)
   end
 end
 
 class TrueClass
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
 
 class FalseClass
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
 
 class NilClass
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
 
 class String
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
 
 class Symbol
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     to_s
   end
 end
 
 class Numeric
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     self
   end
 end
@@ -104,7 +110,7 @@ end
 class Float
   # Encoding Infinity or NaN to JSON should return "null". The default returns
   # "Infinity" or "NaN" which are not valid JSON.
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     finite? ? self : nil
   end
 end
@@ -119,43 +125,43 @@ class BigDecimal
   # if the other end knows by contract that the data is supposed to be a
   # BigDecimal, it still has the chance to post-process the string and get the
   # real value.
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     finite? ? to_s : nil
   end
 end
 
 class Regexp
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     to_s
   end
 end
 
 module Enumerable
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     to_a.as_json(options)
   end
 end
 
 class IO
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     to_s
   end
 end
 
 class Range
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     to_s
   end
 end
 
 class Array
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     map { |v| options ? v.as_json(options.dup) : v.as_json }
   end
 end
 
 class Hash
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     # create a subset of the hash by applying :only or :except
     subset = if options
       if attrs = options[:only]
@@ -178,7 +184,7 @@ class Hash
 end
 
 class Time
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       xmlschema(ActiveSupport::JSON::Encoding.time_precision)
     else
@@ -188,7 +194,7 @@ class Time
 end
 
 class Date
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       strftime("%Y-%m-%d")
     else
@@ -198,7 +204,7 @@ class Date
 end
 
 class DateTime
-  def as_json(options = nil) #:nodoc:
+  def as_json(options = nil) # :nodoc:
     if ActiveSupport::JSON::Encoding.use_standard_json_time_format
       xmlschema(ActiveSupport::JSON::Encoding.time_precision)
     else
@@ -207,19 +213,25 @@ class DateTime
   end
 end
 
-class URI::Generic #:nodoc:
+class URI::Generic # :nodoc:
+  def as_json(options = nil)
+    to_s
+  end
+end
+
+class Pathname # :nodoc:
   def as_json(options = nil)
     to_s
   end
 end
 
-class Pathname #:nodoc:
+class IPAddr # :nodoc:
   def as_json(options = nil)
     to_s
   end
 end
 
-class Process::Status #:nodoc:
+class Process::Status # :nodoc:
   def as_json(options = nil)
     { exitstatus: exitstatus, pid: pid }
   end

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

@@ -75,11 +75,11 @@ class Hash
   #
   # This method is also aliased as +to_param+.
   def to_query(namespace = nil)
-    query = collect do |key, value|
+    query = filter_map do |key, value|
       unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
         value.to_query(namespace ? "#{namespace}[#{key}]" : key)
       end
-    end.compact
+    end
 
     query.sort! unless namespace.to_s.include?("[]")
     query.join("&")

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

@@ -3,32 +3,32 @@
 require "delegate"
 
 module ActiveSupport
-  module Tryable #:nodoc:
-    def try(method_name = nil, *args, &b)
-      if method_name.nil? && block_given?
-        if b.arity == 0
-          instance_eval(&b)
+  module Tryable # :nodoc:
+    def try(*args, &block)
+      if args.empty? && block_given?
+        if block.arity == 0
+          instance_eval(&block)
         else
           yield self
         end
-      elsif respond_to?(method_name)
-        public_send(method_name, *args, &b)
+      elsif respond_to?(args.first)
+        public_send(*args, &block)
       end
     end
-    ruby2_keywords(:try) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:try)
 
-    def try!(method_name = nil, *args, &b)
-      if method_name.nil? && block_given?
-        if b.arity == 0
-          instance_eval(&b)
+    def try!(*args, &block)
+      if args.empty? && block_given?
+        if block.arity == 0
+          instance_eval(&block)
         else
           yield self
         end
       else
-        public_send(method_name, *args, &b)
+        public_send(*args, &block)
       end
     end
-    ruby2_keywords(:try!) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:try!)
   end
 end
 
@@ -39,7 +39,7 @@ class Object
   # :method: try
   #
   # :call-seq:
-  #   try(*a, &b)
+  #   try(*args, &block)
   #
   # Invokes the public method whose name goes as first argument just like
   # +public_send+ does, except that if the receiver does not respond to it the
@@ -104,7 +104,7 @@ class Object
   # :method: try!
   #
   # :call-seq:
-  #   try!(*a, &b)
+  #   try!(*args, &block)
   #
   # Same as #try, but raises a +NoMethodError+ exception if the receiver is
   # not +nil+ and does not implement the tried method.
@@ -121,7 +121,7 @@ class Delegator
   # :method: try
   #
   # :call-seq:
-  #   try(a*, &b)
+  #   try(*args, &block)
   #
   # See Object#try
 
@@ -129,7 +129,7 @@ class Delegator
   # :method: try!
   #
   # :call-seq:
-  #   try!(a*, &b)
+  #   try!(*args, &block)
   #
   # See Object#try!
 end
@@ -145,14 +145,14 @@ class NilClass
   #
   # With +try+
   #   @person.try(:children).try(:first).try(:name)
-  def try(_method_name = nil, *)
+  def try(*)
     nil
   end
 
   # Calling +try!+ on +nil+ always returns +nil+.
   #
   #   nil.try!(:name) # => nil
-  def try!(_method_name = nil, *)
+  def try!(*)
     nil
   end
 end