activesupport 7.1.3.2 → 7.2.2.2

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

@@ -46,7 +46,7 @@ module ActiveSupport
 end
 
 [Enumerable, Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].reverse_each do |klass|
-  klass.prepend(ActiveSupport::ToJsonWithActiveSupportEncoder)
+  klass.include(ActiveSupport::ToJsonWithActiveSupportEncoder)
 end
 
 class Module
@@ -233,9 +233,11 @@ class Pathname # :nodoc:
   end
 end
 
-class IPAddr # :nodoc:
-  def as_json(options = nil)
-    to_s
+unless IPAddr.method_defined?(:as_json, false)
+  class IPAddr # :nodoc:
+    def as_json(options = nil)
+      to_s
+    end
   end
 end
 

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

@@ -4,11 +4,13 @@ class Object
   # Set and restore public attributes around a block.
   #
   #   client.timeout # => 5
-  #   client.with(timeout: 1) do
-  #     client.timeout # => 1
+  #   client.with(timeout: 1) do |c|
+  #     c.timeout # => 1
   #   end
   #   client.timeout # => 5
   #
+  # The receiver is yielded to the provided block.
+  #
   # This method is a shorthand for the common begin/ensure pattern:
   #
   #   old_value = object.attribute
@@ -28,7 +30,7 @@ class Object
         old_values[key] = public_send(key)
         public_send("#{key}=", value)
       end
-      yield
+      yield self
     ensure
       old_values.each do |key, old_value|
         public_send("#{key}=", old_value)

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

@@ -13,4 +13,8 @@ class Pathname
   def blank?
     to_s.empty?
   end
+
+  def present? # :nodoc:
+    !to_s.empty?
+  end
 end

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

@@ -4,7 +4,7 @@ class Range
   # Compare two ranges and see if they overlap each other
   #  (1..5).overlap?(4..6) # => true
   #  (1..5).overlap?(7..9) # => false
-  unless Range.method_defined?(:overlap?)
+  unless Range.method_defined?(:overlap?) # Ruby 3.3+
     def overlap?(other)
       raise TypeError unless other.is_a? Range
 

data/lib/active_support/core_ext/securerandom.rb

@@ -16,18 +16,8 @@ module SecureRandom
   #
   #   p SecureRandom.base58 # => "4kUgL2pdQMSCQtjE"
   #   p SecureRandom.base58(24) # => "77TMHrHJFvFDwodq8w7Ev2m7"
-  if RUBY_VERSION >= "3.3"
-    def self.base58(n = 16)
-      SecureRandom.alphanumeric(n, chars: BASE58_ALPHABET)
-    end
-  else
-    def self.base58(n = 16)
-      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
-        idx = byte % 64
-        idx = SecureRandom.random_number(58) if idx >= 58
-        BASE58_ALPHABET[idx]
-      end.join
-    end
+  def self.base58(n = 16)
+    SecureRandom.alphanumeric(n, chars: BASE58_ALPHABET)
   end
 
   # SecureRandom.base36 generates a random base36 string in lowercase.
@@ -41,17 +31,11 @@ module SecureRandom
   #
   #   p SecureRandom.base36 # => "4kugl2pdqmscqtje"
   #   p SecureRandom.base36(24) # => "77tmhrhjfvfdwodq8w7ev2m7"
-  if RUBY_VERSION >= "3.3"
-    def self.base36(n = 16)
-      SecureRandom.alphanumeric(n, chars: BASE36_ALPHABET)
-    end
-  else
-    def self.base36(n = 16)
-      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
-        idx = byte % 64
-        idx = SecureRandom.random_number(36) if idx >= 36
-        BASE36_ALPHABET[idx]
-      end.join
-    end
+  def self.base36(n = 16)
+    SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+      idx = byte % 64
+      idx = SecureRandom.random_number(36) if idx >= 36
+      BASE36_ALPHABET[idx]
+    end.join
   end
 end

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

@@ -22,7 +22,7 @@ class String
   def to_time(form = :local)
     parts = Date._parse(self, false)
     used_keys = %i(year mon mday hour min sec sec_fraction offset)
