activesupport 6.0.4 → 6.1.4

data/lib/active_support/core_ext/module/delegation.rb

@@ -170,7 +170,7 @@ class Module
   # The target method must be public, otherwise it will raise +NoMethodError+.
   def delegate(*methods, to: nil, prefix: nil, allow_nil: nil, private: nil)
     unless to
-      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter)."
+      raise ArgumentError, "Delegation needs a target. Supply a keyword argument 'to' (e.g. delegate :hello, to: :greeter)."
     end
 
     if prefix == true && /^[^a-z_]/.match?(to)
@@ -190,7 +190,13 @@ class Module
     to = to.to_s
     to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
 
-    method_names = methods.map do |method|
+    method_def = []
+    method_names = []
+
+    methods.map do |method|
+      method_name = prefix ? "#{method_prefix}#{method}" : method
+      method_names << method_name.to_sym
+
       # Attribute writer methods only accept one argument. Makes sure []=
       # methods still accept two arguments.
       definition = if /[^\]]=$/.match?(method)
@@ -209,34 +215,33 @@ class Module
       # whereas conceptually, from the user point of view, the delegator should
       # be doing one call.
       if allow_nil
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",
-          "_ = #{to}",
-          "if !_.nil? || nil.respond_to?(:#{method})",
-          "  _.#{method}(#{definition})",
-          "end",
-        "end"
-        ].join ";"
+        method = method.to_s
+
+        method_def <<
+          "def #{method_name}(#{definition})" <<
+          "  _ = #{to}" <<
+          "  if !_.nil? || nil.respond_to?(:#{method})" <<
+          "    _.#{method}(#{definition})" <<
+          "  end" <<
+          "end"
       else
-        exception = %(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+        method = method.to_s
+        method_name = method_name.to_s
 
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",
-          " _ = #{to}",
-          "  _.#{method}(#{definition})",
-          "rescue NoMethodError => e",
-          "  if _.nil? && e.name == :#{method}",
-          "    #{exception}",
-          "  else",
-          "    raise",
-          "  end",
+        method_def <<
+          "def #{method_name}(#{definition})" <<
+          "  _ = #{to}" <<
+          "  _.#{method}(#{definition})" <<
+          "rescue NoMethodError => e" <<
+          "  if _.nil? && e.name == :#{method}" <<
+          %(   raise DelegationError, "#{self}##{method_name} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}") <<
+          "  else" <<
+          "    raise" <<
+          "  end" <<
           "end"
-        ].join ";"
       end
-
-      module_eval(method_def, file, line)
     end
-
+    module_eval(method_def.join(";"), file, line)
     private(*method_names) if private
     method_names
   end
@@ -280,13 +285,14 @@ class Module
   # variables, methods, constants, etc.
   #
   # The delegated method must be public on the target, otherwise it will
-  # raise +NoMethodError+.
+  # raise +DelegationError+. If you wish to instead return +nil+,
+  # use the <tt>:allow_nil</tt> option.
   #
   # The <tt>marshal_dump</tt> and <tt>_dump</tt> methods are exempt from
   # delegation due to possible interference when calling
   # <tt>Marshal.dump(object)</tt>, should the delegation target method
   # of <tt>object</tt> add or remove instance variables.
-  def delegate_missing_to(target)
+  def delegate_missing_to(target, allow_nil: nil)
     target = target.to_s
     target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
 
@@ -307,7 +313,11 @@ class Module
             super
           rescue NoMethodError
             if #{target}.nil?
-              raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
+              if #{allow_nil == true}
+                nil
+              else
+                raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
+              end
             else
               raise
             end

data/lib/active_support/core_ext/module/introspection.rb

@@ -11,20 +11,12 @@ class Module
     if defined?(@parent_name)
       @parent_name
     else
