activesupport 6.0.6.1 → 7.1.3.2

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string/filters"
 require "active_support/inflector"
 
 class Module
@@ -11,20 +10,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 +35,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 +59,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,12 @@ class NameError
       missing_name == name.to_s
     end
   end
+
+  private
+    UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
+    private_constant :UNBOUND_METHOD_MODULE_NAME
+
+    def real_mod_name(mod)
+      UNBOUND_METHOD_MODULE_NAME.bind_call(mod)
+    end
 end

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

@@ -7,6 +7,7 @@ class Numeric
   TERABYTE = GIGABYTE * 1024
   PETABYTE = TERABYTE * 1024
   EXABYTE  = PETABYTE * 1024
+  ZETTABYTE = EXABYTE * 1024
 
   # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
   #
@@ -63,4 +64,12 @@ class Numeric
     self * EXABYTE
   end
   alias :exabyte :exabytes
+
+  # Returns the number of bytes equivalent to the zettabytes provided.
+  #
+  #   2.zettabytes # => 2_361_183_241_434_822_606_848
+  def zettabytes
+    self * ZETTABYTE
+  end
+  alias :zettabyte :zettabytes
 end

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

@@ -2,13 +2,16 @@
 
 require "active_support/core_ext/big_decimal/conversions"
 require "active_support/number_helper"
-require "active_support/core_ext/module/deprecation"
 
 module ActiveSupport
   module NumericWithFormat
+    # \Numeric With Format
+    #
     # Provides options for converting numbers into formatted strings.
     # Options are provided for phone numbers, currency, percentage,
-    # precision, positional notation, file size and pretty printing.
+    # precision, positional notation, file size, and pretty printing.
+    #
+    # This method is aliased to <tt>to_formatted_s</tt>.
     #
     # ==== Options
     #
@@ -17,97 +20,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_fs(:phone)                                     # => "555-1234"
+    #  1235551234.to_fs(:phone)                                  # => "123-555-1234"
+    #  1235551234.to_fs(:phone, area_code: true)                 # => "(123) 555-1234"
+    #  1235551234.to_fs(:phone, delimiter: ' ')                  # => "123 555 1234"
+    #  1235551234.to_fs(:phone, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
+    #  1235551234.to_fs(:phone, country_code: 1)                 # => "+1-123-555-1234"
+    #  1235551234.to_fs(: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)')
+    #  1234567890.50.to_fs(:currency)                     # => "$1,234,567,890.50"
+    #  1234567890.506.to_fs(:currency)                    # => "$1,234,567,890.51"
+    #  1234567890.506.to_fs(:currency, precision: 3)      # => "$1,234,567,890.506"
+    #  1234567890.506.to_fs(:currency, round_mode: :down) # => "$1,234,567,890.50"
+    #  1234567890.506.to_fs(:currency, locale: :fr)       # => "1 234 567 890,51 €"
+    #  -1234567890.50.to_fs(:currency, negative_format: '(%u%n)')
     #  # => "($1,234,567,890.50)"
-    #  1234567890.50.to_s(:currency, unit: '&pound;', separator: ',', delimiter: '')
+    #  1234567890.50.to_fs(:currency, unit: '&pound;', separator: ',', delimiter: '')
     #  # => "&pound;1234567890,50"
