activesupport 7.1.3.2 → 8.0.1

data/lib/active_support/hash_with_indifferent_access.rb

@@ -313,10 +313,6 @@ module ActiveSupport
     end
     alias_method :without, :except
 
-    def stringify_keys!; self end
-    def deep_stringify_keys!; self end
-    def stringify_keys; dup end
-    def deep_stringify_keys; dup end
     undef :symbolize_keys!
     undef :deep_symbolize_keys!
     def symbolize_keys; to_hash.symbolize_keys! end
@@ -378,33 +374,24 @@ module ActiveSupport
 
     # Convert to a regular hash with string keys.
     def to_hash
-      _new_hash = Hash.new
-      set_defaults(_new_hash)
+      copy = Hash[self]
+      copy.transform_values! { |v| convert_value_to_hash(v) }
+      set_defaults(copy)
+      copy
+    end
 
-      each do |key, value|
-        _new_hash[key] = convert_value(value, conversion: :to_hash)
-      end
-      _new_hash
+    def to_proc
+      proc { |key| self[key] }
     end
 
     private
-      if Symbol.method_defined?(:name)
-        def convert_key(key)
-          key.kind_of?(Symbol) ? key.name : key
-        end
-      else
-        def convert_key(key)
-          key.kind_of?(Symbol) ? key.to_s : key
-        end
+      def convert_key(key)
+        Symbol === key ? key.name : key
       end
 
       def convert_value(value, conversion: nil)
         if value.is_a? Hash
-          if conversion == :to_hash
-            value.to_hash
-          else
-            value.nested_under_indifferent_access
-          end
+          value.nested_under_indifferent_access
         elsif value.is_a?(Array)
           if conversion != :assignment || value.frozen?
             value = value.dup
@@ -415,6 +402,17 @@ module ActiveSupport
         end
       end
 
+      def convert_value_to_hash(value)
+        if value.is_a? Hash
+          value.to_hash
+        elsif value.is_a?(Array)
+          value.map { |e| convert_value_to_hash(e) }
+        else
+          value
+        end
+      end
+
+
       def set_defaults(target)
         if default_proc
           target.default_proc = default_proc.dup

data/lib/active_support/html_safe_translation.rb

@@ -9,11 +9,14 @@ module ActiveSupport
         html_safe_options = html_escape_translation_options(options)
 
         exception = false
+
         exception_handler = ->(*args) do
           exception = true
           I18n.exception_handler.call(*args)
         end
+
         translation = I18n.translate(key, **html_safe_options, exception_handler: exception_handler)
+
         if exception
           translation
         else
@@ -24,11 +27,11 @@ module ActiveSupport
       end
     end
 
-    private
-      def html_safe_translation_key?(key)
-        /(?:_|\b)html\z/.match?(key)
-      end
+    def html_safe_translation_key?(key)
+      /(?:_|\b)html\z/.match?(key)
+    end
 
+    private
       def html_escape_translation_options(options)
         options.each do |name, value|
           unless i18n_option?(name) || (name == :count && value.is_a?(Numeric))

data/lib/active_support/i18n_railtie.rb

@@ -14,15 +14,18 @@ module I18n
 
     config.eager_load_namespaces << I18n
 
-    # Set the i18n configuration after initialization since a lot of
-    # configuration is still usually done in application initializers.
-    config.after_initialize do |app|
+    # Make sure i18n is ready before eager loading, in case any eager loaded
+    # code needs it.
+    config.before_eager_load do |app|
       I18n::Railtie.initialize_i18n(app)
     end
 
-    # Trigger i18n config before any eager loading has happened
-    # so it's ready if any classes require it when eager loaded.
-    config.before_eager_load do |app|
+    # i18n initialization needs to run after application initialization, since
+    # initializers may configure i18n.
+    #
+    # If the application eager loaded, this was done on before_eager_load. The
+    # hook is still OK, though, because initialize_i18n is idempotent.
+    config.after_initialize do |app|
       I18n::Railtie.initialize_i18n(app)
     end
 