-      parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+      parent_name = name =~ /::[^:]+\z/ ? -$` : nil
       @parent_name = parent_name unless frozen?
       parent_name
     end
   end
 
-  def parent_name
-    ActiveSupport::Deprecation.warn(<<-MSG.squish)
-      `Module#parent_name` has been renamed to `module_parent_name`.
-      `parent_name` is deprecated and will be removed in Rails 6.1.
-    MSG
-    module_parent_name
-  end
-
   # Returns the module which contains this one according to its name.
   #
   #   module M
@@ -44,14 +36,6 @@ class Module
     module_parent_name ? ActiveSupport::Inflector.constantize(module_parent_name) : Object
   end
 
-  def parent
-    ActiveSupport::Deprecation.warn(<<-MSG.squish)
-      `Module#parent` has been renamed to `module_parent`.
-      `parent` is deprecated and will be removed in Rails 6.1.
-    MSG
-    module_parent
-  end
-
   # Returns all the parents of this module according to its name, ordered from
   # nested outwards. The receiver is not contained within the result.
   #
@@ -76,12 +60,4 @@ class Module
     parents << Object unless parents.include? Object
     parents
   end
-
-  def parents
-    ActiveSupport::Deprecation.warn(<<-MSG.squish)
-      `Module#parents` has been renamed to `module_parents`.
-      `parents` is deprecated and will be removed in Rails 6.1.
-    MSG
-    module_parents
-  end
 end

data/lib/active_support/core_ext/name_error.rb

@@ -14,9 +14,22 @@ class NameError
     # It extends NameError#message with spell corrections which are SLOW.
     # We should use original_message message instead.
     message = respond_to?(:original_message) ? original_message : self.message
+    return unless message.start_with?("uninitialized constant ")
 
-    if /undefined local variable or method/ !~ message
-      $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
+    receiver = begin
+      self.receiver
+    rescue ArgumentError
+      nil
+    end
+
+    if receiver == Object
+      name.to_s
+    elsif receiver
+      "#{real_mod_name(receiver)}::#{self.name}"
+    else
+      if match = message.match(/((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/)
+        match[1]
+      end
     end
   end
 
@@ -35,4 +48,18 @@ class NameError
       missing_name == name.to_s
     end
   end
+
+  private
+    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
+    end
 end

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

@@ -2,7 +2,6 @@
 
 require "active_support/core_ext/big_decimal/conversions"
 require "active_support/number_helper"
-require "active_support/core_ext/module/deprecation"
 
 module ActiveSupport
   module NumericWithFormat
@@ -27,10 +26,11 @@ module ActiveSupport
     #  # => "+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)                     # => "$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: '')
@@ -43,6 +43,7 @@ module ActiveSupport
     #  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  %"
     #
@@ -59,6 +60,7 @@ module ActiveSupport
     #  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"
@@ -72,19 +74,20 @@ module ActiveSupport
     #  # => "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"
+    #  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"
@@ -96,6 +99,7 @@ module ActiveSupport
     #  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"

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 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/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
@@ -169,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
 
@@ -215,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/try.rb

@@ -145,14 +145,14 @@ class NilClass
   #
   # With +try+
   #   @person.try(:children).try(:first).try(:name)
-  def try(method_name = nil, *args)
+  def try(_method_name = nil, *)
     nil
   end
 
   # Calling +try!+ on +nil+ always returns +nil+.
   #
   #   nil.try!(:name) # => nil
-  def try!(method_name = nil, *args)
+  def try!(_method_name = nil, *)
     nil
   end
 end

data/lib/active_support/core_ext/range/compare_range.rb

@@ -15,11 +15,13 @@ module ActiveSupport
     # The given range must be fully bounded, with both start and end.
     def ===(value)
       if value.is_a?(::Range)
+        is_backwards_op = value.exclude_end? ? :>= : :>
+        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
         # 1...10 includes 1..9 but it does not include 1..10.
         # 1..10 includes 1...11 but it does not include 1...12.
         operator = exclude_end? && !value.exclude_end? ? :< : :<=
         value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.send(operator, last))
+        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
       else
         super
       end
@@ -38,11 +40,13 @@ module ActiveSupport
     # The given range must be fully bounded, with both start and end.
     def include?(value)
       if value.is_a?(::Range)
+        is_backwards_op = value.exclude_end? ? :>= : :>
+        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
         # 1...10 includes 1..9 but it does not include 1..10.
         # 1..10 includes 1...11 but it does not include 1...12.
         operator = exclude_end? && !value.exclude_end? ? :< : :<=
         value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.send(operator, last))