-    return if (parts.keys & used_keys).empty?
+    return if !parts.keys.intersect?(used_keys)
 
     now = Time.now
     time = Time.new(

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

@@ -109,7 +109,7 @@ class String
     when omission.bytesize == truncate_to
       omission.dup
     else
-      self.class.new.tap do |cut|
+      self.class.new.force_encoding(encoding).tap do |cut|
         cut_at = truncate_to - omission.bytesize
 
         each_grapheme_cluster do |grapheme|

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

@@ -19,7 +19,7 @@ class String
   #   >> "lj".upcase
   #   => "LJ"
   #
-  # == Method chaining
+  # == \Method chaining
   #
   # All the methods on the Chars proxy which normally return a string will return a Chars object. This allows
   # method chaining on the result of any of these methods.

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

@@ -77,13 +77,6 @@ module ActiveSupport # :nodoc:
       @html_safe = other.html_safe?
     end
 
-    def clone_empty # :nodoc:
-      ActiveSupport.deprecator.warn <<~EOM
-        ActiveSupport::SafeBuffer#clone_empty is deprecated and will be removed in Rails 7.2.
-      EOM
-      self[0, 0]
-    end
-
     def concat(value)
       unless value.nil?
         super(implicit_html_escape_interpolated_argument(value))

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

@@ -42,20 +42,20 @@ 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, **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
-
-      if time_or_number.is_a?(ActiveSupport::TimeWithZone)
-        at_without_coercion(time_or_number.to_r).getlocal
-      elsif time_or_number.is_a?(DateTime)
-        at_without_coercion(time_or_number.to_f).getlocal
+    def at_with_coercion(time_or_number, *args)
+      if args.empty?
+        if time_or_number.is_a?(ActiveSupport::TimeWithZone)
+          at_without_coercion(time_or_number.to_r).getlocal
+        elsif time_or_number.is_a?(DateTime)
+          at_without_coercion(time_or_number.to_f).getlocal
+        else
+          at_without_coercion(time_or_number)
+        end
       else
-        at_without_coercion(time_or_number)
+        at_without_coercion(time_or_number, *args)
       end
     end
+    ruby2_keywords :at_with_coercion
     alias_method :at_without_coercion, :at
     alias_method :at, :at_with_coercion
 
@@ -108,21 +108,6 @@ class Time
     subsec
   end
 
-  unless Time.method_defined?(:floor)
-    def floor(precision = 0)
-      change(nsec: 0) + subsec.floor(precision)
-    end
-  end
-
-  # Restricted Ruby version due to a bug in `Time#ceil`
-  # See https://bugs.ruby-lang.org/issues/17025 for more details
-  if RUBY_VERSION <= "2.8"
-    remove_possible_method :ceil
-    def ceil(precision = 0)
-      change(nsec: 0) + subsec.ceil(precision)
-    end
-  end
-
   # Returns a new Time where one or more of the elements have been changed according
   # to the +options+ parameter. The time options (<tt>:hour</tt>, <tt>:min</tt>,
   # <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>) reset cascadingly, so if only
@@ -159,7 +144,7 @@ class Time
       ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, new_offset)
     elsif utc?
       ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec)
-    elsif zone&.respond_to?(:utc_to_local)
+    elsif zone.respond_to?(:utc_to_local)
       new_time = ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)
 
       # When there are two occurrences of a nominal time due to DST ending,
@@ -334,7 +319,12 @@ class Time
     if other.class == Time
       compare_without_coercion(other)
     elsif other.is_a?(Time)
-      compare_without_coercion(other.to_time)
+      # also avoid ActiveSupport::TimeWithZone#to_time before Rails 8.0
+      if other.respond_to?(:comparable_time)
+        compare_without_coercion(other.comparable_time)
+      else
+        compare_without_coercion(other.to_time)
+      end
     else
       to_datetime <=> other
     end

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

@@ -13,4 +13,20 @@ class Time
   def to_time
     preserve_timezone ? self : getlocal
   end