@@ -49,7 +52,8 @@ module I18n
         when :load_path
           I18n.load_path += value
         when :raise_on_missing_translations
-          setup_raise_on_missing_translations_config(app)
+          strict = value == :strict
+          setup_raise_on_missing_translations_config(app, strict)
         else
           I18n.public_send("#{setting}=", value)
         end
@@ -62,8 +66,9 @@ module I18n
 
       if app.config.reloading_enabled?
         directories = watched_dirs_with_extensions(reloadable_paths)
-        reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
-          I18n.load_path.keep_if { |p| File.exist?(p) }
+        root_load_paths = I18n.load_path.select { |path| path.to_s.start_with?(Rails.root.to_s) }
+        reloader = app.config.file_watcher.new(root_load_paths, directories) do
+          I18n.load_path.delete_if { |path| path.to_s.start_with?(Rails.root.to_s) && !File.exist?(path) }
           I18n.load_path |= reloadable_paths.flat_map(&:existent)
         end
 
@@ -71,17 +76,20 @@ module I18n
         app.reloader.to_run do
           reloader.execute_if_updated { require_unload_lock! }
         end
-        reloader.execute
       end
 
       @i18n_inited = true
     end
 
-    def self.setup_raise_on_missing_translations_config(app)
+    def self.setup_raise_on_missing_translations_config(app, strict)
       ActiveSupport.on_load(:action_view) do
         ActionView::Helpers::TranslationHelper.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
       end
 
+      ActiveSupport.on_load(:active_model_translation) do
+        ActiveModel::Translation.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations if strict
+      end
+
       if app.config.i18n.raise_on_missing_translations &&
           I18n.exception_handler.is_a?(I18n::ExceptionHandler) # Only override the i18n gem's default exception handler.
 

data/lib/active_support/isolated_execution_state.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "fiber"
-
 module ActiveSupport
   module IsolatedExecutionState # :nodoc:
     @isolation_level = nil

data/lib/active_support/json/encoding.rb

@@ -36,14 +36,14 @@ module ActiveSupport
         # Encode the given object into a JSON string
         def encode(value)
           unless options.empty?
-            value = value.as_json(options.dup)
+            value = value.as_json(options.dup.freeze)
           end
           json = stringify(jsonify(value))
 
           # Rails does more escaping than the JSON gem natively does (we
           # escape \u2028 and \u2029 and optionally >, <, & to work around
           # certain browser problems).
-          if Encoding.escape_html_entities_in_json
+          if @options.fetch(:escape_html_entities, Encoding.escape_html_entities_in_json)
             json.gsub!(">", '\u003e')
             json.gsub!("<", '\u003c')
             json.gsub!("&", '\u0026')
@@ -76,7 +76,7 @@ module ActiveSupport
             when Hash
               result = {}
               value.each do |k, v|
-                k = k.to_s unless String === k
+                k = k.to_s unless Symbol === k || String === k
                 result[k] = jsonify(v)
               end
               result

data/lib/active_support/log_subscriber.rb

@@ -2,6 +2,7 @@
 
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/enumerable"
 require "active_support/subscriber"
 require "active_support/deprecation/proxy_wrappers"
 
@@ -61,10 +62,6 @@ module ActiveSupport
   # that all logs are flushed, and it is called in Rails::Rack::Logger after a
   # request finishes.
   class LogSubscriber < Subscriber
