activesupport 7.1.5.1 → 7.2.2.1

data/lib/active_support/descendants_tracker.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "weakref"
-require "active_support/ruby_features"
 
 module ActiveSupport
   # = Active Support Descendants Tracker
@@ -95,96 +94,19 @@ module ActiveSupport
       end
     end
 
-    if RubyFeatures::CLASS_SUBCLASSES
-      class << self
-        def subclasses(klass)
-          klass.subclasses
-        end
-
-        def descendants(klass)
-          klass.descendants
-        end
-      end
-
-      def descendants
-        subclasses = DescendantsTracker.reject!(self.subclasses)
-        subclasses.concat(subclasses.flat_map(&:descendants))
-      end
-    else
-      # DescendantsArray is an array that contains weak references to classes.
-      # Note: DescendantsArray is redundant with WeakSet, however WeakSet when used
-      # on Ruby 2.7 or 3.0 can trigger a Ruby crash: https://bugs.ruby-lang.org/issues/18928
-      class DescendantsArray # :nodoc:
-        include Enumerable
-
-        def initialize
-          @refs = []
-        end
-
-        def <<(klass)
-          @refs << WeakRef.new(klass)
-        end
-
-        def each
-          @refs.reject! do |ref|
-            yield ref.__getobj__
-            false
-          rescue WeakRef::RefError
-            true
-          end
-          self
-        end
-
-        def refs_size
-          @refs.size
-        end
-
-        def cleanup!
-          @refs.delete_if { |ref| !ref.weakref_alive? }
-        end
-
-        def reject!
-          @refs.reject! do |ref|
-            yield ref.__getobj__
-          rescue WeakRef::RefError
-            true
-          end
-        end
-      end
-
-      @direct_descendants = {}
-
-      class << self
-        def subclasses(klass)
-          descendants = @direct_descendants[klass]
-          descendants ? DescendantsTracker.reject!(descendants.to_a) : []
-        end
-
-        def descendants(klass)
-          subclasses = self.subclasses(klass)
-          subclasses.concat(subclasses.flat_map { |k| descendants(k) })
-        end
-
-        # This is the only method that is not thread safe, but is only ever called
-        # during the eager loading phase.
-        def store_inherited(klass, descendant) # :nodoc:
-          (@direct_descendants[klass] ||= DescendantsArray.new) << descendant
-        end
-      end
-
-      def subclasses
-        DescendantsTracker.subclasses(self)
+    class << self
+      def subclasses(klass)
+        klass.subclasses
       end
 
-      def descendants
-        DescendantsTracker.descendants(self)
+      def descendants(klass)
+        klass.descendants
       end
+    end
 
-      private
-        def inherited(base) # :nodoc:
-          DescendantsTracker.store_inherited(self, base)
-          super
-        end
+    def descendants
+      subclasses = DescendantsTracker.reject!(self.subclasses)
+      subclasses.concat(subclasses.flat_map(&:descendants))
     end
   end
 end

data/lib/active_support/duration/iso8601_parser.rb

@@ -102,12 +102,12 @@ module ActiveSupport
           raise_parsing_error("is empty duration") if parts.empty?
 
           # Mixing any of Y, M, D with W is invalid.
-          if parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
+          if parts.key?(:weeks) && parts.keys.intersect?(DATE_COMPONENTS)
             raise_parsing_error("mixing weeks with other date parts not allowed")
           end
 
           # Specifying an empty T part is invalid.
-          if mode == :time && (parts.keys & TIME_COMPONENTS).empty?
+          if mode == :time && !parts.keys.intersect?(TIME_COMPONENTS)
             raise_parsing_error("time part marker is present but time part is empty")
           end
 

data/lib/active_support/duration/iso8601_serializer.rb

@@ -35,7 +35,6 @@ module ActiveSupport
         # Return pair of duration's parts and whole duration sign.
         # Parts are summarized (as they can become repetitive due to addition, etc).
         # Zero parts are removed as not significant.
-        # If all parts are negative it will negate all of them and return minus as a sign.
         def normalize
           parts = @duration.parts.each_with_object(Hash.new(0)) do |(k, v), p|
             p[k] += v  unless v.zero?
@@ -50,7 +49,7 @@ module ActiveSupport
         end
 
         def week_mixed_with_date?(parts)
-          parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
+          parts.key?(:weeks) && parts.keys.intersect?(DATE_COMPONENTS)
         end
 
         def format_seconds(seconds)

data/lib/active_support/duration.rb

@@ -14,7 +14,7 @@ module ActiveSupport
   class Duration
     class Scalar < Numeric # :nodoc:
       attr_reader :value
-      delegate :to_i, :to_f, :to_s, to: :value
+      delegate :to_i, :to_f, :to_s, to: :@value
 
       def initialize(value)
         @value = value
@@ -221,6 +221,8 @@ module ActiveSupport
         end
     end
 
+    Delegation.generate(self, [:to_f, :positive?, :negative?, :zero?, :abs], to: :@value, as: Integer, nilable: false)
+
     def initialize(value, parts, variable = nil) # :nodoc:
       @value, @parts = value, parts
       @parts.reject! { |k, v| v.zero? } unless value == 0
@@ -232,7 +234,10 @@ module ActiveSupport
       end
     end
 
-    # Returns a copy of the parts hash that defines the duration
+    # Returns a copy of the parts hash that defines the duration.
+    #
+    #   5.minutes.parts # => {:minutes=>5}
+    #   3.years.parts # => {:years=>3}
     def parts
       @parts.dup
     end
@@ -366,8 +371,8 @@ module ActiveSupport
     #   1.year.to_i     # => 31556952
     #
     # In such cases, Ruby's core
-    # Date[https://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
-    # Time[https://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+    # Date[https://docs.ruby-lang.org/en/master/Date.html] and
+    # Time[https://docs.ruby-lang.org/en/master/Time.html] should be used for precision
     # date and time arithmetic.
     def to_i
       @value.to_i
@@ -504,8 +509,8 @@ module ActiveSupport
         value.respond_to?(method)
       end
 
-      def method_missing(method, *args, &block)
-        value.public_send(method, *args, &block)
+      def method_missing(...)
+        value.public_send(...)
       end
 
       def raise_type_error(other)

data/lib/active_support/encrypted_file.rb

@@ -69,7 +69,7 @@ module ActiveSupport
     #   decrypted or verified.
     def read
       if !key.nil? && content_path.exist?
-        decrypt content_path.binread
+        decrypt content_path.binread.strip
       else
         raise MissingContentError, content_path
       end

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,8 +8,8 @@ module ActiveSupport
 
   module VERSION
     MAJOR = 7
-    MINOR = 1
-    TINY  = 5
+    MINOR = 2
+    TINY  = 2
     PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

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

data/lib/active_support/log_subscriber.rb

@@ -62,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,
@@ -182,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/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) }