+
+  def preserve_timezone # :nodoc:
+    active_support_local_zone == zone || super
+  end
+
+  private
+    @@active_support_local_tz = nil
+
+    def active_support_local_zone
+      @@active_support_local_zone = nil if @@active_support_local_tz != ENV["TZ"]
+      @@active_support_local_zone ||=
+        begin
+          @@active_support_local_tz = ENV["TZ"]
+          Time.new.zone
+        end
+    end
 end

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

@@ -58,8 +58,6 @@ class Time
     end
   end
   alias_method :to_formatted_s, :to_fs
-  alias_method :to_default_s, :to_s
-  deprecate to_default_s: :to_s, deprecator: ActiveSupport.deprecator
 
   # Returns a formatted string of the offset from UTC, or an alternative
   # string if the time zone is already UTC.

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

@@ -20,7 +20,7 @@ class Time
     # This method accepts any of the following:
     #
     # * A \Rails TimeZone object.
-    # * An identifier for a \Rails TimeZone object (e.g., "Eastern Time (US & Canada)", <tt>-5.hours</tt>).
+    # * An identifier for a \Rails TimeZone object (e.g., "Eastern \Time (US & Canada)", <tt>-5.hours</tt>).
     # * A +TZInfo::Timezone+ object.
     # * An identifier for a +TZInfo::Timezone+ object (e.g., "America/New_York").
     #

data/lib/active_support/core_ext.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.each do |path|
-  next if path.end_with?("core_ext/uri.rb")
   require path
 end

data/lib/active_support/current_attributes.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/callbacks"
+require "active_support/core_ext/object/with"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/delegation"
 
@@ -94,6 +95,8 @@ module ActiveSupport
 
     INVALID_ATTRIBUTE_NAMES = [:set, :reset, :resets, :instance, :before_reset, :after_reset, :reset_all, :clear_all] # :nodoc:
 
+    NOT_SET = Object.new.freeze # :nodoc:
+
     class << self
       # Returns singleton instance for this class in this thread. If none exists, one is created.
       def instance
@@ -101,7 +104,14 @@ module ActiveSupport
       end
 
       # Declares one or more attributes that will be given both class and instance accessor methods.
-      def attribute(*names)
+      #
+      # ==== Options
+      #
+      # * <tt>:default</tt> - The default value for the attributes. If the value
+      # is a proc or lambda, it will be called whenever an instance is
+      # constructed. Otherwise, the value will be duplicated with +#dup+.
+      # Default values are re-assigned when the attributes are reset.
+      def attribute(*names, default: NOT_SET)
         invalid_attribute_names = names.map(&:to_sym) & INVALID_ATTRIBUTE_NAMES
         if invalid_attribute_names.any?
           raise ArgumentError, "Restricted attribute names: #{invalid_attribute_names.join(", ")}"
@@ -124,22 +134,10 @@ module ActiveSupport
           end
         end
 
-        ActiveSupport::CodeGenerator.batch(singleton_class, __FILE__, __LINE__) do |owner|
-          names.each do |name|
-            owner.define_cached_method(name, namespace: :current_attributes_delegation) do |batch|
-              batch <<
-                "def #{name}" <<
-                "instance.#{name}" <<
-                "end"
-            end
-            owner.define_cached_method("#{name}=", namespace: :current_attributes_delegation) do |batch|
-              batch <<
-                "def #{name}=(value)" <<
-                "instance.#{name} = value" <<
-                "end"
-            end
-          end
-        end
+        Delegation.generate(singleton_class, names, to: :instance, nilable: false, signature: "")
+        Delegation.generate(singleton_class, names.map { |n| "#{n}=" }, to: :instance, nilable: false, signature: "value")
+
+        self.defaults = defaults.merge(names.index_with { default })
       end
 
       # Calls this callback before #reset is called on the instance. Used for resetting external collaborators that depend on current values.
@@ -177,25 +175,29 @@ module ActiveSupport
           @current_instances_key ||= name.to_sym
         end
 
-        def method_missing(name, *args, &block)
-          # Caches the method definition as a singleton method of the receiver.
-          #
-          # By letting #delegate handle it, we avoid an enclosure that'll capture args.
-          singleton_class.delegate name, to: :instance
-
-          send(name, *args, &block)
+        def method_missing(name, ...)
+          instance.public_send(name, ...)
         end