-    # Embed in a String to clear all previous ANSI sequences.
-    CLEAR = ActiveSupport::Deprecation::DeprecatedObjectProxy.new("\e[0m", "CLEAR is deprecated! Use MODES[:clear] instead.", ActiveSupport.deprecator)
-    BOLD  = ActiveSupport::Deprecation::DeprecatedObjectProxy.new("\e[1m", "BOLD is deprecated! Use MODES[:bold] instead.", ActiveSupport.deprecator)
-
     # ANSI sequence modes
     MODES = {
       clear:     0,
@@ -181,14 +178,6 @@ module ActiveSupport
     end
 
     def mode_from(options)
-      if options.is_a?(TrueClass) || options.is_a?(FalseClass)
-        ActiveSupport.deprecator.warn(<<~MSG.squish)
-          Bolding log text with a positional boolean is deprecated and will be removed
-          in Rails 7.2. Use an option hash instead (eg. `color("my text", :red, bold: true)`).
-        MSG
-        options = { bold: options }
-      end
-
       modes = MODES.values_at(*options.compact_blank.keys)
 
       "\e[#{modes.join(";")}m" if modes.any?

data/lib/active_support/logger.rb

@@ -13,6 +13,10 @@ module ActiveSupport
     #   logger = Logger.new(STDOUT)
     #   ActiveSupport::Logger.logger_outputs_to?(logger, STDOUT)
     #   # => true
+    #
+    #   logger = Logger.new('/var/log/rails.log')
+    #   ActiveSupport::Logger.logger_outputs_to?(logger, '/var/log/rails.log')
+    #   # => true
     def self.logger_outputs_to?(logger, *sources)
       loggers = if logger.is_a?(BroadcastLogger)
         logger.broadcasts
@@ -21,9 +25,9 @@ module ActiveSupport
       end
 
       logdevs = loggers.map { |logger| logger.instance_variable_get(:@logdev) }
-      logger_sources = logdevs.filter_map { |logdev| logdev.dev if logdev.respond_to?(:dev) }
+      logger_sources = logdevs.filter_map { |logdev| logdev.try(:filename) || logdev.try(:dev) }
 
-      (sources & logger_sources).any?
+      normalize_sources(sources).intersect?(normalize_sources(logger_sources))
     end
 
     def initialize(*args, **kwargs)
@@ -38,5 +42,14 @@ module ActiveSupport
         "#{String === msg ? msg : msg.inspect}\n"
       end
     end
+
+    private
+      def self.normalize_sources(sources)
+        sources.map do |source|
+          source = source.path if source.respond_to?(:path)
+          source = File.realpath(source) if source.is_a?(String) && File.exist?(source)
+          source
+        end
+      end
   end
 end

data/lib/active_support/logger_thread_safe_level.rb

@@ -7,14 +7,6 @@ module ActiveSupport
   module LoggerThreadSafeLevel # :nodoc:
     extend ActiveSupport::Concern
 
-    Logger::Severity.constants.each do |severity|
-      class_eval(<<-EOT, __FILE__, __LINE__ + 1)
-        def #{severity.downcase}?                # def debug?
-          Logger::#{severity} >= level           #   DEBUG >= level
-        end                                      # end
-      EOT
-    end
-
     def local_level
       IsolatedExecutionState[local_level_key]
     end

data/lib/active_support/message_pack/extensions.rb

@@ -86,8 +86,9 @@ module ActiveSupport
           unpacker: URI.method(:parse)
 
         registry.register_type 14, IPAddr,
-          packer: :to_s,
-          unpacker: :new
+          packer: method(:write_ipaddr),
+          unpacker: method(:read_ipaddr),
+          recursive: true
 
         registry.register_type 15, Pathname,
           packer: :to_s,
@@ -221,6 +222,18 @@ module ActiveSupport
         Set.new(unpacker.read)
       end
 
+      def write_ipaddr(ipaddr, packer)
+        if ipaddr.prefix < 32 || (ipaddr.ipv6? && ipaddr.prefix < 128)
+          packer.write("#{ipaddr}/#{ipaddr.prefix}")
+        else
+          packer.write(ipaddr.to_s)
+        end
+      end
+
+      def read_ipaddr(unpacker)
+        IPAddr.new(unpacker.read)
+      end
+
       def write_hash_with_indifferent_access(hwia, packer)
         packer.write(hwia.to_h)
       end

data/lib/active_support/message_verifier.rb

@@ -30,6 +30,18 @@ module ActiveSupport
   #     self.current_user = User.find(id)
   #   end
   #
+  # === Signing is not encryption
+  #
+  # The signed messages are not encrypted. The payload is merely encoded (Base64 by default) and can be decoded by
+  # anyone. The signature is just assuring that the message wasn't tampered with. For example:
+  #
+  #     message = Rails.application.message_verifier('my_purpose').generate('never put secrets here')
+  #     # => "BAhJIhtuZXZlciBwdXQgc2VjcmV0cyBoZXJlBjoGRVQ=--a0c1c0827919da5e949e989c971249355735e140"
+  #     Base64.decode64(message.split("--").first) # no key needed
+  #     # => 'never put secrets here'
+  #
+  # If you also need to encrypt the contents, you must use ActiveSupport::MessageEncryptor instead.
+  #
   # === Confine messages to a specific purpose
   #
   # It's not recommended to use the same verifier for different purposes in your application.

data/lib/active_support/messages/codec.rb

@@ -28,7 +28,7 @@ module ActiveSupport
 
         def decode(encoded, url_safe: @url_safe)
           url_safe ? ::Base64.urlsafe_decode64(encoded) : ::Base64.strict_decode64(encoded)
-        rescue ArgumentError => error
+        rescue StandardError => error
           throw :invalid_message_format, error
         end
 

data/lib/active_support/multibyte/chars.rb

@@ -59,8 +59,8 @@ module ActiveSupport # :nodoc:
       end
 
       # Forward all undefined methods to the wrapped string.
-      def method_missing(method, *args, &block)
-        result = @wrapped_string.__send__(method, *args, &block)
+      def method_missing(method, ...)
+        result = @wrapped_string.__send__(method, ...)
         if method.end_with?("!")
           self if result
         else

data/lib/active_support/notifications/fanout.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "mutex_m"
 require "concurrent/map"
-require "set"
 require "active_support/core_ext/object/try"
 
 module ActiveSupport
@@ -49,15 +47,13 @@ module ActiveSupport
     #
     # This class is thread safe. All methods are reentrant.
     class Fanout
-      include Mutex_m
-
       def initialize
+        @mutex = Mutex.new
         @string_subscribers = Concurrent::Map.new { |h, k| h.compute_if_absent(k) { [] } }
         @other_subscribers = []
         @all_listeners_for = Concurrent::Map.new
         @groups_for = Concurrent::Map.new
         @silenceable_groups_for = Concurrent::Map.new
-        super
       end
 
       def inspect # :nodoc:
@@ -67,7 +63,7 @@ module ActiveSupport
 
       def subscribe(pattern = nil, callable = nil, monotonic: false, &block)
         subscriber = Subscribers.new(pattern, callable || block, monotonic)
-        synchronize do
+        @mutex.synchronize do
           case pattern
           when String
             @string_subscribers[pattern] << subscriber
@@ -83,7 +79,7 @@ module ActiveSupport
       end
 
       def unsubscribe(subscriber_or_name)
-        synchronize do
+        @mutex.synchronize do
           case subscriber_or_name
           when String
             @string_subscribers[subscriber_or_name].clear
@@ -300,7 +296,7 @@ module ActiveSupport
 
       def all_listeners_for(name)
         # this is correctly done double-checked locking (Concurrent::Map's lookups have volatile semantics)
-        @all_listeners_for[name] || synchronize do
+        @all_listeners_for[name] || @mutex.synchronize do
           # use synchronisation when accessing @subscribers
           @all_listeners_for[name] ||=
             @string_subscribers[name] + @other_subscribers.select { |s| s.subscribed_to?(name) }

data/lib/active_support/notifications/instrumenter.rb

@@ -104,7 +104,7 @@ module ActiveSupport
     end
 
     class Event
-      attr_reader :name, :time, :end, :transaction_id
+      attr_reader :name, :transaction_id
       attr_accessor :payload
 
       def initialize(name, start, ending, transaction_id, payload)
@@ -117,9 +117,19 @@ module ActiveSupport
         @cpu_time_finish = 0.0
         @allocation_count_start = 0
         @allocation_count_finish = 0
+        @gc_time_start = 0
+        @gc_time_finish = 0
       end
 
-      def record
+      def time
+        @time / 1000.0 if @time
+      end
+
+      def end
+        @end / 1000.0 if @end
+      end
+
+      def record # :nodoc:
         start!
         begin
           yield payload if block_given?
@@ -136,12 +146,14 @@ module ActiveSupport
       def start!
         @time = now
         @cpu_time_start = now_cpu
+        @gc_time_start = now_gc
         @allocation_count_start = now_allocations
       end
 
       # Record information at the time this event finishes
       def finish!
         @cpu_time_finish = now_cpu
+        @gc_time_finish = now_gc
         @end = now
         @allocation_count_finish = now_allocations
       end
@@ -165,28 +177,17 @@ module ActiveSupport
         @allocation_count_finish - @allocation_count_start
       end
 
-      def children # :nodoc:
-        ActiveSupport.deprecator.warn <<~EOM
-          ActiveSupport::Notifications::Event#children is deprecated and will
-          be removed in Rails 7.2.
-        EOM
-        []
-      end
-
-      def parent_of?(event) # :nodoc:
-        ActiveSupport.deprecator.warn <<~EOM
-          ActiveSupport::Notifications::Event#parent_of? is deprecated and will
-          be removed in Rails 7.2.
-        EOM
-        start = (time - event.time) * 1000
-        start <= 0 && (start + duration >= event.duration)
+      # Returns the time spent in GC (in milliseconds) between the call to #start!
+      # and the call to #finish!
+      def gc_time
+        (@gc_time_finish - @gc_time_start) / 1_000_000.0
       end
 
       # Returns the difference in milliseconds between when the execution of the
       # event started and when it ended.
       #
-      #   ActiveSupport::Notifications.subscribe('wait') do |*args|
-      #     @event = ActiveSupport::Notifications::Event.new(*args)
+      #   ActiveSupport::Notifications.subscribe('wait') do |event|
+      #     @event = event
       #   end
       #
       #   ActiveSupport::Notifications.instrument('wait') do
@@ -195,7 +196,7 @@ module ActiveSupport
       #
       #   @event.duration # => 1000.138
       def duration
-        self.end - time
+        @end - @time
       end
 
       private
@@ -210,11 +211,21 @@ module ActiveSupport
             Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_millisecond)
           end
         rescue
