activesupport 7.2.3 → 8.0.5

data/lib/active_support/cache/redis_cache_store.rb

@@ -150,7 +150,7 @@ module ActiveSupport
         universal_options = redis_options.extract!(*UNIVERSAL_OPTIONS)
 
         if pool_options = self.class.send(:retrieve_pool_options, redis_options)
-          @redis = ::ConnectionPool.new(pool_options) { self.class.build_redis(**redis_options) }
+          @redis = ::ConnectionPool.new(**pool_options) { self.class.build_redis(**redis_options) }
         else
           @redis = self.class.build_redis(**redis_options)
         end
@@ -173,9 +173,12 @@ module ActiveSupport
         return {} if names.empty?
 
         options = names.extract_options!
-        instrument_multi(:read_multi, names, options) do |payload|
+        options = merged_options(options)
+        keys    = names.map { |name| normalize_key(name, options) }
+
+        instrument_multi(:read_multi, keys, options) do |payload|
           read_multi_entries(names, **options).tap do |results|
-            payload[:hits] = results.keys
+            payload[:hits] = results.keys.map { |name| normalize_key(name, options) }
           end
         end
       end

data/lib/active_support/cache.rb

@@ -287,7 +287,7 @@ module ActiveSupport
       #   <tt>coder: nil</tt> to avoid the overhead of safeguarding against
       #   mutation.
       #
-      #   The +:coder+ option is mutally exclusive with the +:serializer+ and
+      #   The +:coder+ option is mutually exclusive with the +:serializer+ and
       #   +:compressor+ options. Specifying them together will raise an
       #   +ArgumentError+.
       #
@@ -420,7 +420,7 @@ module ActiveSupport
       #     t1.join
       #
       #     p val_1 # => "new value 1"
-      #     p val_2 # => "oritinal value"
+      #     p val_2 # => "original value"
       #     p cache.fetch("foo") # => "new value 1"
       #
       #     # The entry requires 3 seconds to expire (expires_in + race_condition_ttl)
@@ -539,10 +539,11 @@ module ActiveSupport
 
         options = names.extract_options!
         options = merged_options(options)
+        keys    = names.map { |name| normalize_key(name, options) }
 
-        instrument_multi :read_multi, names, options do |payload|
+        instrument_multi :read_multi, keys, options do |payload|
           read_multi_entries(names, **options, event: payload).tap do |results|
-            payload[:hits] = results.keys
+            payload[:hits] = results.keys.map { |name| normalize_key(name, options) }
           end
         end
       end
@@ -552,8 +553,9 @@ module ActiveSupport
         return hash if hash.empty?
 
         options = merged_options(options)
+        normalized_hash = hash.transform_keys { |key| normalize_key(key, options) }
 
-        instrument_multi :write_multi, hash, options do |payload|
+        instrument_multi :write_multi, normalized_hash, options do |payload|
           entries = hash.each_with_object({}) do |(name, value), memo|
             memo[normalize_key(name, options)] = Entry.new(value, **options.merge(version: normalize_version(name, options)))
           end
@@ -597,9 +599,9 @@ module ActiveSupport
 
         options = names.extract_options!
         options = merged_options(options)
-
+        keys    = names.map { |name| normalize_key(name, options) }
         writes  = {}
-        ordered = instrument_multi :read_multi, names, options do |payload|
+        ordered = instrument_multi :read_multi, keys, options do |payload|
           if options[:force]
             reads = {}
           else
@@ -611,7 +613,7 @@ module ActiveSupport
           end
           writes.compact! if options[:skip_nil]
 
-          payload[:hits] = reads.keys
+          payload[:hits] = reads.keys.map { |name| normalize_key(name, options) }
           payload[:super_operation] = :fetch_multi
 
           ordered
@@ -944,9 +946,12 @@ module ActiveSupport
         #
         #   namespace_key 'foo', namespace: -> { 'cache' }
         #   # => 'cache:foo'
-        def namespace_key(key, options = nil)
-          options = merged_options(options)
-          namespace = options[:namespace]
+        def namespace_key(key, call_options = nil)
+          namespace = if call_options&.key?(:namespace)
+            call_options[:namespace]
+          else
+            options[:namespace]
+          end
 
           if namespace.respond_to?(:call)
             namespace = namespace.call

data/lib/active_support/callbacks.rb

