activesupport 7.1.3.2 → 7.2.2.2

data/lib/active_support/core_ext/class/subclasses.rb

@@ -1,43 +1,23 @@
 # frozen_string_literal: true
 
-require "active_support/ruby_features"
 require "active_support/descendants_tracker"
 
 class Class
-  if ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
-    # Returns an array with all classes that are < than its receiver.
-    #
-    #   class C; end
-    #   C.descendants # => []
-    #
-    #   class B < C; end
-    #   C.descendants # => [B]
-    #
-    #   class A < B; end
-    #   C.descendants # => [B, A]
-    #
-    #   class D < C; end
-    #   C.descendants # => [B, A, D]
-    def descendants
-      subclasses.concat(subclasses.flat_map(&:descendants))
-    end
-  else
-    def descendants
-      ObjectSpace.each_object(singleton_class).reject do |k|
-        k.singleton_class? || k == self
-      end
-    end
-
-    # Returns an array with the direct children of +self+.
-    #
-    #   class Foo; end
-    #   class Bar < Foo; end
-    #   class Baz < Bar; end
-    #
-    #   Foo.subclasses # => [Bar]
-    def subclasses
-      descendants.select { |descendant| descendant.superclass == self }
-    end
+  # Returns an array with all classes that are < than its receiver.
+  #
+  #   class C; end
+  #   C.descendants # => []
+  #
+  #   class B < C; end
+  #   C.descendants # => [B]
+  #
+  #   class A < B; end
+  #   C.descendants # => [B, A]
+  #
+  #   class D < C; end
+  #   C.descendants # => [B, A, D]
+  def descendants
+    subclasses.concat(subclasses.flat_map(&:descendants))
   end
 
   prepend ActiveSupport::DescendantsTracker::ReloadedClassesFiltering

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

@@ -11,4 +11,8 @@ class Date # :nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end

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

@@ -56,8 +56,6 @@ class Date
     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
 
   # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005"
   def readable_inspect

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/module/redefine_method"
 
 module DateAndTime
   module Compatibility
@@ -11,7 +12,33 @@ module DateAndTime
     # of the receiver. For backwards compatibility we're overriding
     # this behavior, but new apps will have an initializer that sets
     # this to true, because the new behavior is preferred.
-    mattr_accessor :preserve_timezone, instance_writer: false, default: false
+    mattr_accessor :preserve_timezone, instance_accessor: false, default: nil
+
+    singleton_class.silence_redefinition_of_method :preserve_timezone
+
+    #--
+    # This re-implements the behaviour of the mattr_reader, instead
+    # of prepending on to it, to avoid overcomplicating a module that
+    # is in turn included in several places. This will all go away in
+    # Rails 8.0 anyway.
+    def self.preserve_timezone # :nodoc:
+      if @@preserve_timezone.nil?
+        # Only warn once, the first time the value is used (which should
+        # be the first time #to_time is called).
+        ActiveSupport.deprecator.warn(
+          "to_time will always preserve the timezone offset of the receiver in Rails 8.0. " \
+          "To opt in to the new behavior, set `ActiveSupport.to_time_preserves_timezone = true`."
+        )
+
+        @@preserve_timezone = false
+      end
+
+      @@preserve_timezone
+    end
+
+    def preserve_timezone # :nodoc:
+      Compatibility.preserve_timezone
+    end
 
     # Change the output of <tt>ActiveSupport::TimeZone.utc_to_local</tt>.
     #

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

@@ -11,4 +11,8 @@ class DateTime # :nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end

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

@@ -40,10 +40,6 @@ class DateTime
     end
   end
   alias_method :to_formatted_s, :to_fs
-  if instance_methods(false).include?(:to_s)
-    alias_method :to_default_s, :to_s
-    deprecate to_default_s: :to_s, deprecator: ActiveSupport.deprecator
-  end
 
 
   # Returns a formatted string of the offset from UTC, or an alternative

data/lib/active_support/core_ext/digest/uuid.rb

@@ -53,6 +53,12 @@ module Digest
       SecureRandom.uuid
     end
 