-          def now_cpu # rubocop:disable Lint/DuplicateMethods
+          def now_cpu
             0.0
           end
         end
 
+        if GC.respond_to?(:total_time)
+          def now_gc
+            GC.total_time
+          end
+        else
+          def now_gc
+            0
+          end
+        end
+
         if GC.stat.key?(:total_allocated_objects)
           def now_allocations
             GC.stat(:total_allocated_objects)

data/lib/active_support/notifications.rb

@@ -29,6 +29,16 @@ module ActiveSupport
   # You can consume those events and the information they provide by registering
   # a subscriber.
   #
+  #   ActiveSupport::Notifications.subscribe('render') do |event|
+  #     event.name          # => "render"
+  #     event.duration      # => 10 (in milliseconds)
+  #     event.payload       # => { extra: :information }
+  #     event.allocations   # => 1826 (objects)
+  #   end
+  #
+  # +Event+ objects record CPU time and allocations. If you don't need this
+  # it's also possible to pass a block that accepts five arguments:
+  #
   #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
   #     name    # => String, name of the event (such as 'render' from above)
   #     start   # => Time, when the instrumented block started execution
@@ -42,20 +52,18 @@ module ActiveSupport
   #
   #   ActiveSupport::Notifications.monotonic_subscribe('render') do |name, start, finish, id, payload|
   #     name    # => String, name of the event (such as 'render' from above)