+        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
       else
         super
       end
@@ -61,11 +65,13 @@ module ActiveSupport
     # The given range must be fully bounded, with both start and end.
     def cover?(value)
       if value.is_a?(::Range)
+        is_backwards_op = value.exclude_end? ? :>= : :>
+        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
         # 1...10 covers 1..9 but it does not cover 1..10.
         # 1..10 covers 1...11 but it does not cover 1...12.
         operator = exclude_end? && !value.exclude_end? ? :< : :<=
         value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.send(operator, last))
+        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
       else
         super
       end

data/lib/active_support/core_ext/range/include_time_with_zone.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/time_with_zone"
+require "active_support/deprecation"
 
 module ActiveSupport
   module IncludeTimeWithZone #:nodoc:
@@ -9,9 +10,13 @@ module ActiveSupport
     #   (1.hour.ago..1.hour.from_now).include?(Time.current) # => true
     #
     def include?(value)
-      if self.begin.is_a?(TimeWithZone)
-        cover?(value)
-      elsif self.end.is_a?(TimeWithZone)
+      if self.begin.is_a?(TimeWithZone) || self.end.is_a?(TimeWithZone)
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          Using `Range#include?` to check the inclusion of a value in
+          a date time range is deprecated.
+          It is recommended to use `Range#cover?` instead of `Range#include?` to
+          check the inclusion of a value in a date time range.
+        MSG
         cover?(value)
       else
         super

data/lib/active_support/core_ext/regexp.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
-class Regexp #:nodoc:
+class Regexp
+  # Returns +true+ if the regexp has the multiline flag set.
+  #
+  #   (/./).multiline?  # => false
+  #   (/./m).multiline? # => true
+  #
+  #   Regexp.new(".").multiline?                    # => false
+  #   Regexp.new(".", Regexp::MULTILINE).multiline? # => true
   def multiline?
     options & MULTILINE == MULTILINE
   end

data/lib/active_support/core_ext/string/access.rb

@@ -44,7 +44,7 @@ class String
   #   str.from(0).to(-1) # => "hello"
   #   str.from(1).to(-2) # => "ell"
   def from(position)
-    self[position..-1]
+    self[position, length]
   end
 
   # Returns a substring from the beginning of the string to the given position.
@@ -61,7 +61,8 @@ class String
   #   str.from(0).to(-1) # => "hello"
   #   str.from(1).to(-2) # => "ell"
   def to(position)
-    self[0..position]
+    position += size if position < 0
+    self[0, position + 1] || +""
   end
 
   # Returns the first character. If a limit is supplied, returns a substring
@@ -75,17 +76,7 @@ class String
   #   str.first(0) # => ""
   #   str.first(6) # => "hello"
   def first(limit = 1)
-    ActiveSupport::Deprecation.warn(
-      "Calling String#first with a negative integer limit " \
-      "will raise an ArgumentError in Rails 6.1."
-    ) if limit < 0
-    if limit == 0
-      ""
-    elsif limit >= size
-      dup
-    else
-      to(limit - 1)
-    end
+    self[0, limit] || raise(ArgumentError, "negative limit")
   end
 
   # Returns the last character of the string. If a limit is supplied, returns a substring
@@ -99,16 +90,6 @@ class String
   #   str.last(0) # => ""
   #   str.last(6) # => "hello"
   def last(limit = 1)