+    # Returns the nil UUID. This is a special form of UUID that is specified to
+    # have all 128 bits set to zero.
+    def self.nil_uuid
+      "00000000-0000-0000-0000-000000000000"
+    end
+
     def self.pack_uuid_namespace(namespace)
       if [DNS_NAMESPACE, OID_NAMESPACE, URL_NAMESPACE, X500_NAMESPACE].include?(namespace)
         namespace

data/lib/active_support/core_ext/erb/util.rb

@@ -188,6 +188,11 @@ class ERB
         else
           raise NotImplementedError, source.matched
         end
+
+        unless source.eos? || source.exist?(start_re) || source.exist?(finish_re)
+          tokens << [:TEXT, source.rest]
+          source.terminate
+        end
       end
 
       tokens

data/lib/active_support/core_ext/hash/keys.rb

@@ -8,13 +8,13 @@ class Hash
   #   hash.stringify_keys
   #   # => {"name"=>"Rob", "age"=>"28"}
   def stringify_keys
-    transform_keys(&:to_s)
+    transform_keys { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Destructively converts all keys to strings. Same as
   # +stringify_keys+, but modifies +self+.
   def stringify_keys!
-    transform_keys!(&:to_s)
+    transform_keys! { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Returns a new hash with all keys converted to symbols, as long as
@@ -82,14 +82,14 @@ class Hash
   #   hash.deep_stringify_keys
   #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
   def deep_stringify_keys
-    deep_transform_keys(&:to_s)
+    deep_transform_keys { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Destructively converts all keys to strings.
   # This includes the keys from the root hash and from all
   # nested hashes and arrays.
   def deep_stringify_keys!
-    deep_transform_keys!(&:to_s)
+    deep_transform_keys! { |k| Symbol === k ? k.name : k.to_s }
   end
 
   # Returns a new hash with all keys converted to symbols, as long as

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

@@ -19,16 +19,27 @@ class Module
   end
   alias_method :attr_internal, :attr_internal_accessor
 
-  class << self; attr_accessor :attr_internal_naming_format end
-  self.attr_internal_naming_format = "@_%s"
+  class << self
+    attr_reader :attr_internal_naming_format
 
-  private
-    def attr_internal_ivar_name(attr)
-      Module.attr_internal_naming_format % attr
+    def attr_internal_naming_format=(format)
+      if format.start_with?("@")
+        ActiveSupport.deprecator.warn <<~MESSAGE
+          Setting `attr_internal_naming_format` with a `@` prefix is deprecated and will be removed in Rails 8.0.
+
+          You can simply replace #{format.inspect} by #{format.delete_prefix("@").inspect}.
+        MESSAGE
+
+        format = format.delete_prefix("@")
+      end
+      @attr_internal_naming_format = format
     end
+  end
+  self.attr_internal_naming_format = "_%s"
 
+  private
     def attr_internal_define(attr_name, type)
-      internal_name = attr_internal_ivar_name(attr_name).delete_prefix("@")
+      internal_name = Module.attr_internal_naming_format % attr_name
       # use native attr_* methods as they are faster on some Ruby implementations
       public_send("attr_#{type}", internal_name)
       attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer

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

@@ -1,19 +1,8 @@
 # frozen_string_literal: true
 
-require "set"
-
 class Module
-  # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
-  # option is not used.
-  class DelegationError < NoMethodError; end
-
-  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)
-  DELEGATION_RESERVED_KEYWORDS = %w(_ arg args block)
-  DELEGATION_RESERVED_METHOD_NAMES = Set.new(
-    RUBY_RESERVED_KEYWORDS + DELEGATION_RESERVED_KEYWORDS
-  ).freeze
+  require "active_support/delegation"
+  DelegationError = ActiveSupport::DelegationError # :nodoc:
 
   # Provides a +delegate+ class method to easily expose contained objects'
   # public methods as your own.
@@ -21,7 +10,7 @@ class Module
   # ==== Options
   # * <tt>:to</tt> - Specifies the target object name as a symbol or string
   # * <tt>:prefix</tt> - Prefixes the new method with the target name or a custom prefix
-  # * <tt>:allow_nil</tt> - If set to true, prevents a +Module::DelegationError+
+  # * <tt>:allow_nil</tt> - If set to true, prevents a +ActiveSupport::DelegationError+
   #   from being raised
   # * <tt>:private</tt> - If set to true, changes method visibility to private
   #
@@ -132,7 +121,7 @@ class Module
   #   User.new.age # => 2
   #
   # If the target is +nil+ and does not respond to the delegated method a
-  # +Module::DelegationError+ is raised. If you wish to instead return +nil+,
+  # +ActiveSupport::DelegationError+ is raised. If you wish to instead return +nil+,
   # use the <tt>:allow_nil</tt> option.
   #
   #   class User < ActiveRecord::Base
@@ -141,7 +130,7 @@ class Module
   #   end
   #
   #   User.new.age
-  #   # => Module::DelegationError: User#age delegated to profile.age, but profile is nil
+  #   # => ActiveSupport::DelegationError: User#age delegated to profile.age, but profile is nil
   #
   # But if not having a profile yet is fine and should not be an error
   # condition:
@@ -169,104 +158,15 @@ class Module
   #
   # The target method must be public, otherwise it will raise +NoMethodError+.
   def delegate(*methods, to: nil, prefix: nil, allow_nil: nil, private: 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 = to.to_s
-    receiver = "self.#{receiver}" if DELEGATION_RESERVED_METHOD_NAMES.include?(receiver)
-
-    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 /[^\]]=\z/.match?(method)
-          "arg"
-        else
-          method_object =
-            begin
-              if to.is_a?(Module)
-                to.method(method)
-              elsif receiver == "self.class"
-                method(method)
-              end
-            rescue NameError
-              # Do nothing. Fall back to `"..."`
-            end
-
-          if method_object
-            parameters = method_object.parameters
-
-            if (parameters.map(&:first) & [:opt, :rest, :keyreq, :key, :keyrest]).any?
-              "..."
-            else
-              defn = parameters.filter_map { |type, arg| arg if type == :req }
-              defn << "&block"
-              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 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 DelegationError, "#{self}##{method_name} delegated to #{receiver}.#{method}, but #{receiver} is nil: \#{self.inspect}") <<
-          "  else" <<
-          "    raise" <<
-          "  end" <<
-          "end"
-      end
-    end
-    module_eval(method_def.join(";"), file, line)
-    method_names
+    ::ActiveSupport::Delegation.generate(
+      self,
+      methods,
+      location: caller_locations(1, 1).first,
+      to: to,
+      prefix: prefix,
+      allow_nil: allow_nil,
+      private: private,
+    )
   end
 
   # When building decorators, a common pattern may emerge:
@@ -308,7 +208,7 @@ class Module
   # variables, methods, constants, etc.
   #
   # The delegated method must be public on the target, otherwise it will
-  # raise +DelegationError+. If you wish to instead return +nil+,
+  # raise +ActiveSupport::DelegationError+. If you wish to instead return +nil+,
   # use the <tt>:allow_nil</tt> option.
   #
   # The <tt>marshal_dump</tt> and <tt>_dump</tt> methods are exempt from
@@ -316,38 +216,10 @@ class Module
   # <tt>Marshal.dump(object)</tt>, should the delegation target method
   # of <tt>object</tt> add or remove instance variables.
   def delegate_missing_to(target, allow_nil: nil)
-    target = target.to_s
-    target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
-
-    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, *args, &block)
-        if #{target}.respond_to?(method)
-          #{target}.public_send(method, *args, &block)
-        else
-          begin
-            super
-          rescue NoMethodError
-            if #{target}.nil?
-              if #{allow_nil == true}
-                nil
-              else
-                raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
-              end
-            else
-              raise
-            end
-          end
-        end
-      end
-      ruby2_keywords(:method_missing)
-    RUBY
+    ::ActiveSupport::Delegation.generate_method_missing(
+      self,
+      target,
+      allow_nil: allow_nil,
+    )
   end
 end

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