-    #  1234567890.50.to_s(:currency, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
+    #  1234567890.50.to_fs(: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%"
-    #  1000.to_s(:percentage, locale: :fr)                    # => "1 000,000%"
-    #  100.to_s(:percentage, format: '%n  %')                 # => "100.000  %"
+    #  100.to_fs(:percentage)                                  # => "100.000%"
+    #  100.to_fs(:percentage, precision: 0)                    # => "100%"
+    #  1000.to_fs(:percentage, delimiter: '.', separator: ',') # => "1.000,000%"
+    #  302.24398923423.to_fs(:percentage, precision: 5)        # => "302.24399%"
+    #  302.24398923423.to_fs(:percentage, round_mode: :down)   # => "302.243%"
+    #  1000.to_fs(:percentage, locale: :fr)                    # => "1 000,000%"
+    #  100.to_fs(: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_fs(:delimited)                     # => "12,345,678"
+    #  12345678.05.to_fs(:delimited)                  # => "12,345,678.05"
+    #  12345678.to_fs(:delimited, delimiter: '.')     # => "12.345.678"
+    #  12345678.to_fs(:delimited, delimiter: ',')     # => "12,345,678"
+    #  12345678.05.to_fs(:delimited, separator: ' ')  # => "12,345,678 05"
+    #  12345678.05.to_fs(:delimited, locale: :fr)     # => "12 345 678,05"
+    #  98765432.98.to_fs(: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)
+    #  111.2345.to_fs(:rounded)                                      # => "111.235"
+    #  111.2345.to_fs(:rounded, precision: 2)                        # => "111.23"
+    #  111.2345.to_fs(:rounded, precision: 2, round_mode: :up)       # => "111.24"
+    #  13.to_fs(:rounded, precision: 5)                              # => "13.00000"
+    #  389.32314.to_fs(:rounded, precision: 0)                       # => "389"
+    #  111.2345.to_fs(:rounded, significant: true)                   # => "111"
+    #  111.2345.to_fs(:rounded, precision: 1, significant: true)     # => "100"
+    #  13.to_fs(:rounded, precision: 5, significant: true)           # => "13.000"
+    #  111.234.to_fs(:rounded, locale: :fr)                          # => "111,234"
+    #  13.to_fs(: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_fs(:rounded, precision: 4, significant: true)    # => "389.3"
+    #  1111.2345.to_fs(: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"
+    #  123.to_fs(:human_size)                                    # => "123 Bytes"
+    #  1234.to_fs(:human_size)                                   # => "1.21 KB"
+    #  12345.to_fs(:human_size)                                  # => "12.1 KB"
+    #  1234567.to_fs(:human_size)                                # => "1.18 MB"
+    #  1234567890.to_fs(:human_size)                             # => "1.15 GB"
+    #  1234567890123.to_fs(:human_size)                          # => "1.12 TB"
+    #  1234567890123456.to_fs(:human_size)                       # => "1.1 PB"
+    #  1234567890123456789.to_fs(:human_size)                    # => "1.07 EB"
+    #  1234567.to_fs(:human_size, precision: 2)                  # => "1.2 MB"
+    #  1234567.to_fs(:human_size, precision: 2, round_mode: :up) # => "1.3 MB"
+    #  483989.to_fs(:human_size, precision: 2)                   # => "470 KB"
+    #  1234567.to_fs(:human_size, precision: 2, separator: ',')  # => "1,2 MB"
+    #  1234567890123.to_fs(:human_size, precision: 5)            # => "1.1228 TB"
+    #  524288000.to_fs(: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,
+    #  123.to_fs(:human)                                       # => "123"
+    #  1234.to_fs(:human)                                      # => "1.23 Thousand"
+    #  12345.to_fs(:human)                                     # => "12.3 Thousand"
+    #  1234567.to_fs(:human)                                   # => "1.23 Million"
+    #  1234567890.to_fs(:human)                                # => "1.23 Billion"
+    #  1234567890123.to_fs(:human)                             # => "1.23 Trillion"
+    #  1234567890123456.to_fs(:human)                          # => "1.23 Quadrillion"
+    #  1234567890123456789.to_fs(:human)                       # => "1230 Quadrillion"
+    #  489939.to_fs(:human, precision: 2)                      # => "490 Thousand"
+    #  489939.to_fs(:human, precision: 2, round_mode: :down)   # => "480 Thousand"
+    #  489939.to_fs(:human, precision: 4)                      # => "489.9 Thousand"
+    #  1234567.to_fs(:human, precision: 4,
+    #                   significant: false)                             # => "1.2346 Million"
+    #  1234567.to_fs(:human, precision: 1,
     #                   separator: ',',