@@ -6,7 +6,6 @@ require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/class/attribute"
 require "active_support/core_ext/string/filters"
 require "active_support/core_ext/object/blank"
-require "thread"
 
 module ActiveSupport
   # = Active Support \Callbacks
@@ -67,7 +66,7 @@ module ActiveSupport
 
     included do
       extend ActiveSupport::DescendantsTracker
-      class_attribute :__callbacks, instance_writer: false, default: {}
+      class_attribute :__callbacks, instance_writer: false, instance_predicate: false, default: {}
     end
 
     CALLBACK_FILTER_TYPES = [:before, :after, :around].freeze
@@ -935,7 +934,10 @@ module ActiveSupport
           end
 
           def set_callbacks(name, callbacks) # :nodoc:
-            unless singleton_class.method_defined?(:__callbacks, false)
+            # HACK: We're making assumption on how `class_attribute` is implemented
+            # to save constantly duping the callback hash. If this desync with class_attribute
+            # we'll lose the optimization, but won't cause an actual behavior bug.
+            unless singleton_class.private_method_defined?(:__class_attr__callbacks, false)
               self.__callbacks = __callbacks.dup
             end
             self.__callbacks[name.to_sym] = callbacks

data/lib/active_support/class_attribute.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ClassAttribute # :nodoc:
+    class << self
+      def redefine(owner, name, namespaced_name, value)
+        if owner.singleton_class?
+          if owner.attached_object.is_a?(Module)
+            redefine_method(owner, namespaced_name, private: true) { value }
+          else
+            redefine_method(owner, name) { value }
+          end
+        end
+
+        redefine_method(owner.singleton_class, namespaced_name, private: true) { value }
+
+        redefine_method(owner.singleton_class, "#{namespaced_name}=", private: true) do |new_value|
+          if owner.equal?(self)
+            value = new_value
+          else
+            ::ActiveSupport::ClassAttribute.redefine(self, name, namespaced_name, new_value)
+          end
+        end
+      end
+
+      def redefine_method(owner, name, private: false, &block)
+        owner.silence_redefinition_of_method(name)
+        owner.define_method(name, &block)
+        owner.send(:private, name) if private
+      end
+    end
+  end
+end

data/lib/active_support/code_generator.rb

@@ -55,6 +55,11 @@ 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(canonical_name, namespace:, as: nil, &block)
@@ -65,6 +70,10 @@ module ActiveSupport
       @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.

data/lib/active_support/core_ext/benchmark.rb

@@ -4,14 +4,11 @@ require "benchmark"
 return if Benchmark.respond_to?(:ms)
 
 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.
@@ -91,24 +92,31 @@ class Class
         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
