activesupport 7.1.3.4 → 8.0.1

data/lib/active_support/code_generator.rb

@@ -9,16 +9,19 @@ module ActiveSupport
         @cache = METHOD_CACHES[namespace]
         @sources = []
         @methods = {}
+        @canonical_methods = {}
       end
 
-      def define_cached_method(name, as: name)
-        name = name.to_sym
-        as = as.to_sym
-        @methods.fetch(name) do
-          unless @cache.method_defined?(as)
+      def define_cached_method(canonical_name, as: nil)
+        canonical_name = canonical_name.to_sym
+        as = (as || canonical_name).to_sym
+
+        @methods.fetch(as) do
+          unless @cache.method_defined?(canonical_name) || @canonical_methods[canonical_name]
             yield @sources
           end
-          @methods[name] = as
+          @canonical_methods[canonical_name] = true
+          @methods[as] = canonical_name
         end
       end
 
@@ -26,8 +29,10 @@ module ActiveSupport
         unless @sources.empty?
           @cache.module_eval("# frozen_string_literal: true\n" + @sources.join(";"), path, line)
         end
-        @methods.each do |name, as|
-          owner.define_method(name, @cache.instance_method(as))
+        @canonical_methods.clear
+
+        @methods.each do |as, canonical_name|
+          owner.define_method(as, @cache.instance_method(canonical_name))
         end
       end
     end
@@ -50,16 +55,25 @@ module ActiveSupport
       @path = path
       @line = line
       @namespaces = Hash.new { |h, k| h[k] = MethodSet.new(k) }
+      @sources = []
+    end
+
+    def class_eval
+      yield @sources
     end
 
-    def define_cached_method(name, namespace:, as: name, &block)
-      @namespaces[namespace].define_cached_method(name, as: as, &block)
+    def define_cached_method(canonical_name, namespace:, as: nil, &block)
+      @namespaces[namespace].define_cached_method(canonical_name, as: as, &block)
     end
 
     def execute
       @namespaces.each_value do |method_set|
         method_set.apply(@owner, @path, @line - 1)
       end
+
+      unless @sources.empty?
+        @owner.class_eval("# frozen_string_literal: true\n" + @sources.join(";"), @path, @line - 1)
+      end
     end
   end
 end

data/lib/active_support/concurrency/share_lock.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
 require "monitor"
 
 module ActiveSupport

data/lib/active_support/configuration_file.rb

@@ -19,11 +19,20 @@ module ActiveSupport
     end
 
     def parse(context: nil, **options)
-      source = render(context)
-      if YAML.respond_to?(:unsafe_load)
-        YAML.unsafe_load(source, **options) || {}
+      source = @content.include?("<%") ? render(context) : @content
+
+      if source == @content
+        if YAML.respond_to?(:unsafe_load)
+          YAML.unsafe_load_file(@content_path, **options) || {}
+        else
+          YAML.load_file(@content_path, **options) || {}
+        end
       else
-        YAML.load(source, **options) || {}
+        if YAML.respond_to?(:unsafe_load)
+          YAML.unsafe_load(source, **options) || {}
+        else
+          YAML.load(source, **options) || {}
+        end
       end
     rescue Psych::SyntaxError => error
       raise "YAML syntax error occurred while parsing #{@content_path}. " \
@@ -33,8 +42,7 @@ module ActiveSupport
 
     private
       def read(content_path)
-        require "yaml"
-        require "erb"
+        require "yaml" unless defined?(YAML)
 
         File.read(content_path).tap do |content|
           if content.include?("\u00A0")
@@ -44,6 +52,7 @@ module ActiveSupport
       end
 
       def render(context)
+        require "erb" unless defined?(ERB)
         erb = ERB.new(@content).tap { |e| e.filename = @content_path }
         context ? erb.result(context) : erb.result
       end

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

