activesupport 6.1.7.6 → 7.0.0.alpha1

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

@@ -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/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/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

@@ -4,7 +4,7 @@ require "active_support/time_with_zone"
 require "active_support/deprecation"
 
 module ActiveSupport
-  module IncludeTimeWithZone #:nodoc:
+  module IncludeTimeWithZone # :nodoc:
     # Extends the default Range#include? to support ActiveSupport::TimeWithZone.
     #
     #   (1.hour.ago..1.hour.from_now).include?(Time.current) # => true

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

@@ -106,7 +106,7 @@ class String
       self.class.new.tap do |cut|
         cut_at = truncate_at - omission.bytesize
 
-        scan(/\X/) do |grapheme|
+        each_grapheme_cluster do |grapheme|
           if cut.bytesize + grapheme.bytesize <= cut_at
             cut << grapheme
           else

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

@@ -260,7 +260,7 @@ class String
   #   'author_id'.humanize                          # => "Author"
   #   'author_id'.humanize(capitalize: false)       # => "author"
   #   '_id'.humanize                                # => "Id"
-  #   'author_id'.humanize(keep_id_suffix: true)    # => "Author Id"
+  #   'author_id'.humanize(keep_id_suffix: true)    # => "Author id"
   #
   # See ActiveSupport::Inflector.humanize.
   def humanize(capitalize: true, keep_id_suffix: false)

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