@@ -14,15 +14,12 @@ class Module
   #       Kernel.warn message
   #     end
   #   end
-  def deprecate(*method_names, deprecator: nil, **options)
+  def deprecate(*method_names, deprecator:, **options)
     if deprecator.is_a?(ActiveSupport::Deprecation)
       deprecator.deprecate_methods(self, *method_names, **options)
     elsif deprecator
       # we just need any instance to call deprecate_methods, but the deprecation will be emitted by deprecator
       ActiveSupport.deprecator.deprecate_methods(self, *method_names, **options, deprecator: deprecator)
-    else
-      ActiveSupport.deprecator.warn("Module.deprecate without a deprecator is deprecated")
-      ActiveSupport::Deprecation._instance.deprecate_methods(self, *method_names, **options)
     end
   end
 end

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

@@ -140,6 +140,6 @@ module ActiveSupport
   end
 end
 
-Integer.prepend ActiveSupport::NumericWithFormat
-Float.prepend ActiveSupport::NumericWithFormat
-BigDecimal.prepend ActiveSupport::NumericWithFormat
+Integer.include ActiveSupport::NumericWithFormat
+Float.include ActiveSupport::NumericWithFormat
+BigDecimal.include ActiveSupport::NumericWithFormat

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

@@ -16,7 +16,7 @@ class Object
   #
   # @return [true, false]
   def blank?