+      class_methods << "def #{name}; #{namespaced_name}; end"
+      class_methods << "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
+      if singleton_class?
+        methods << <<~RUBY if instance_reader
+          silence_redefinition_of_method(:#{name})
+          def #{name}
+            self.singleton_class.#{name}
+          end
+        RUBY
+      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 +133,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/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

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

@@ -26,8 +26,8 @@ module DateAndTime
         # 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`."
+          "`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

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/hash/deep_merge.rb

@@ -36,6 +36,7 @@ class Hash
   #--
   # Implemented by ActiveSupport::DeepMergeable#deep_merge!.
 
+  ##
   def deep_merge?(other) # :nodoc:
     other.is_a?(Hash)
   end

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/module/attr_internal.rb

@@ -24,14 +24,13 @@ class Module
 
     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.
+        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
-
-        format = format.delete_prefix("@")
       end
+
       @attr_internal_naming_format = format
     end
   end

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

@@ -4,7 +4,7 @@
 require "json"
 require "bigdecimal"
 require "ipaddr"
-require "uri/generic"
+require "uri"
 require "pathname"
 require "active_support/core_ext/big_decimal/conversions" # for #to_s
 require "active_support/core_ext/hash/except"
@@ -65,11 +65,9 @@ class Object
   end
 end
 
-if RUBY_VERSION >= "3.2"
-  class Data # :nodoc:
-    def as_json(options = nil)
-      to_h.as_json(options)
-    end
+class Data # :nodoc:
+  def as_json(options = nil)
+    to_h.as_json(options)
   end
 end
 
@@ -105,7 +103,7 @@ end
 
 class Symbol
   def as_json(options = nil) # :nodoc:
-    to_s
+    name
   end
 end
 
@@ -164,7 +162,12 @@ end
 
 class Array
   def as_json(options = nil) # :nodoc:
-    map { |v| options ? v.as_json(options.dup) : v.as_json }
+    if options
+      options = options.dup.freeze unless options.frozen?
+      map { |v| v.as_json(options) }
+    else
+      map { |v| v.as_json }
+    end
   end
 end
 
@@ -184,8 +187,11 @@ class Hash
     end
 
     result = {}
-    subset.each do |k, v|
-      result[k.to_s] = options ? v.as_json(options.dup) : v.as_json
+    if options
+      options = options.dup.freeze unless options.frozen?
+      subset.each { |k, v| result[k.to_s] = v.as_json(options) }
+    else
+      subset.each { |k, v| result[k.to_s] = v.as_json }
     end
     result
   end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "cgi"
+require "cgi/escape"
+require "cgi/util" if RUBY_VERSION < "3.5"
 
 class Object
   # Alias of <tt>to_s</tt>.

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

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

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

@@ -248,7 +248,7 @@ class String
   # optional parameter +capitalize+ to false.
   # By default, this parameter is true.
   #
-  # The trailing '_id' can be kept and capitalized by setting the
+  # The trailing '_id' can be kept by setting the
   # optional parameter +keep_id_suffix+ to true.
   # By default, this parameter is false.
   #

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

@@ -128,7 +128,9 @@ module ActiveSupport # :nodoc:
         escaped_args = Array(args).map { |arg| explicit_html_escape_interpolated_argument(arg) }
       end
 
-      self.class.new(super(escaped_args))
+      new_safe_buffer = self.class.new(super(escaped_args))
+      new_safe_buffer.instance_variable_set(:@html_safe, @html_safe)
+      new_safe_buffer
     end
 
     attr_reader :html_safe

data/lib/active_support/core_ext/thread/backtrace/location.rb

@@ -1,12 +1,7 @@
 # frozen_string_literal: true
 
 class Thread::Backtrace::Location # :nodoc:
-  if defined?(ErrorHighlight) && Gem::Version.new(ErrorHighlight::VERSION) >= Gem::Version.new("0.4.0")
-    def spot(ex)
-      ErrorHighlight.spot(ex, backtrace_location: self)
-    end
-  else
-    def spot(ex)
-    end
+  def spot(ex)
+    ErrorHighlight.spot(ex, backtrace_location: self)
   end
 end

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

@@ -147,6 +147,13 @@ class Time
     elsif zone.respond_to?(:utc_to_local)
       new_time = ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)
 
+      # Some versions of Ruby have a bug where Time.new with a zone object and
+      # fractional seconds will end up with a broken utc_offset.
+      # This is fixed in Ruby 3.3.1 and 3.2.4
+      unless new_time.utc_offset.integer?
+        new_time += 0
+      end
+
       # When there are two occurrences of a nominal time due to DST ending,
       # `Time.new` chooses the first chronological occurrence (the one with a
       # larger UTC offset). However, for `change`, we want to choose the
@@ -217,8 +224,13 @@ class Time
   # Returns a new Time representing the time a number of seconds since the instance time
   def since(seconds)
     self + seconds
-  rescue
-    to_datetime.since(seconds)
+  rescue TypeError
+    result = to_datetime.since(seconds)
+    ActiveSupport.deprecator.warn(
+      "Passing an instance of #{seconds.class} to #{self.class}#since is deprecated. This behavior will raise " \
+      "a `TypeError` in Rails 8.1."
+    )
+    result
   end
   alias :in :since
 

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

@@ -22,6 +22,7 @@ class Time
       offset_format = time.formatted_offset(false)
       time.strftime("%a, %d %b %Y %H:%M:%S #{offset_format}")
     },
+    rfc2822: lambda { |time| time.rfc2822 },
     iso8601: lambda { |time| time.iso8601 }
   }
 
@@ -40,6 +41,7 @@ class Time
   #   time.to_fs(:long)         # => "January 18, 2007 06:10"
   #   time.to_fs(:long_ordinal) # => "January 18th, 2007 06:10"
   #   time.to_fs(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
+  #   time.to_fs(:rfc2822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
   #   time.to_fs(:iso8601)      # => "2007-01-18T06:10:17-06:00"
   #
   # == Adding your own time formats to +to_fs+