activesupport 6.1.6.1 → 7.0.3.1

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_fs(#{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_fs(#{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_fs(#{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_fs(#{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_fs(#{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_fs(#{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_fs(#{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_fs(#{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/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 (::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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Hack to load json gem first so we can overwrite its to_json.
+# Hack to load json gem first so we can override its to_json.
 require "json"
 require "bigdecimal"
 require "ipaddr"
@@ -19,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
@@ -50,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
@@ -60,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
@@ -105,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
@@ -120,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]
@@ -179,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
@@ -189,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
@@ -199,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
@@ -208,13 +213,13 @@ class DateTime
   end
 end
 
-class URI::Generic #:nodoc:
+class URI::Generic # :nodoc:
   def as_json(options = nil)
     to_s
   end
 end
 
-class Pathname #:nodoc:
+class Pathname # :nodoc:
   def as_json(options = nil)
     to_s
   end
@@ -226,7 +231,7 @@ class IPAddr # :nodoc:
   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

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

@@ -75,8 +75,27 @@ class Object
   #     end
   #   end
   #
+  # When the block argument is omitted, the decorated Object instance is returned:
+  #
+  #   module MyStyledHelpers
+  #     def styled
+  #       with_options style: "color: red;"
+  #     end
+  #   end
+  #
+  #   # styled.link_to "I'm red", "/"
+  #   # #=> <a href="/" style="color: red;">I'm red</a>
+  #
+  #   # styled.button_tag "I'm red too!"
+  #   # #=> <button style="color: red;">I'm red too!</button>
+  #
   def with_options(options, &block)
     option_merger = ActiveSupport::OptionMerger.new(self, options)
-    block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
+
+    if block
+      block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
+    else
+      option_merger
+    end
   end
 end

data/lib/active_support/core_ext/pathname/existence.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Pathname
+  # Returns the receiver if the named file exists otherwise returns +nil+.
+  # <tt>pathname.existence</tt> is equivalent to
+  #
+  #    pathname.exist? ? pathname : nil
+  #
+  # For example, something like
+  #
+  #   content = pathname.read if pathname.exist?
+  #
+  # becomes
+  #
+  #   content = pathname.existence&.read
+  #
+  # @return [Pathname]
+  def existence
+    self if exist?
+  end
+end

data/lib/active_support/core_ext/pathname.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/pathname/existence"

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

@@ -51,31 +51,6 @@ module ActiveSupport
         super
       end
     end
-
-    # Extends the default Range#cover? to support range comparisons.
-    #  (1..5).cover?(1..5)  # => true
-    #  (1..5).cover?(2..3)  # => true
-    #  (1..5).cover?(1...6) # => true
-    #  (1..5).cover?(2..6)  # => false
-    #
-    # The native Range#cover? behavior is untouched.
-    #  ('a'..'f').cover?('c') # => true
-    #  (5..9).cover?(11) # => false
-    #
-    # 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.public_send(operator, last))
-      else
-        super
-      end
-    end
   end
 end
 

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

@@ -7,34 +7,34 @@ module ActiveSupport
         case start
         when String then "BETWEEN '#{start}' AND '#{stop}'"
         else
-          "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'"
+          "BETWEEN '#{start.to_fs(:db)}' AND '#{stop.to_fs(:db)}'"
         end
       end
     }
 
     # Convert range to a formatted string. See RANGE_FORMATS for predefined formats.
     #
+    # This method is aliased to <tt>to_formatted_s</tt>.
+    #
     #   range = (1..100)           # => 1..100
     #
     #   range.to_s                 # => "1..100"
-    #   range.to_s(:db)            # => "BETWEEN '1' AND '100'"
+    #   range.to_fs(:db)            # => "BETWEEN '1' AND '100'"
     #
     # == Adding your own range formats to to_s
     # You can add your own formats to the Range::RANGE_FORMATS hash.
     # Use the format name as the hash key and a Proc instance.
     #
     #   # config/initializers/range_formats.rb
-    #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_s(:db)} and #{stop.to_s(:db)}" }
-    def to_s(format = :default)
+    #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_fs(:db)} and #{stop.to_fs(:db)}" }
+    def to_fs(format = :default)
       if formatter = RANGE_FORMATS[format]
         formatter.call(first, last)
       else
-        super()
+        to_s
       end
     end
-
-    alias_method :to_default_s, :to_s
-    alias_method :to_formatted_s, :to_s
+    alias_method :to_formatted_s, :to_fs
   end
 end
 

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module DeprecatedRangeWithFormat # :nodoc:
+    NOT_SET = Object.new # :nodoc:
+    def to_s(format = NOT_SET)
+      if formatter = RangeWithFormat::RANGE_FORMATS[format]
+        ActiveSupport::Deprecation.warn(
+          "Range#to_s(#{format.inspect}) is deprecated. Please use Range#to_fs(#{format.inspect}) instead."
+        )
+        formatter.call(first, last)
+      elsif format == NOT_SET
+        super()
+      else
+        ActiveSupport::Deprecation.warn(
+          "Range#to_s(#{format.inspect}) is deprecated. Please use Range#to_fs(#{format.inspect}) instead."
+        )
+        super()
+      end
+    end
+    alias_method :to_default_s, :to_s
+    deprecate :to_default_s
+  end
+end
+
+Range.prepend(ActiveSupport::DeprecatedRangeWithFormat)

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

@@ -3,7 +3,7 @@
 require "active_support/time_with_zone"
 
 module ActiveSupport
-  module EachTimeWithZone #:nodoc:
+  module EachTimeWithZone # :nodoc:
     def each(&block)
       ensure_iteration_allowed
       super

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

@@ -1,28 +1,7 @@
 # frozen_string_literal: true
 
-require "active_support/time_with_zone"
-require "active_support/deprecation"
-
-module ActiveSupport
-  module IncludeTimeWithZone #:nodoc:
-    # Extends the default Range#include? to support ActiveSupport::TimeWithZone.
-    #
-    #   (1.hour.ago..1.hour.from_now).include?(Time.current) # => true
-    #
-    def include?(value)
-      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
-      end
-    end
-  end
-end
+# frozen_string_literal: true
 
-Range.prepend(ActiveSupport::IncludeTimeWithZone)
+ActiveSupport::Deprecation.warn(<<-MSG.squish)
+  `active_support/core_ext/range/include_time_with_zone` is deprecated and will be removed in Rails 7.1.
+MSG

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

@@ -5,6 +5,6 @@ class Range
   #  (1..5).overlaps?(4..6) # => true
   #  (1..5).overlaps?(7..9) # => false
   def overlaps?(other)
-    cover?(other.first) || other.cover?(first)
+    other.begin == self.begin || cover?(other.begin) || other.cover?(self.begin)
   end
 end