activesupport 7.0.8 → 7.2.2

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2005-2022 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,11 +1,11 @@
-= Active Support -- Utility classes and Ruby extensions from Rails
+= Active Support -- Utility classes and Ruby extensions from \Rails
 
 Active Support is a collection of utility classes and standard library
-extensions that were found useful for the Rails framework. These additions
+extensions that were found useful for the \Rails framework. These additions
 reside in this package so they can be loaded as needed in Ruby projects
-outside of Rails.
+outside of \Rails.
 
-You can read more about the extensions in the {Active Support Core Extensions}[https://edgeguides.rubyonrails.org/active_support_core_extensions.html] guide.
+You can read more about the extensions in the {Active Support Core Extensions}[https://guides.rubyonrails.org/active_support_core_extensions.html] guide.
 
 == Download and installation
 

data/lib/active_support/actionable_error.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = Actionable Errors
+  #
   # Actionable errors lets you define actions to resolve an error.
   #
-  # To make an error actionable, include the <tt>ActiveSupport::ActionableError</tt>
+  # To make an error actionable, include the +ActiveSupport::ActionableError+
   # module and invoke the +action+ class macro to define the action. An action
   # needs a name and a block to execute.
   module ActionableError

data/lib/active_support/array_inquirer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = \Array Inquirer
+  #
   # Wrapping an array in an +ArrayInquirer+ gives a friendlier way to check
   # its string-like contents:
   #
@@ -37,7 +39,7 @@ module ActiveSupport
         name.end_with?("?") || super
       end
 
-      def method_missing(name, *args)
+      def method_missing(name, ...)
         if name.end_with?("?")
           any?(name[0..-2])
         else

data/lib/active_support/backtrace_cleaner.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = Backtrace Cleaner
+  #
   # Backtraces often include many lines that are not relevant for the context
   # under review. This makes it hard to find the signal amongst the backtrace
   # noise, and adds debugging time. With a BacktraceCleaner, filters and
@@ -15,11 +17,12 @@ module ActiveSupport
   # can focus on the rest.
   #
   #   bc = ActiveSupport::BacktraceCleaner.new
-  #   bc.add_filter   { |line| line.gsub(Rails.root.to_s, '') } # strip the Rails.root prefix
+  #   root = "#{Rails.root}/"
+  #   bc.add_filter   { |line| line.start_with?(root) ? line.from(root.size) : line } # strip the Rails.root prefix
   #   bc.add_silencer { |line| /puma|rubygems/.match?(line) } # skip any lines from puma or rubygems
   #   bc.clean(exception.backtrace) # perform the cleanup
   #
-  # To reconfigure an existing BacktraceCleaner (like the default one in Rails)
+  # To reconfigure an existing BacktraceCleaner (like the default one in \Rails)
   # and show as much data as possible, you can always call
   # BacktraceCleaner#remove_silencers!, which will restore the
   # backtrace to a pristine state. If you need to reconfigure an existing
@@ -31,6 +34,7 @@ module ActiveSupport
   class BacktraceCleaner
     def initialize
       @filters, @silencers = [], []
+      add_core_silencer
       add_gem_filter
       add_gem_silencer
       add_stdlib_silencer
@@ -52,11 +56,30 @@ module ActiveSupport
     end
     alias :filter :clean
 
+    # Returns the frame with all filters applied.
+    # returns +nil+ if the frame was silenced.
+    def clean_frame(frame, kind = :silent)
+      frame = frame.to_s
+      @filters.each do |f|
+        frame = f.call(frame.to_s)
+      end
+
+      case kind
+      when :silent
+        frame unless @silencers.any? { |s| s.call(frame) }
+      when :noise
+        frame if @silencers.any? { |s| s.call(frame) }
+      else
+        frame
+      end
+    end
+
     # Adds a filter from the block provided. Each line in the backtrace will be
     # mapped against this filter.
     #
-    #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
-    #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root, '') }
+    #   # Will turn "/my/rails/root/app/models/person.rb" into "app/models/person.rb"
+    #   root = "#{Rails.root}/"
+    #   backtrace_cleaner.add_filter { |line| line.start_with?(root) ? line.from(root.size) : line }
     def add_filter(&block)
       @filters << block
     end
@@ -87,6 +110,11 @@ module ActiveSupport
     private
       FORMATTED_GEMS_PATTERN = /\A[^\/]+ \([\w.]+\) /
 
+      def initialize_copy(_other)
+        @filters = @filters.dup
+        @silencers = @silencers.dup
+      end
+
       def add_gem_filter
         gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
         return if gems_paths.empty?
@@ -96,6 +124,10 @@ module ActiveSupport
         add_filter { |line| line.sub(gems_regexp, gems_result) }
       end
 
+      def add_core_silencer
+        add_silencer { |line| line.include?("<internal:") }
+      end
+
       def add_gem_silencer
         add_silencer { |line| FORMATTED_GEMS_PATTERN.match?(line) }
       end
@@ -106,7 +138,7 @@ module ActiveSupport
 
       def filter_backtrace(backtrace)
         @filters.each do |f|
-          backtrace = backtrace.map { |line| f.call(line) }
+          backtrace = backtrace.map { |line| f.call(line.to_s) }
         end
 
         backtrace
@@ -114,7 +146,7 @@ module ActiveSupport
 
       def silence(backtrace)
         @silencers.each do |s|
-          backtrace = backtrace.reject { |line| s.call(line) }
+          backtrace = backtrace.reject { |line| s.call(line.to_s) }
         end
 
         backtrace
@@ -123,7 +155,7 @@ module ActiveSupport
       def noise(backtrace)
         backtrace.select do |line|
           @silencers.any? do |s|
-            s.call(line)
+            s.call(line.to_s)
           end
         end
       end

data/lib/active_support/benchmarkable.rb

@@ -4,6 +4,7 @@ require "active_support/core_ext/benchmark"
 require "active_support/core_ext/hash/keys"
 
 module ActiveSupport
+  # = \Benchmarkable
   module Benchmarkable
     # Allows you to measure the execution time of a block in a template and
     # records the result to the log. Wrap this block around expensive operations

data/lib/active_support/broadcast_logger.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # = Active Support Broadcast Logger
+  #
+  # The Broadcast logger is a logger used to write messages to multiple IO. It is commonly used
+  # in development to display messages on STDOUT and also write them to a file (development.log).
+  # With the Broadcast logger, you can broadcast your logs to a unlimited number of sinks.
+  #
+  # The BroadcastLogger acts as a standard logger and all methods you are used to are available.
+  # However, all the methods on this logger will propagate and be delegated to the other loggers
+  # that are part of the broadcast.
+  #
+  # Broadcasting your logs.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  # Add a logger to the broadcast.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   broadcast = BroadcastLogger.new(stdout_logger)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast.broadcast_to(file_logger)
+  #
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  # Modifying the log level for all broadcasted loggers.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #
+  #   broadcast.level = Logger::FATAL # Modify the log level for the whole broadcast.
+  #
+  # Stop broadcasting log to a sink.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  #   broadcast.stop_broadcasting_to(file_logger)
+  #   broadcast.info("Hello world!") # Writes the log *only* to STDOUT.
+  #
+  # At least one sink has to be part of the broadcast. Otherwise, your logs will not
+  # be written anywhere. For instance:
+  #
+  #   broadcast = BroadcastLogger.new
+  #   broadcast.info("Hello world") # The log message will appear nowhere.
+  #
+  # If you are adding a custom logger with custom methods to the broadcast,
+  # the `BroadcastLogger` will proxy them and return the raw value, or an array
+  # of raw values, depending on how many loggers in the broadcasts responded to
+  # the method:
+  #
+  #   class MyLogger < ::Logger
+  #     def loggable?
+  #       true
+  #     end
+  #   end
+  #
+  #   logger = BroadcastLogger.new
+  #   logger.loggable? # => A NoMethodError exception is raised because no loggers in the broadcasts could respond.
+  #
+  #   logger.broadcast_to(MyLogger.new(STDOUT))
+  #   logger.loggable? # => true
+  #   logger.broadcast_to(MyLogger.new(STDOUT))
+  #   puts logger.broadcasts # => [MyLogger, MyLogger]
+  #   logger.loggable? # [true, true]
+  class BroadcastLogger
+    include ActiveSupport::LoggerSilence
+
+    # Returns all the logger that are part of this broadcast.
+    attr_reader :broadcasts
+    attr_reader :formatter
+    attr_accessor :progname
+
+    def initialize(*loggers)
+      @broadcasts = []
+      @progname = "Broadcast"
+
+      broadcast_to(*loggers)
+    end
+
+    # Add logger(s) to the broadcast.
+    #
+    #   broadcast_logger = ActiveSupport::BroadcastLogger.new
+    #   broadcast_logger.broadcast_to(Logger.new(STDOUT), Logger.new(STDERR))
+    def broadcast_to(*loggers)
+      @broadcasts.concat(loggers)
+    end
+
+    # Remove a logger from the broadcast. When a logger is removed, messages sent to
+    # the broadcast will no longer be written to its sink.
+    #
+    #   sink = Logger.new(STDOUT)
+    #   broadcast_logger = ActiveSupport::BroadcastLogger.new
+    #
+    #   broadcast_logger.stop_broadcasting_to(sink)
+    def stop_broadcasting_to(logger)
+      @broadcasts.delete(logger)
+    end
+
+    def level
+      @broadcasts.map(&:level).min
+    end
+
+    def <<(message)
+      dispatch { |logger| logger.<<(message) }
+    end
+
+    def add(...)
+      dispatch { |logger| logger.add(...) }
+    end
+    alias_method :log, :add
+
+    def debug(...)
+      dispatch { |logger| logger.debug(...) }
+    end
+
+    def info(...)
+      dispatch { |logger| logger.info(...) }
+    end
+
+    def warn(...)
+      dispatch { |logger| logger.warn(...) }
+    end
+
+    def error(...)
+      dispatch { |logger| logger.error(...) }
+    end
+
+    def fatal(...)
+      dispatch { |logger| logger.fatal(...) }
+    end
+
+    def unknown(...)
+      dispatch { |logger| logger.unknown(...) }
+    end
+
+    def formatter=(formatter)
+      dispatch { |logger| logger.formatter = formatter }
+
+      @formatter = formatter
+    end
+
+    def level=(level)
+      dispatch { |logger| logger.level = level }
+    end
+    alias_method :sev_threshold=, :level=
+
+    def local_level=(level)
+      dispatch do |logger|
+        logger.local_level = level if logger.respond_to?(:local_level=)
+      end
+    end
+
+    def close
+      dispatch { |logger| logger.close }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::DEBUG to be written
+    # to at least one broadcast. +False+ otherwise.
+    def debug?
+      @broadcasts.any? { |logger| logger.debug? }
+    end
+
+    # Sets the log level to Logger::DEBUG for the whole broadcast.
+    def debug!
+      dispatch { |logger| logger.debug! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::INFO to be written
+    # to at least one broadcast. +False+ otherwise.
+    def info?
+      @broadcasts.any? { |logger| logger.info? }
+    end
+
+    # Sets the log level to Logger::INFO for the whole broadcast.
+    def info!
+      dispatch { |logger| logger.info! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::WARN to be written
+    # to at least one broadcast. +False+ otherwise.
+    def warn?
+      @broadcasts.any? { |logger| logger.warn? }
+    end
+
+    # Sets the log level to Logger::WARN for the whole broadcast.
+    def warn!
+      dispatch { |logger| logger.warn! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::ERROR to be written
+    # to at least one broadcast. +False+ otherwise.
+    def error?
+      @broadcasts.any? { |logger| logger.error? }
+    end
+
+    # Sets the log level to Logger::ERROR for the whole broadcast.
+    def error!
+      dispatch { |logger| logger.error! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::FATAL to be written
+    # to at least one broadcast. +False+ otherwise.
+    def fatal?
+      @broadcasts.any? { |logger| logger.fatal? }
+    end
+
+    # Sets the log level to Logger::FATAL for the whole broadcast.
+    def fatal!
+      dispatch { |logger| logger.fatal! }
+    end
+
+    def initialize_copy(other)
+      @broadcasts = []
+      @progname = other.progname.dup
+      @formatter = other.formatter.dup
+
+      broadcast_to(*other.broadcasts.map(&:dup))
+    end
+
+    private
+      def dispatch(&block)
+        @broadcasts.each { |logger| block.call(logger) }
+        true
+      end
+
+      def method_missing(name, ...)
+        loggers = @broadcasts.select { |logger| logger.respond_to?(name) }
+
+        if loggers.none?
+          super
+        elsif loggers.one?
+          loggers.first.send(name, ...)
+        else
+          loggers.map { |logger| logger.send(name, ...) }
+        end
+      end
+
+      def respond_to_missing?(method, include_all)
+        @broadcasts.any? { |logger| logger.respond_to?(method, include_all) }
+      end
+  end
+end

data/lib/active_support/builder.rb

@@ -3,6 +3,6 @@
 begin
   require "builder"
 rescue LoadError => e
-  $stderr.puts "You don't have builder installed in your application. Please add it to your Gemfile and run bundle install"
+  warn "You don't have builder installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
 end

data/lib/active_support/cache/coder.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "entry"
+
+module ActiveSupport
+  module Cache
+    class Coder # :nodoc:
+      def initialize(serializer, compressor, legacy_serializer: false)
+        @serializer = serializer
+        @compressor = compressor
+        @legacy_serializer = legacy_serializer
+      end
+
+      def dump(entry)
+        return @serializer.dump(entry) if @legacy_serializer
+
+        dump_compressed(entry, Float::INFINITY)
+      end
+
+      def dump_compressed(entry, threshold)
+        return @serializer.dump_compressed(entry, threshold) if @legacy_serializer
+
+        # If value is a string with a supported encoding, use it as the payload
+        # instead of passing it through the serializer.
+        if type = type_for_string(entry.value)
+          payload = entry.value.b
+        else
+          type = OBJECT_DUMP_TYPE
+          payload = @serializer.dump(entry.value)
+        end
+
+        if compressed = try_compress(payload, threshold)
+          payload = compressed
+          type = type | COMPRESSED_FLAG
+        end
+
+        expires_at = entry.expires_at || -1.0
+
+        version = dump_version(entry.version) if entry.version
+        version_length = version&.bytesize || -1
+
+        packed = SIGNATURE.b
+        packed << [type, expires_at, version_length].pack(PACKED_TEMPLATE)
+        packed << version if version
+        packed << payload
+      end
+
+      def load(dumped)
+        return @serializer.load(dumped) if !signature?(dumped)
+
+        type = dumped.unpack1(PACKED_TYPE_TEMPLATE)
+        expires_at = dumped.unpack1(PACKED_EXPIRES_AT_TEMPLATE)
+        version_length = dumped.unpack1(PACKED_VERSION_LENGTH_TEMPLATE)
+
+        expires_at = nil if expires_at < 0
+        version = load_version(dumped.byteslice(PACKED_VERSION_INDEX, version_length)) if version_length >= 0
+        payload = dumped.byteslice((PACKED_VERSION_INDEX + [version_length, 0].max)..)
+
+        compressor = @compressor if type & COMPRESSED_FLAG > 0
+        serializer = STRING_DESERIALIZERS[type & ~COMPRESSED_FLAG] || @serializer
+
+        LazyEntry.new(serializer, compressor, payload, version: version, expires_at: expires_at)
+      end
+
+      private
+        SIGNATURE = "\x00\x11".b.freeze
+
+        OBJECT_DUMP_TYPE = 0x01
+
+        STRING_ENCODINGS = {
+          0x02 => Encoding::UTF_8,
+          0x03 => Encoding::BINARY,
+          0x04 => Encoding::US_ASCII,
+        }
+
+        COMPRESSED_FLAG = 0x80
+
+        PACKED_TEMPLATE = "CEl<"
+        PACKED_TYPE_TEMPLATE = "@#{SIGNATURE.bytesize}C"
+        PACKED_EXPIRES_AT_TEMPLATE = "@#{[0].pack(PACKED_TYPE_TEMPLATE).bytesize}E"
+        PACKED_VERSION_LENGTH_TEMPLATE = "@#{[0].pack(PACKED_EXPIRES_AT_TEMPLATE).bytesize}l<"
+        PACKED_VERSION_INDEX = [0].pack(PACKED_VERSION_LENGTH_TEMPLATE).bytesize
+
+        MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+        class StringDeserializer
+          def initialize(encoding)
+            @encoding = encoding
+          end
+
+          def load(payload)
+            payload.force_encoding(@encoding)
+          end
+        end
+
+        STRING_DESERIALIZERS = STRING_ENCODINGS.transform_values { |encoding| StringDeserializer.new(encoding) }
+
+        class LazyEntry < Cache::Entry
+          def initialize(serializer, compressor, payload, **options)
+            super(payload, **options)
+            @serializer = serializer
+            @compressor = compressor
+            @resolved = false
+          end
+
+          def value
+            if !@resolved
+              @value = @serializer.load(@compressor ? @compressor.inflate(@value) : @value)
+              @resolved = true
+            end
+            @value
+          end
+
+          def mismatched?(version)
+            super.tap { |mismatched| value if !mismatched }
+          rescue Cache::DeserializationError
+            true
+          end
+        end
+
+        def signature?(dumped)
+          dumped.is_a?(String) && dumped.start_with?(SIGNATURE)
+        end
+
+        def type_for_string(value)
+          STRING_ENCODINGS.key(value.encoding) if value.instance_of?(String)
+        end
+
+        def try_compress(string, threshold)
+          if @compressor && string.bytesize >= threshold
+            compressed = @compressor.deflate(string)
+            compressed if compressed.bytesize < string.bytesize
+          end
+        end
+
+        def dump_version(version)
+          if version.encoding != Encoding::UTF_8 || version.start_with?(MARSHAL_SIGNATURE)
+            Marshal.dump(version)
+          else
+            version.b
+          end
+        end
+
+        def load_version(dumped_version)
+          if dumped_version.start_with?(MARSHAL_SIGNATURE)
+            Marshal.load(dumped_version)
+          else
+            dumped_version.force_encoding(Encoding::UTF_8)
+          end
+        end
+    end
+  end
+end