-    ActiveSupport::Deprecation.warn(
-      "Calling String#last with a negative integer limit " \
-      "will raise an ArgumentError in Rails 6.1."
-    ) if limit < 0
-    if limit == 0
-      ""
-    elsif limit >= size
-      dup
-    else
-      from(-limit)
-    end
+    self[[length - limit, 0].max, limit] || raise(ArgumentError, "negative limit")
   end
 end

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

@@ -18,6 +18,7 @@ class String
   #   "2012-12-13T06:12".to_time         # => 2012-12-13 06:12:00 +0100
   #   "2012-12-13T06:12".to_time(:utc)   # => 2012-12-13 06:12:00 UTC
   #   "12/13/2012".to_time               # => ArgumentError: argument out of range
+  #   "1604326192".to_time               # => ArgumentError: argument out of range
   def to_time(form = :local)
     parts = Date._parse(self, false)
     used_keys = %i(year mon mday hour min sec sec_fraction offset)

data/lib/active_support/core_ext/string/inflections.rb

@@ -30,6 +30,8 @@ class String
   #   'apple'.pluralize(2)         # => "apples"
   #   'ley'.pluralize(:es)         # => "leyes"
   #   'ley'.pluralize(1, :es)      # => "ley"
+  #
+  # See ActiveSupport::Inflector.pluralize.
   def pluralize(count = nil, locale = :en)
     locale = count if count.is_a?(Symbol)
     if count == 1
@@ -53,28 +55,34 @@ class String
   #   'the blue mailmen'.singularize # => "the blue mailman"
   #   'CamelOctopi'.singularize      # => "CamelOctopus"
   #   'leyes'.singularize(:es)       # => "ley"
+  #
+  # See ActiveSupport::Inflector.singularize.
   def singularize(locale = :en)
     ActiveSupport::Inflector.singularize(self, locale)
   end
 
   # +constantize+ tries to find a declared constant with the name specified
   # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.  See ActiveSupport::Inflector.constantize
+  # or is not initialized.
   #
   #   'Module'.constantize  # => Module
   #   'Class'.constantize   # => Class
   #   'blargle'.constantize # => NameError: wrong constant name blargle
+  #
+  # See ActiveSupport::Inflector.constantize.
   def constantize
     ActiveSupport::Inflector.constantize(self)
   end
 
   # +safe_constantize+ tries to find a declared constant with the name specified
   # in the string. It returns +nil+ when the name is not in CamelCase
-  # or is not initialized.  See ActiveSupport::Inflector.safe_constantize
+  # or is not initialized.
   #
   #   'Module'.safe_constantize  # => Module
   #   'Class'.safe_constantize   # => Class
   #   'blargle'.safe_constantize # => nil
+  #
+  # See ActiveSupport::Inflector.safe_constantize.
   def safe_constantize
     ActiveSupport::Inflector.safe_constantize(self)
   end
@@ -88,6 +96,10 @@ class String
   #   'active_record'.camelize(:lower)        # => "activeRecord"
   #   'active_record/errors'.camelize         # => "ActiveRecord::Errors"
   #   'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"
+  #
+  # +camelize+ is also aliased as +camelcase+.
+  #
+  # See ActiveSupport::Inflector.camelize.
   def camelize(first_letter = :upper)
     case first_letter
     when :upper
@@ -108,11 +120,13 @@ class String
   # optional parameter +keep_id_suffix+ to true.
   # By default, this parameter is false.
   #
-  # +titleize+ is also aliased as +titlecase+.
-  #
   #   'man from the boondocks'.titleize                       # => "Man From The Boondocks"
   #   'x-men: the last stand'.titleize                        # => "X Men: The Last Stand"
   #   'string_ending_with_id'.titleize(keep_id_suffix: true)  # => "String Ending With Id"