-        ruby2_keywords(:method_missing)
 
         def respond_to_missing?(name, _)
-          super || instance.respond_to?(name)
+          instance.respond_to?(name) || super
+        end
+
+        def method_added(name)
+          super
+          return if name == :initialize
+          return unless public_method_defined?(name)
+          return if respond_to?(name, true)
+          Delegation.generate(singleton_class, [name], to: :instance, as: self, nilable: false)
         end
     end
 
+    class_attribute :defaults, instance_writer: false, default: {}.freeze
+
     attr_accessor :attributes
 
     def initialize
-      @attributes = {}
+      @attributes = resolve_defaults
     end
 
     # Expose one or more attributes within a block. Old values are returned after the block concludes.
@@ -208,28 +210,24 @@ module ActiveSupport
     #       end
     #     end
     #   end
-    def set(set_attributes)
-      old_attributes = compute_attributes(set_attributes.keys)
-      assign_attributes(set_attributes)
-      yield
-    ensure
-      assign_attributes(old_attributes)
+    def set(attributes, &block)
+      with(**attributes, &block)
     end
 
     # Reset all attributes. Should be called before and after actions, when used as a per-request singleton.
     def reset
       run_callbacks :reset do
-        self.attributes = {}
+        self.attributes = resolve_defaults
       end
     end
 
     private
-      def assign_attributes(new_attributes)
-        new_attributes.each { |key, value| public_send("#{key}=", value) }
-      end
-
-      def compute_attributes(keys)
-        keys.index_with { |key| public_send(key) }
+      def resolve_defaults
+        defaults.each_with_object({}) do |(key, value), result|
+          if value != NOT_SET
+            result[key] = Proc === value ? value.call : value.dup
+          end
+        end
       end
   end
 end