-    #                   significant: false)                   # => "1,2 Million"
-    def to_s(format = nil, options = nil)
+    #                   significant: false)                             # => "1,2 Million"
+    def to_fs(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
@@ -123,11 +131,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_formatted_s, :to_fs
   end
 end
 

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

@@ -1,11 +1,35 @@
 # 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
-  # <tt>acts_like_time?</tt>. As a result, we can do <tt>x.acts_like?(:time)</tt> and
-  # <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.
+  # Provides a way to check whether some class acts like some other class based on the existence of
+  # an appropriately-named marker method.
+  #
+  # A class that provides the same interface as <tt>SomeClass</tt> may define a marker method named
+  # <tt>acts_like_some_class?</tt> to signal its compatibility to callers of
+  # <tt>acts_like?(:some_class)</tt>.
+  #
+  # For example, Active Support extends <tt>Date</tt> to define an <tt>acts_like_date?</tt> method,
+  # and extends <tt>Time</tt> to define <tt>acts_like_time?</tt>. As a result, developers can call
+  # <tt>x.acts_like?(:time)</tt> and <tt>x.acts_like?(:date)</tt> to test duck-type compatibility,
+  # and classes that are able to act like <tt>Time</tt> can also define an <tt>acts_like_time?</tt>
+  # method to interoperate.
+  #
+  # Note that the marker method is only expected to exist. It isn't called, so its body or return
+  # value are irrelevant.
+  #
+  # ==== Example: A class that provides the same interface as <tt>String</tt>
+  #
+  # This class may define:
+  #
+  #   class Stringish
+  #     def acts_like_string?
+  #     end
+  #   end
+  #
+  # Then client code can query for duck-type-safeness this way:
+  #
+  #   Stringish.new.acts_like?(:string) # => true
+  #
   def acts_like?(duck)
     case duck
     when :time

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 key.frozen? && ::String === key
+      if ::String === key || ::Symbol === key
         hash[key] = value.deep_dup
       else
         hash.delete(key)
@@ -53,3 +53,19 @@ class Hash
     hash
   end
 end
+
+class Module
+  # Returns a copy of module or class if it's anonymous. If it's
+  # named, returns +self+.
+  #
+  #   Object.deep_dup == Object # => true
+  #   klass = Class.new
+  #   klass.deep_dup == klass # => false
+  def deep_dup
+    if name.nil?
+      super
+    else
+      self
+    end
+  end
+end

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

@@ -31,8 +31,8 @@ end
 class Method
   # Methods are not duplicable:
   #
-  #  method(:puts).duplicable? # => false
-  #  method(:puts).dup         # => TypeError: allocator undefined for Method
+  #   method(:puts).duplicable? # => false
+  #   method(:puts).dup         # => TypeError: allocator undefined for Method
   def duplicable?
     false
   end
@@ -41,8 +41,19 @@ end
 class UnboundMethod
   # Unbound methods are not duplicable:
   #
-  #  method(:puts).unbind.duplicable? # => false
-  #  method(:puts).unbind.dup         # => TypeError: allocator undefined for UnboundMethod
+  #   method(:puts).unbind.duplicable? # => false
+  #   method(:puts).unbind.dup         # => TypeError: allocator undefined for UnboundMethod
+  def duplicable?
+    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

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

@@ -1,16 +1,24 @@
 # 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:
+  # Returns true if this object is included in the argument.
+  #
+  # When argument is a +Range+, +#cover?+ is used to properly handle inclusion
+  # check within open ranges. Otherwise, argument must be any object which responds
+  # to +#include?+. Usage:
   #
   #   characters = ["Konata", "Kagami", "Tsukasa"]
   #   "Konata".in?(characters) # => true
   #
-  # This will throw an +ArgumentError+ if the argument doesn't respond
-  # to +#include?+.
+  # For non +Range+ arguments, this will throw an +ArgumentError+ if the argument
+  # doesn't respond to +#include?+.
   def in?(another_object)
-    another_object.include?(self)
+    case another_object
+    when Range
+      another_object.cover?(self)
+    else
+      another_object.include?(self)
+    end
   rescue NoMethodError
     raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
   end

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

@@ -12,19 +12,29 @@ class Object
   #
   #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
   def instance_values
-    Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
+    instance_variables.to_h do |ivar|
+      [ivar[1..-1].freeze, instance_variable_get(ivar)]
+    end
   end
 
-  # Returns an array of instance variable names as strings including "@".
-  #
-  #   class C
-  #     def initialize(x, y)
-  #       @x, @y = x, y
-  #     end
-  #   end
-  #
-  #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
-  def instance_variable_names
-    instance_variables.map(&:to_s)
+  if Symbol.method_defined?(:name) # RUBY_VERSION >= "3.0"
+    # Returns an array of instance variable names as strings including "@".
+    #
+    #   class C
+    #     def initialize(x, y)
+    #       @x, @y = x, y
+    #     end
+    #   end
+    #
+    #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
+    def instance_variable_names
+      instance_variables.map(&:name)
+    end
+  else
+    def instance_variable_names
+      variables = instance_variables
+      variables.map! { |s| s.to_s.freeze }
+      variables
+    end
   end
 end