+  #
+  # +titleize+ is also aliased as +titlecase+.
+  #
+  # See ActiveSupport::Inflector.titleize.
   def titleize(keep_id_suffix: false)
     ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
   end
@@ -124,6 +138,8 @@ class String
   #
   #   'ActiveModel'.underscore         # => "active_model"
   #   'ActiveModel::Errors'.underscore # => "active_model/errors"
+  #
+  # See ActiveSupport::Inflector.underscore.
   def underscore
     ActiveSupport::Inflector.underscore(self)
   end
@@ -131,6 +147,8 @@ class String
   # Replaces underscores with dashes in the string.
   #
   #   'puni_puni'.dasherize # => "puni-puni"
+  #
+  # See ActiveSupport::Inflector.dasherize.
   def dasherize
     ActiveSupport::Inflector.dasherize(self)
   end
@@ -142,6 +160,8 @@ class String
   #   '::Inflections'.demodulize                         # => "Inflections"
   #   ''.demodulize                                      # => ''
   #
+  # See ActiveSupport::Inflector.demodulize.
+  #
   # See also +deconstantize+.
   def demodulize
     ActiveSupport::Inflector.demodulize(self)
@@ -155,6 +175,8 @@ class String
   #   '::String'.deconstantize    # => ""
   #   ''.deconstantize            # => ""
   #
+  # See ActiveSupport::Inflector.deconstantize.
+  #
   # See also +demodulize+.
   def deconstantize
     ActiveSupport::Inflector.deconstantize(self)
@@ -192,6 +214,8 @@ class String
   #
   #   <%= link_to(@person.name, person_path) %>
   #   # => <a href="/person/1-Donald-E-Knuth">Donald E. Knuth</a>
+  #
+  # See ActiveSupport::Inflector.parameterize.
   def parameterize(separator: "-", preserve_case: false, locale: nil)
     ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case, locale: locale)
   end
@@ -202,6 +226,8 @@ class String
   #   'RawScaledScorer'.tableize # => "raw_scaled_scorers"
   #   'ham_and_egg'.tableize     # => "ham_and_eggs"
   #   'fancyCategory'.tableize   # => "fancy_categories"
+  #
+  # See ActiveSupport::Inflector.tableize.
   def tableize
     ActiveSupport::Inflector.tableize(self)
   end
@@ -212,6 +238,8 @@ class String
   #
   #   'ham_and_eggs'.classify # => "HamAndEgg"
   #   'posts'.classify        # => "Post"
+  #
+  # See ActiveSupport::Inflector.classify.
   def classify
     ActiveSupport::Inflector.classify(self)
   end
@@ -233,6 +261,8 @@ class String
   #   'author_id'.humanize(capitalize: false)       # => "author"
   #   '_id'.humanize                                # => "Id"
   #   'author_id'.humanize(keep_id_suffix: true)    # => "Author Id"
+  #
+  # See ActiveSupport::Inflector.humanize.
   def humanize(capitalize: true, keep_id_suffix: false)
     ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
   end
@@ -242,6 +272,8 @@ class String
   #   'what a Lovely Day'.upcase_first # => "What a Lovely Day"
   #   'w'.upcase_first                 # => "W"
   #   ''.upcase_first                  # => ""
+  #
+  # See ActiveSupport::Inflector.upcase_first.
   def upcase_first
     ActiveSupport::Inflector.upcase_first(self)
   end
@@ -253,6 +285,8 @@ class String
   #   'Message'.foreign_key        # => "message_id"
   #   'Message'.foreign_key(false) # => "messageid"
   #   'Admin::Post'.foreign_key    # => "post_id"
+  #
+  # See ActiveSupport::Inflector.foreign_key.
   def foreign_key(separate_class_name_and_id_with_underscore = true)
     ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
   end

data/lib/active_support/core_ext/string/inquiry.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/string_inquirer"
+require "active_support/environment_inquirer"
 
 class String
   # Wraps the current string in the <tt>ActiveSupport::StringInquirer</tt> class,