activesupport 7.1.3.4 → 7.2.0.beta1

data/lib/active_support/error_reporter.rb

@@ -26,12 +26,16 @@ module ActiveSupport
   class ErrorReporter
     SEVERITIES = %i(error warning info)
     DEFAULT_SOURCE = "application"
+    DEFAULT_RESCUE = [StandardError].freeze
 
-    attr_accessor :logger
+    attr_accessor :logger, :debug_mode
+
+    UnexpectedError = Class.new(Exception)
 
     def initialize(*subscribers, logger: nil)
       @subscribers = subscribers.flatten
       @logger = logger
+      @debug_mode = false
     end
 
     # Evaluates the given block, reporting and swallowing any unhandled error.
@@ -72,7 +76,7 @@ module ActiveSupport
     #   source of the error. Subscribers can use this value to ignore certain
     #   errors. Defaults to <tt>"application"</tt>.
     def handle(*error_classes, severity: :warning, context: {}, fallback: nil, source: DEFAULT_SOURCE)
-      error_classes = [StandardError] if error_classes.blank?
+      error_classes = DEFAULT_RESCUE if error_classes.empty?
       yield
     rescue *error_classes => error
       report(error, handled: true, severity: severity, context: context, source: source)
@@ -108,13 +112,47 @@ module ActiveSupport
     #   source of the error. Subscribers can use this value to ignore certain
     #   errors. Defaults to <tt>"application"</tt>.
     def record(*error_classes, severity: :error, context: {}, source: DEFAULT_SOURCE)
-      error_classes = [StandardError] if error_classes.blank?
+      error_classes = DEFAULT_RESCUE if error_classes.empty?
       yield
     rescue *error_classes => error
       report(error, handled: false, severity: severity, context: context, source: source)
       raise
     end
 
+    # Either report the given error when in production, or raise it when in development or test.
+    #
+    # When called in production, after the error is reported, this method will return
+    # nil and execution will continue.
+    #
+    # When called in development, the original error is wrapped in a different error class to ensure
+    # it's not being rescued higher in the stack and will be surfaced to the developer.
+    #
+    # This method is intended for reporting violated assertions about preconditions, or similar
+    # cases that can and should be gracefully handled in production, but that aren't supposed to happen.
+    #
+    # The error can be either an exception instance or a String.
+    #
+    #   example:
+    #
+    #     def edit
+    #       if published?
+    #         Rails.error.unexpected("[BUG] Attempting to edit a published article, that shouldn't be possible")
+    #         return false
+    #       end
+    #       # ...
+    #     end
+    #
+    def unexpected(error, severity: :warning, context: {}, source: DEFAULT_SOURCE)
+      error = RuntimeError.new(error) if error.is_a?(String)
+      error.set_backtrace(caller(1)) if error.backtrace.nil?
+
+      if @debug_mode
+        raise UnexpectedError, "#{error.class.name}: #{error.message}", error.backtrace, cause: error
+      else
+        report(error, handled: true, severity: severity, context: context, source: source)
+      end
+    end
+
     # Register a new error subscriber. The subscriber must respond to
     #
     #   report(Exception, handled: Boolean, severity: (:error OR :warning OR :info), context: Hash, source: String)

data/lib/active_support/evented_file_update_checker.rb

@@ -6,7 +6,6 @@ require "listen"
 require "set"
 require "pathname"
 require "concurrent/atomic/atomic_boolean"
-require "active_support/fork_tracker"
 
 module ActiveSupport
   # Allows you to "listen" to changes in a file system.

data/lib/active_support/execution_wrapper.rb

@@ -2,7 +2,6 @@
 
 require "active_support/error_reporter"
 require "active_support/callbacks"
-require "concurrent/hash"
 
 module ActiveSupport
   class ExecutionWrapper

data/lib/active_support/file_update_checker.rb

@@ -104,7 +104,7 @@ module ActiveSupport
         @watched || begin
           all = @files.select { |f| File.exist?(f) }
           all.concat(Dir[@glob]) if @glob
-          all
+          all.tap(&:uniq!)
         end
       end
 

data/lib/active_support/fork_tracker.rb

@@ -2,7 +2,7 @@
 
 module ActiveSupport
   module ForkTracker # :nodoc:
-    module ModernCoreExt
+    module CoreExt
       def _fork
         pid = super
         if pid == 0
@@ -12,27 +12,6 @@ module ActiveSupport
       end
     end
 
-    module CoreExt
-      def fork(...)
-        if block_given?
-          super do
-            ForkTracker.check!
-            yield
-          end
-        else
-          unless pid = super
-            ForkTracker.check!
-          end
-          pid
-        end
-      end
-    end
-
-    module CoreExtPrivate
-      include CoreExt
-      private :fork
-    end
-
     @pid = Process.pid
     @callbacks = []
 
@@ -45,23 +24,8 @@ module ActiveSupport
         end
       end
 
-      if Process.respond_to?(:_fork) # Ruby 3.1+
-        def check!
-          # We trust the `_fork` callback
-        end
-      else
-        alias_method :check!, :after_fork_callback
-      end
-
       def hook!
-        if Process.respond_to?(:_fork) # Ruby 3.1+
-          ::Process.singleton_class.prepend(ModernCoreExt)
-        elsif Process.respond_to?(:fork)
-          ::Object.prepend(CoreExtPrivate) if RUBY_VERSION < "3.0"
-          ::Kernel.prepend(CoreExtPrivate)
-          ::Kernel.singleton_class.prepend(CoreExt)
-          ::Process.singleton_class.prepend(CoreExt)
-        end
+        ::Process.singleton_class.prepend(CoreExt)
       end
 
       def after_fork(&block)

data/lib/active_support/gem_version.rb

@@ -8,9 +8,9 @@ module ActiveSupport
 
   module VERSION
     MAJOR = 7
-    MINOR = 1
-    TINY  = 3
-    PRE   = "4"
+    MINOR = 2
+    TINY  = 0
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/hash_with_indifferent_access.rb

@@ -387,15 +387,13 @@ module ActiveSupport
       _new_hash
     end
 
+    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)

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/json/encoding.rb

@@ -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/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/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,6 +1,5 @@
 # frozen_string_literal: true
 
-require "mutex_m"
 require "concurrent/map"
 require "set"
 require "active_support/core_ext/object/try"
@@ -49,15 +48,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 +64,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 +80,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 +297,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)

data/lib/active_support/option_merger.rb

@@ -31,8 +31,8 @@ module ActiveSupport
         end
       end
 
-      def respond_to_missing?(*arguments)
-        @context.respond_to?(*arguments)
+      def respond_to_missing?(...)
+        @context.respond_to?(...)
       end
   end
 end