data/lib/active_support/delegation.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "set"
+
+module ActiveSupport
+  # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
+  # option is not used.
+  class DelegationError < NoMethodError
+    class << self
+      def nil_target(method_name, target) # :nodoc:
+        new("#{method_name} delegated to #{target}, but #{target} is nil")
+      end
+    end
+  end
+
+  module Delegation # :nodoc:
+    RUBY_RESERVED_KEYWORDS = %w(__ENCODING__ __LINE__ __FILE__ alias and BEGIN begin break
+    case class def defined? do else elsif END end ensure false for if in module next nil
+    not or redo rescue retry return self super then true undef unless until when while yield)
+    RESERVED_METHOD_NAMES = (RUBY_RESERVED_KEYWORDS + %w(_ arg args block)).to_set.freeze
+
+    class << self
+      def generate(owner, methods, location: nil, to: nil, prefix: nil, allow_nil: nil, nilable: true, private: nil, as: nil, signature: nil)
+        unless to
+          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)
+          raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+        end
+
+        method_prefix = \
+          if prefix
+            "#{prefix == true ? to : prefix}_"
+          else
+            ""
+          end
+
+        location ||= caller_locations(1, 1).first
+        file, line = location.path, location.lineno
+
+        receiver = if to.is_a?(Module)
+          if to.name.nil?
+            raise ArgumentError, "Can't delegate to anonymous class or module: #{to}"
+          end
+
+          unless Inflector.safe_constantize(to.name).equal?(to)
+            raise ArgumentError, "Can't delegate to detached class or module: #{to.name}"
+          end
+
+          "::#{to.name}"
+        else
+          to.to_s
+        end
+        receiver = "self.#{receiver}" if RESERVED_METHOD_NAMES.include?(receiver)
+
+        explicit_receiver = false
+        receiver_class = if as
+          explicit_receiver = true
+          as
+        elsif to.is_a?(Module)
+          to.singleton_class
+        elsif receiver == "self.class"
+          nilable = false # self.class can't possibly be nil
+          owner.singleton_class
+        end
+
+        method_def = []
+        method_names = []
+
+        method_def << "self.private" if private
+
+        methods.each 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 signature
+              signature
+            elsif /[^\]]=\z/.match?(method)
+              "arg"
+            else
+              method_object = if receiver_class
+                begin
+                  receiver_class.public_instance_method(method)
+                rescue NameError
+                  raise if explicit_receiver
+                  # Do nothing. Fall back to `"..."`
+                end
+              end
+
+              if method_object
+                parameters = method_object.parameters
+
+                if parameters.map(&:first).intersect?([:opt, :rest, :keyreq, :key, :keyrest])
+                  "..."
+                else
+                  defn = parameters.filter_map { |type, arg| arg if type == :req }
+                  defn << "&"
+                  defn.join(", ")
+                end
+              else
+                "..."
+              end
+            end
+
+          # The following generated method calls the target exactly once, storing
+          # the returned value in a dummy variable.
+          #
+          # Reason is twofold: On one hand doing less calls is in general better.
+          # On the other hand it could be that the target has side-effects,
+          # whereas conceptually, from the user point of view, the delegator should
+          # be doing one call.
+          if nilable == false
+            method_def <<
+              "def #{method_name}(#{definition})" <<
+              "  (#{receiver}).#{method}(#{definition})" <<
+              "end"
+          elsif allow_nil
+            method = method.to_s
+
+            method_def <<
+              "def #{method_name}(#{definition})" <<
+              "  _ = #{receiver}" <<
+              "  if !_.nil? || nil.respond_to?(:#{method})" <<
+              "    _.#{method}(#{definition})" <<
+              "  end" <<
+              "end"
+          else
+            method = method.to_s
+            method_name = method_name.to_s
+
+            method_def <<
+              "def #{method_name}(#{definition})" <<
+              "  _ = #{receiver}" <<
+              "  _.#{method}(#{definition})" <<
+              "rescue NoMethodError => e" <<
+              "  if _.nil? && e.name == :#{method}" <<
+              "    raise ::ActiveSupport::DelegationError.nil_target(:#{method_name}, :'#{receiver}')" <<
+              "  else" <<
+              "    raise" <<
+              "  end" <<
+              "end"
+          end
+        end
+        owner.module_eval(method_def.join(";"), file, line)
+        method_names
+      end
+
+      def generate_method_missing(owner, target, allow_nil: nil)
+        target = target.to_s
+        target = "self.#{target}" if RESERVED_METHOD_NAMES.include?(target) || target == "__target"
+
+        if allow_nil
+          owner.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def respond_to_missing?(name, include_private = false)
+              # It may look like an oversight, but we deliberately do not pass
+              # +include_private+, because they do not get delegated.
+
+              return false if name == :marshal_dump || name == :_dump
+              #{target}.respond_to?(name) || super
+            end
+
+            def method_missing(method, ...)
+              __target = #{target}
+              if __target.nil? && !nil.respond_to?(method)
+                nil
+              elsif __target.respond_to?(method)
+                __target.public_send(method, ...)
+              else
+                super
+              end
+            end
+          RUBY
+        else
+          owner.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def respond_to_missing?(name, include_private = false)
+              # It may look like an oversight, but we deliberately do not pass
+              # +include_private+, because they do not get delegated.
+
+              return false if name == :marshal_dump || name == :_dump
+              #{target}.respond_to?(name) || super
+            end
+
+            def method_missing(method, ...)
+              __target = #{target}
+              if __target.nil? && !nil.respond_to?(method)
+                raise ::ActiveSupport::DelegationError.nil_target(method, :'#{target}')
+              elsif __target.respond_to?(method)
+                __target.public_send(method, ...)
+              else
+                super
+              end
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/active_support/dependencies/autoload.rb

@@ -27,18 +27,6 @@ module ActiveSupport
   #
   #   MyLib.eager_load!
   module Autoload
-    def self.extended(base) # :nodoc:
-      if RUBY_VERSION < "3"
-        base.class_eval do
-          @_autoloads = nil
-          @_under_path = nil
-          @_at_path = nil
-          @_eager_autoload = false
-          @_eagerloaded_constants = nil
-        end
-      end
-    end
-
     def autoload(const_name, path = @_at_path)
       unless path
         full = [name, @_under_path, const_name.to_s].compact.join("::")