-  #     start   # => Monotonic time, when the instrumented block started execution
-  #     finish  # => Monotonic time, when the instrumented block ended execution
+  #     start   # => Float, monotonic time when the instrumented block started execution
+  #     finish  # => Float, monotonic time when the instrumented block ended execution
   #     id      # => String, unique ID for the instrumenter that fired the event
   #     payload # => Hash, the payload
   #   end
   #
-  # The +start+ and +finish+ values above represent monotonic time.
-  #
   # For instance, let's store all "render" events in an array:
   #
   #   events = []
   #
-  #   ActiveSupport::Notifications.subscribe('render') do |*args|
-  #     events << ActiveSupport::Notifications::Event.new(*args)
+  #   ActiveSupport::Notifications.subscribe('render') do |event|
+  #     events << event
   #   end
   #
   # That code returns right away, you are just subscribing to "render" events.
@@ -66,14 +74,10 @@ module ActiveSupport
   #   end
   #
   #   event = events.first
-  #   event.name      # => "render"
-  #   event.duration  # => 10 (in milliseconds)
-  #   event.payload   # => { extra: :information }
-  #
-  # The block in the <tt>subscribe</tt> call gets the name of the event, start
-  # timestamp, end timestamp, a string with a unique identifier for that event's instrumenter
-  # (something like "535801666f04d0298cd6"), and a hash with the payload, in
-  # that order.
+  #   event.name          # => "render"
+  #   event.duration      # => 10 (in milliseconds)
+  #   event.payload       # => { extra: :information }
+  #   event.allocations   # => 1826 (objects)
   #
   # If an exception happens during that particular instrumentation the payload will
   # have a key <tt>:exception</tt> with an array of two elements as value: a string with