-    respond_to?(:empty?) ? !!empty? : !self
+    respond_to?(:empty?) ? !!empty? : false
   end
 
   # An object is present if it's not blank.
@@ -56,6 +56,10 @@ class NilClass
   def blank?
     true
   end
+
+  def present? # :nodoc:
+    false
+  end
 end
 
 class FalseClass
@@ -67,6 +71,10 @@ class FalseClass
   def blank?
     true
   end
+
+  def present? # :nodoc:
+    false
+  end
 end
 
 class TrueClass
@@ -78,6 +86,10 @@ class TrueClass
   def blank?
     false
   end
+
+  def present? # :nodoc:
+    true
+  end
 end
 
 class Array
@@ -88,6 +100,10 @@ class Array
   #
   # @return [true, false]
   alias_method :blank?, :empty?
+
+  def present? # :nodoc:
+    !empty?
+  end
 end
 
 class Hash
@@ -98,6 +114,22 @@ class Hash
   #
   # @return [true, false]
   alias_method :blank?, :empty?
+
+  def present? # :nodoc:
+    !empty?
+  end
+end
+
+class Symbol
+  # A Symbol is blank if it's empty:
+  #
+  #   :''.blank?     # => true
+  #   :symbol.blank? # => false
+  alias_method :blank?, :empty?
+
+  def present? # :nodoc:
+    !empty?
+  end
 end
 
 class String
@@ -129,6 +161,10 @@ class String
         ENCODED_BLANKS[self.encoding].match?(self)
       end
   end
+
+  def present? # :nodoc:
+    !blank?
+  end
 end
 
 class Numeric # :nodoc:
@@ -141,6 +177,10 @@ class Numeric # :nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end
 
 class Time # :nodoc:
@@ -152,4 +192,8 @@ class Time # :nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end

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

@@ -28,23 +28,32 @@ class Object
   end
 end
 
-class Method
-  # Methods are not duplicable:
-  #
-  #   method(:puts).duplicable? # => false
-  #   method(:puts).dup         # => TypeError: allocator undefined for Method
-  def duplicable?
-    false
-  end
+methods_are_duplicable = begin
+  Object.instance_method(:duplicable?).dup
+  true
+rescue TypeError
+  false
 end
 
-class UnboundMethod
-  # Unbound methods are not duplicable:
-  #
-  #   method(:puts).unbind.duplicable? # => false
-  #   method(:puts).unbind.dup         # => TypeError: allocator undefined for UnboundMethod
-  def duplicable?
-    false
+unless methods_are_duplicable
+  class Method
+    # Methods are not duplicable:
+    #
+    #   method(:puts).duplicable? # => false
+    #   method(:puts).dup         # => TypeError: allocator undefined for Method
+    def duplicable?
+      false
+    end
+  end
+
+  class UnboundMethod
+    # Unbound methods are not duplicable:
+    #
+    #   method(:puts).unbind.duplicable? # => false
+    #   method(:puts).unbind.dup         # => TypeError: allocator undefined for UnboundMethod
+    def duplicable?
+      false
+    end
   end
 end
 

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

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