@@ -16,11 +16,11 @@ class Array
   # ==== Options
   #
   # * <tt>:words_connector</tt> - The sign or word used to join all but the last
-  #   element in arrays with three or more elements (default: ", ").
+  #   element in arrays with three or more elements (default: <tt>", "</tt>).
   # * <tt>:last_word_connector</tt> - The sign or word used to join the last element
-  #   in arrays with three or more elements (default: ", and ").
+  #   in arrays with three or more elements (default: <tt>", and "</tt>).
   # * <tt>:two_words_connector</tt> - The sign or word used to join the elements
-  #   in arrays with two elements (default: " and ").
+  #   in arrays with two elements (default: <tt>" and "</tt>).
   # * <tt>:locale</tt> - If +i18n+ is available, you can set a locale and use
   #   the connector options defined on the 'support.array' namespace in the
   #   corresponding dictionary file.
@@ -104,8 +104,6 @@ class Array
     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 string that represents the array in XML by invoking +to_xml+
   # on each element. Active Record collections delegate their representation

data/lib/active_support/core_ext/benchmark.rb

@@ -3,14 +3,11 @@
 require "benchmark"
 
 class << Benchmark
-  # Benchmark realtime in milliseconds.
-  #
-  #   Benchmark.realtime { User.all }
-  #   # => 8.0e-05
-  #
-  #   Benchmark.ms { User.all }
-  #   # => 0.074
-  def ms(&block)
-    1000 * realtime(&block)
+  def ms(&block) # :nodoc
+    # NOTE: Please also remove the Active Support `benchmark` dependency when removing this
+    ActiveSupport.deprecator.warn <<~TEXT
+      `Benchmark.ms` is deprecated and will be removed in Rails 8.1 without replacement.
+    TEXT
+    ActiveSupport::Benchmark.realtime(:float_millisecond, &block)
   end
 end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/module/redefine_method"
+require "active_support/class_attribute"
 
 class Class
   # Declare a class-level attribute whose value is inheritable by subclasses.
@@ -83,32 +84,37 @@ class Class
   #
   #   class_attribute :settings, default: {}
   def class_attribute(*attrs, instance_accessor: true,
-    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil)
-
+    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil
+  )
     class_methods, methods = [], []
     attrs.each do |name|
       unless name.is_a?(Symbol) || name.is_a?(String)
         raise TypeError, "#{name.inspect} is not a symbol nor a string"
       end
 
-      class_methods << <<~RUBY # In case the method exists and is not public
-        silence_redefinition_of_method def #{name}
-        end
-      RUBY
+      name = name.to_sym
+      namespaced_name = :"__class_attr_#{name}"
+      ::ActiveSupport::ClassAttribute.redefine(self, name, namespaced_name, default)
 