@@ -138,7 +142,7 @@ module ActiveSupport
   # You can subscribe to some event temporarily while some block runs. For
   # example, in
   #
-  #   callback = lambda {|*args| ... }
+  #   callback = lambda {|event| ... }
   #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
   #     ...
   #   end
@@ -161,7 +165,7 @@ module ActiveSupport
   #
   # The +subscribe+ method returns a subscriber object:
   #
-  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |*args|
+  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |event|
   #     ...
   #   end
   #
@@ -214,11 +218,15 @@ module ActiveSupport
       # You can subscribe to events by passing a String to match exact event
       # names, or by passing a Regexp to match all events that match a pattern.
       #
-      #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
-      #     @event = ActiveSupport::Notifications::Event.new(*args)
+      # If the block passed to the method only takes one argument,
+      # it will yield an +Event+ object to the block:
+      #
+      #   ActiveSupport::Notifications.subscribe(/render/) do |event|
+      #     @event = event
       #   end
       #
-      # The +block+ will receive five parameters with information about the event:
+      # Otherwise the +block+ will receive five arguments with information
+      # about the event:
       #
       #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
       #     name    # => String, name of the event (such as 'render' from above)
@@ -228,16 +236,9 @@ module ActiveSupport
       #     payload # => Hash, the payload
       #   end
       #
-      # If the block passed to the method only takes one parameter,
-      # it will yield an event object to the block:
-      #
-      #   ActiveSupport::Notifications.subscribe(/render/) do |event|
-      #     @event = event
-      #   end
-      #
       # Raises an error if invalid event name type is passed:
       #
-      #   ActiveSupport::Notifications.subscribe(:render) {|*args| ...}
+      #   ActiveSupport::Notifications.subscribe(:render) {|event| ...}
       #   #=> ArgumentError (pattern must be specified as a String, Regexp or empty)
       #
       def subscribe(pattern = nil, callback = nil, &block)

data/lib/active_support/number_helper/number_converter.rb

@@ -164,11 +164,11 @@ module ActiveSupport
         end
 
         def translate_number_value_with_default(key, **i18n_options)
-          I18n.translate(key, **{ default: default_value(key), scope: :number }.merge!(i18n_options))
+          I18n.translate(key, default: default_value(key), scope: :number, **i18n_options)
         end
 
         def translate_in_locale(key, **i18n_options)
-          translate_number_value_with_default(key, **{ locale: options[:locale] }.merge(i18n_options))
+          translate_number_value_with_default(key, locale: options[:locale], **i18n_options)
         end
 
         def default_value(key)