@@ -11,14 +11,6 @@ class ERB
     HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+)|(#[xX][\dA-Fa-f]+));)/
     JSON_ESCAPE_REGEXP = /[\u2028\u2029&><]/u
 
-    # Following XML requirements: https://www.w3.org/TR/REC-xml/#NT-Name
-    TAG_NAME_START_REGEXP_SET = "@:A-Z_a-z\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{2FF}\u{370}-\u{37D}\u{37F}-\u{1FFF}" \
-                                "\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}" \
-                                "\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}"
-    TAG_NAME_START_REGEXP = /[^#{TAG_NAME_START_REGEXP_SET}]/
-    TAG_NAME_FOLLOWING_REGEXP = /[^#{TAG_NAME_START_REGEXP_SET}\-.0-9\u{B7}\u{0300}-\u{036F}\u{203F}-\u{2040}]/
-    TAG_NAME_REPLACEMENT_CHAR = "_"
-
     # A utility method for escaping HTML tag characters.
     # This method is also aliased as <tt>h</tt>.
     #
@@ -123,26 +115,6 @@ class ERB
     end
 
     module_function :json_escape
-
-    # A utility method for escaping XML names of tags and names of attributes.
-    #
-    #   xml_name_escape('1 < 2 & 3')
-    #   # => "1___2___3"
-    #
-    # It follows the requirements of the specification: https://www.w3.org/TR/REC-xml/#NT-Name
-    def xml_name_escape(name)
-      name = name.to_s
-      return "" if name.blank?
-
-      starting_char = name[0].gsub(TAG_NAME_START_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
-
-      return starting_char if name.size == 1
-
-      following_chars = name[1..-1].gsub(TAG_NAME_FOLLOWING_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
-
-      starting_char + following_chars
-    end
-    module_function :xml_name_escape
   end
 end
 
@@ -158,7 +130,7 @@ class Numeric
   end
 end
 
-module ActiveSupport #:nodoc:
+module ActiveSupport # :nodoc:
   class SafeBuffer < String
     UNSAFE_STRING_METHODS = %w(
       capitalize chomp chop delete delete_prefix delete_suffix
@@ -212,31 +184,30 @@ module ActiveSupport #:nodoc:
     end
 
     def concat(value)
-      super(html_escape_interpolated_argument(value))
+      unless value.nil?
+        super(implicit_html_escape_interpolated_argument(value))
+      end
+      self
     end
     alias << concat
 
-    def bytesplice(*args, value)
-      super(*args, implicit_html_escape_interpolated_argument(value))
-    end
-
     def insert(index, value)
-      super(index, html_escape_interpolated_argument(value))
+      super(index, implicit_html_escape_interpolated_argument(value))
     end
 
     def prepend(value)
-      super(html_escape_interpolated_argument(value))
+      super(implicit_html_escape_interpolated_argument(value))
     end
 
     def replace(value)
-      super(html_escape_interpolated_argument(value))
+      super(implicit_html_escape_interpolated_argument(value))
     end
 
     def []=(*args)
       if args.length == 3
-        super(args[0], args[1], html_escape_interpolated_argument(args[2]))
+        super(args[0], args[1], implicit_html_escape_interpolated_argument(args[2]))
       else
-        super(args[0], html_escape_interpolated_argument(args[1]))
+        super(args[0], implicit_html_escape_interpolated_argument(args[1]))
       end
     end
 
@@ -254,9 +225,9 @@ module ActiveSupport #:nodoc:
     def %(args)
       case args
       when Hash
-        escaped_args = args.transform_values { |arg| html_escape_interpolated_argument(arg) }
+        escaped_args = args.transform_values { |arg| explicit_html_escape_interpolated_argument(arg) }
       else
-        escaped_args = Array(args).map { |arg| html_escape_interpolated_argument(arg) }
+        escaped_args = Array(args).map { |arg| explicit_html_escape_interpolated_argument(arg) }
       end
 
       self.class.new(super(escaped_args))
@@ -294,39 +265,60 @@ module ActiveSupport #:nodoc:
     end
 
     UNSAFE_STRING_METHODS_WITH_BACKREF.each do |unsafe_method|
-      if unsafe_method.respond_to?(unsafe_method)
-        class_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{unsafe_method}(*args, &block)             # def gsub(*args, &block)
-            if block                                      #   if block
-              to_str.#{unsafe_method}(*args) { |*params|  #     to_str.gsub(*args) { |*params|
-                set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
-                block.call(*params)                       #       block.call(*params)
-              }                                           #     }
-            else                                          #   else
-              to_str.#{unsafe_method}(*args)              #     to_str.gsub(*args)
-            end                                           #   end
-          end                                             # end
-
-          def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
-            @html_safe = false                            #   @html_safe = false
-            if block                                      #   if block
-              super(*args) { |*params|                    #     super(*args) { |*params|
-                set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
-                block.call(*params)                       #       block.call(*params)
-              }                                           #     }
-            else                                          #   else
-              super                                       #     super
-            end                                           #   end
-          end                                             # end
-        EOT
-      end
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{unsafe_method}(*args, &block)             # def gsub(*args, &block)
+          if block                                      #   if block
+            to_str.#{unsafe_method}(*args) { |*params|  #     to_str.gsub(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            to_str.#{unsafe_method}(*args)              #     to_str.gsub(*args)
+          end                                           #   end
+        end                                             # end
+
+        def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
+          @html_safe = false                            #   @html_safe = false
+          if block                                      #   if block
+            super(*args) { |*params|                    #     super(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            super                                       #     super
+          end                                           #   end
+        end                                             # end
+      EOT
     end
 
     private
-      def html_escape_interpolated_argument(arg)
+      def explicit_html_escape_interpolated_argument(arg)
         (!html_safe? || arg.html_safe?) ? arg : CGI.escapeHTML(arg.to_s)
       end
 
+      def implicit_html_escape_interpolated_argument(arg)
+        if !html_safe? || arg.html_safe?
+          arg
+        else
+          arg_string = begin
+            arg.to_str
+          rescue NoMethodError => error
+            if error.name == :to_str
+              str = arg.to_s
+              ActiveSupport::Deprecation.warn <<~MSG.squish
+                Implicit conversion of #{arg.class} into String by ActiveSupport::SafeBuffer
+                is deprecated and will be removed in Rails 7.1.
+                You must explicitly cast it to a String.
+              MSG
+              str
+            else
+              raise
+            end
+          end
+          CGI.escapeHTML(arg_string)
+        end
+      end
+
       def set_block_back_references(block, match_data)
         block.binding.eval("proc { |m| $~ = m }").call(match_data)
       rescue ArgumentError

data/lib/active_support/core_ext/symbol/starts_ends_with.rb

@@ -1,14 +1,6 @@
 # frozen_string_literal: true
 
 class Symbol
-  def start_with?(*prefixes)
-    to_s.start_with?(*prefixes)
-  end unless method_defined?(:start_with?)
-
-  def end_with?(*suffixes)
-    to_s.end_with?(*suffixes)
-  end unless method_defined?(:end_with?)
-
   alias :starts_with? :start_with?
   alias :ends_with? :end_with?
 end

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

@@ -42,8 +42,8 @@ class Time
 
     # Layers additional behavior on Time.at so that ActiveSupport::TimeWithZone and DateTime
     # instances can be used when called with a single argument
-    def at_with_coercion(*args)
-      return at_without_coercion(*args) if args.size != 1
+    def at_with_coercion(*args, **kwargs)
+      return at_without_coercion(*args, **kwargs) if args.size != 1 || !kwargs.empty?
 
       # Time.at can be called with a time or numerical value
       time_or_number = args.first
@@ -56,7 +56,6 @@ class Time
         at_without_coercion(time_or_number)
       end
     end
-    ruby2_keywords(:at_with_coercion) if respond_to?(:ruby2_keywords, true)
     alias_method :at_without_coercion, :at
     alias_method :at, :at_with_coercion
 
@@ -278,7 +277,7 @@ class Time
   end
   alias :at_end_of_minute :end_of_minute
 
-  def plus_with_duration(other) #:nodoc:
+  def plus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       other.since(self)
     else
@@ -288,7 +287,7 @@ class Time
   alias_method :plus_without_duration, :+
   alias_method :+, :plus_with_duration
 
-  def minus_with_duration(other) #:nodoc:
+  def minus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       other.until(self)
     else

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

@@ -80,24 +80,9 @@ class Time
     #   Time.find_zone! false              # => false
     #   Time.find_zone! "NOT-A-TIMEZONE"   # => ArgumentError: Invalid Timezone: NOT-A-TIMEZONE
     def find_zone!(time_zone)
-      if !time_zone || time_zone.is_a?(ActiveSupport::TimeZone)
-        time_zone
-      else
-        # Look up the timezone based on the identifier (unless we've been
-        # passed a TZInfo::Timezone)
-        unless time_zone.respond_to?(:period_for_local)
-          time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone)
-        end
+      return time_zone unless time_zone
 
-        # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
-        if time_zone.is_a?(ActiveSupport::TimeZone)
-          time_zone
-        else
-          ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
-        end
-      end
-    rescue TZInfo::InvalidTimezoneIdentifier
-      raise ArgumentError, "Invalid Timezone: #{time_zone}"
+      ActiveSupport::TimeZone[time_zone] || raise(ArgumentError, "Invalid Timezone: #{time_zone}")
     end
 
     # Returns a TimeZone instance matching the time zone provided.

data/lib/active_support/core_ext/uri.rb

@@ -2,20 +2,6 @@
 
 require "uri"
 
-if RUBY_VERSION < "2.6.0"
-  require "active_support/core_ext/module/redefine_method"
-  URI::Parser.class_eval do
-    silence_redefinition_of_method :unescape
-    def unescape(str, escaped = /%[a-fA-F\d]{2}/)
-      # TODO: Are we actually sure that ASCII == UTF-8?
-      # YK: My initial experiments say yes, but let's be sure please
-      enc = str.encoding
-      enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
-      str.dup.force_encoding(Encoding::ASCII_8BIT).gsub(escaped) { |match| [match[1, 2].hex].pack("C") }.force_encoding(enc)
-    end
-  end
-end
-
 module URI
   class << self
     def parser