-      methods << <<~RUBY if instance_reader
-        silence_redefinition_of_method def #{name}
-          defined?(@#{name}) ? @#{name} : self.class.#{name}
-        end
-      RUBY
+      delegators = [
+        "def #{name}; #{namespaced_name}; end",
+        "def #{name}=(value); self.#{namespaced_name} = value; end",
+      ]
 
-      class_methods << <<~RUBY
-        silence_redefinition_of_method def #{name}=(value)
-          redefine_method(:#{name}) { value } if singleton_class?
-          redefine_singleton_method(:#{name}) { value }
-          value
-        end
-      RUBY
+      class_methods.concat(delegators)
+      if singleton_class?
+        methods.concat(delegators)
+      else
+        methods << <<~RUBY if instance_reader
+          silence_redefinition_of_method def #{name}
+            if defined?(@#{name})
+              @#{name}
+            else
+              self.class.#{name}
+            end
+          end
+        RUBY
+      end
 
       methods << <<~RUBY if instance_writer
         silence_redefinition_of_method(:#{name}=)
@@ -125,7 +131,5 @@ class Class
 
     location = caller_locations(1, 1).first
     class_eval(["class << self", *class_methods, "end", *methods].join(";").tr("\n", ";"), location.path, location.lineno)
-
-    attrs.each { |name| public_send("#{name}=", default) }
   end
 end

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

@@ -17,6 +17,7 @@ class Date
       date.strftime("%B #{day_format}, %Y") # => "April 25th, 2007"
     },
     rfc822: "%d %b %Y",
+    rfc2822: "%d %b %Y",
     iso8601: lambda { |date| date.iso8601 }
   }
 
@@ -34,6 +35,7 @@ class Date
   #   date.to_fs(:long)          # => "November 10, 2007"
   #   date.to_fs(:long_ordinal)  # => "November 10th, 2007"
   #   date.to_fs(:rfc822)        # => "10 Nov 2007"
+  #   date.to_fs(:rfc2822)       # => "10 Nov 2007"
   #   date.to_fs(:iso8601)       # => "2007-11-10"
   #
   # == Adding your own date formats to to_fs
@@ -56,8 +58,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 receiver timezone rather than system local time in Rails 8.1." \
+          "To opt in to the new behavior, set `config.active_support.to_time_preserves_timezone = :zone`."
+        )
+
+        @@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/enumerable.rb

@@ -192,9 +192,14 @@ module Enumerable
   #   # => [ Person.find(1), Person.find(5), Person.find(3) ]
   #
   # If the +series+ include keys that have no corresponding element in the Enumerable, these are ignored.
-  # If the Enumerable has additional elements that aren't named in the +series+, these are not included in the result.
-  def in_order_of(key, series)
-    group_by(&key).values_at(*series).flatten(1).compact
+  # If the Enumerable has additional elements that aren't named in the +series+, these are not included in the result, unless
+  # the +filter+ option is set to +false+.
+  def in_order_of(key, series, filter: true)
+    if filter
+      group_by(&key).values_at(*series).flatten(1).compact
+    else
+      sort_by { |v| series.index(v.public_send(key)) || series.size }.compact
+    end
   end
 
   # Returns the sole item in the enumerable. If there are no items, or more

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

@@ -174,7 +174,7 @@ class ERB
 
         case source.matched
         when start_re
-          tokens << [:TEXT, source.string[pos, len]] if len > 0
+          tokens << [:TEXT, source.string.byteslice(pos, len)] if len > 0
           tokens << [:OPEN, source.matched]
           if source.scan(/(.*?)(?=#{finish_re}|\z)/m)
             tokens << [:CODE, source.matched] unless source.matched.empty?
@@ -183,11 +183,16 @@ class ERB
             raise NotImplementedError
           end
         when finish_re
-          tokens << [:CODE, source.string[pos, len]] if len > 0
+          tokens << [:CODE, source.string.byteslice(pos, len)] if len > 0
           tokens << [:CLOSE, source.matched]
         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/except.rb

@@ -1,18 +1,6 @@
 # frozen_string_literal: true
 
 class Hash
-  # Returns a hash that includes everything except given keys.
-  #   hash = { a: true, b: false, c: nil }
-  #   hash.except(:c)     # => { a: true, b: false }
-  #   hash.except(:a, :b) # => { c: nil }
-  #   hash                # => { a: true, b: false, c: nil }
-  #
-  # This is useful for limiting a set of parameters to everything but a few known toggles:
-  #   @person.update(params[:person].except(:admin))
-  def except(*keys)
-    slice(*self.keys - keys)
-  end unless method_defined?(:except)
-
   # Removes the given keys from hash and returns it.
   #   hash = { a: true, b: false, c: nil }
   #   hash.except!(:c) # => { a: true, b: false }

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,26 @@ 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?("@")
+        raise ArgumentError, <<~MESSAGE.squish
+          Setting `attr_internal_naming_format` with a `@` prefix is not supported.
+
+          You can simply replace #{format.inspect} by #{format.delete_prefix("@").inspect}.
+        MESSAGE
+      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