activesupport 7.1.4.1 → 7.2.2.1

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("::")

data/lib/active_support/deprecation/constant_accessor.rb

@@ -2,28 +2,6 @@
 
 module ActiveSupport
   class Deprecation
-    # DeprecatedConstantAccessor transforms a constant into a deprecated one by
-    # hooking +const_missing+.
-    #
-    # It takes the names of an old (deprecated) constant and of a new constant
-    # (both in string form) and a deprecator.
-    #
-    # The deprecated constant now returns the same object as the new one rather
-    # than a proxy object, so it can be used transparently in +rescue+ blocks
-    # etc.
-    #
-    #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
-    #
-    #   # (In a later update, the original implementation of `PLANETS` has been removed.)
-    #
-    #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
-    #   include ActiveSupport::Deprecation::DeprecatedConstantAccessor
-    #   deprecate_constant 'PLANETS', 'PLANETS_POST_2006', deprecator: ActiveSupport::Deprecation.new
-    #
-    #   PLANETS.map { |planet| planet.capitalize }
-    #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
-    #        (Backtrace information…)
-    #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     module DeprecatedConstantAccessor
       def self.included(base)
         require "active_support/inflector/methods"
@@ -39,11 +17,54 @@ module ActiveSupport
             super
           end
 
-          def deprecate_constant(const_name, new_constant, message: nil, deprecator: nil)
-            ActiveSupport.deprecator.warn("DeprecatedConstantAccessor.deprecate_constant without a deprecator is deprecated") unless deprecator
-            deprecator ||= ActiveSupport::Deprecation._instance
+          # Provides a way to rename constants with a deprecation cycle in which
+          # both the old and new names work, but using the old one prints a
+          # deprecation message.
+          #
+          # In order to rename <tt>A::B</tt> to <tt>C::D</tt>, you need to delete the
+          # definition of <tt>A::B</tt> and declare the deprecation in +A+:
+          #
+          #   require "active_support/deprecation"
+          #
+          #   module A
+          #     include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+          #
+          #     deprecate_constant "B", "C::D", deprecator: ActiveSupport::Deprecation.new
+          #   end
+          #
+          # The first argument is a constant name (no colons). It is the name of
+          # the constant you want to deprecate in the enclosing class or module.
+          #
+          # The second argument is the constant path of the replacement. That
+          # has to be a full path even if the replacement is defined in the same
+          # namespace as the deprecated one was.
+          #
+          # In both cases, strings and symbols are supported.
+          #
+          # The +deprecator+ keyword argument is the object that will print the
+          # deprecation message, an instance of ActiveSupport::Deprecation.
+          #
+          # With that in place, references to <tt>A::B</tt> still work, they
+          # evaluate to <tt>C::D</tt> now, and trigger a deprecation warning:
+          #
+          #   DEPRECATION WARNING: A::B is deprecated! Use C::D instead.
+          #   (called from ...)
+          #
+          # The message can be customized with the optional +message+ keyword
+          # argument.
+          #
+          # For this to work, a +const_missing+ hook is installed. When client
+          # code references the deprecated constant, the callback prints the
+          # message and constantizes the replacement.
+          #
+          # Caveat: If the deprecated constant name is reachable in a different
+          # namespace and Ruby constant lookup finds it, the hook won't be
+          # called and the deprecation won't work as intended. This may happen,
+          # for example, if an ancestor of the enclosing namespace has a
+          # constant with the same name. This is an unsupported edge case.
+          def deprecate_constant(old_constant_name, new_constant_path, deprecator:, message: nil)
             class_variable_set(:@@_deprecated_constants, {}) unless class_variable_defined?(:@@_deprecated_constants)
-            class_variable_get(:@@_deprecated_constants)[const_name.to_s] = { new: new_constant, message: message, deprecator: deprecator }
+            class_variable_get(:@@_deprecated_constants)[old_constant_name.to_s] = { new: new_constant_path, message: message, deprecator: deprecator }
           end
         end
         base.singleton_class.prepend extension

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -3,7 +3,7 @@
 module ActiveSupport
   class Deprecation
     class DeprecationProxy # :nodoc:
-      def self.new(*args, &block)
+      def self.new(*args, **kwargs, &block)
         object = args.first
 
         return object unless object
@@ -36,11 +36,10 @@ module ActiveSupport
     #   (Backtrace)
     #   # => "#<Object:0x007fb9b34c34b0>"
     class DeprecatedObjectProxy < DeprecationProxy
-      def initialize(object, message, deprecator = nil)
+      def initialize(object, message, deprecator)
         @object = object
         @message = message
-        ActiveSupport.deprecator.warn("DeprecatedObjectProxy without a deprecator is deprecated") unless deprecator
-        @deprecator = deprecator || ActiveSupport::Deprecation._instance
+        @deprecator = deprecator
       end
 
       private
@@ -86,12 +85,11 @@ module ActiveSupport
     #   example.request.to_s
     #   # => "special_request"
     class DeprecatedInstanceVariableProxy < DeprecationProxy
-      def initialize(instance, method, var = "@#{method}", deprecator = nil)
+      def initialize(instance, method, var = "@#{method}", deprecator:)
         @instance = instance
         @method = method
         @var = var
-        ActiveSupport.deprecator.warn("DeprecatedInstanceVariableProxy without a deprecator is deprecated") unless deprecator
-        @deprecator = deprecator || ActiveSupport::Deprecation._instance
+        @deprecator = deprecator
       end
 
       private
@@ -127,13 +125,12 @@ module ActiveSupport
         super
       end
 
-      def initialize(old_const, new_const, deprecator = nil, message: "#{old_const} is deprecated! Use #{new_const} instead.")
+      def initialize(old_const, new_const, deprecator, message: "#{old_const} is deprecated! Use #{new_const} instead.")
         Kernel.require "active_support/inflector/methods"
 
         @old_const = old_const
         @new_const = new_const
-        ActiveSupport.deprecator.warn("DeprecatedConstantProxy without a deprecator is deprecated") unless deprecator
-        @deprecator = deprecator || ActiveSupport::Deprecation._instance
+        @deprecator = deprecator
         @message = message
       end
 
@@ -183,9 +180,9 @@ module ActiveSupport
           target.const_get(name)
         end
 
-        def method_missing(called, *args, &block)
+        def method_missing(...)
           @deprecator.warn(@message, caller_locations)
-          target.__send__(called, *args, &block)
+          target.__send__(...)
         end
     end
   end