activesupport 7.0.8.3 → 7.1.0.beta1

data/lib/active_support/parameter_filter.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/duplicable"
+require "active_support/core_ext/array/extract"
 
 module ActiveSupport
+  # = Active Support Parameter Filter
+  #
   # +ParameterFilter+ replaces values in a <tt>Hash</tt>-like object if their
   # keys match one of the specified filters.
   #
@@ -36,6 +39,34 @@ module ActiveSupport
   class ParameterFilter
     FILTERED = "[FILTERED]" # :nodoc:
 
+    # Precompiles an array of filters that otherwise would be passed directly to
+    # #initialize. Depending on the quantity and types of filters,
+    # precompilation can improve filtering performance, especially in the case
+    # where the ParameterFilter instance itself cannot be retained (but the
+    # precompiled filters can be retained).
+    #
+    #   filters = [/foo/, :bar, "nested.baz", /nested\.qux/]
+    #
+    #   precompiled = ActiveSupport::ParameterFilter.precompile_filters(filters)
+    #   # => [/(?-mix:foo)|(?i:bar)/, /(?i:nested\.baz)|(?-mix:nested\.qux)/]
+    #
+    #   ActiveSupport::ParameterFilter.new(precompiled)
+    #
+    def self.precompile_filters(filters)
+      filters, patterns = filters.partition { |filter| filter.is_a?(Proc) }
+
+      patterns.map! do |pattern|
+        pattern.is_a?(Regexp) ? pattern : "(?i:#{Regexp.escape pattern.to_s})"
+      end
+
+      deep_patterns = patterns.extract! { |pattern| pattern.to_s.include?("\\.") }
+
+      filters << Regexp.new(patterns.join("|")) if patterns.any?
+      filters << Regexp.new(deep_patterns.join("|")) if deep_patterns.any?
+
+      filters
+    end
+
     # Create instance with given filters. Supported type of filters are +String+, +Regexp+, and +Proc+.
     # Other types of filters are treated as +String+ using +to_s+.
     # For +Proc+ filters, key, value, and optional original hash is passed to block arguments.
@@ -44,99 +75,83 @@ module ActiveSupport
     #
     # * <tt>:mask</tt> - A replaced object when filtered. Defaults to <tt>"[FILTERED]"</tt>.
     def initialize(filters = [], mask: FILTERED)
-      @filters = filters
       @mask = mask
+      compile_filters!(filters)
     end
 
     # Mask value of +params+ if key matches one of filters.
     def filter(params)
-      compiled_filter.call(params)
+      @no_filters ? params.dup : call(params)
     end
 
     # Returns filtered value for given key. For +Proc+ filters, third block argument is not populated.
     def filter_param(key, value)
-      @filters.empty? ? value : compiled_filter.value_for_key(key, value)
+      @no_filters ? value : value_for_key(key, value)
     end
 
   private
-    def compiled_filter
-      @compiled_filter ||= CompiledFilter.compile(@filters, mask: @mask)
-    end
-
-    class CompiledFilter # :nodoc:
-      def self.compile(filters, mask:)
-        return lambda { |params| params.dup } if filters.empty?
-
-        strings, regexps, blocks, deep_regexps, deep_strings = [], [], [], nil, nil
-
-        filters.each do |item|
-          case item
-          when Proc
-            blocks << item
-          when Regexp
-            if item.to_s.include?("\\.")
-              (deep_regexps ||= []) << item
-            else
-              regexps << item
-            end
+    def compile_filters!(filters)
+      @no_filters = filters.empty?
+      return if @no_filters
+
+      @regexps, strings = [], []
+      @deep_regexps, deep_strings = nil, nil
+      @blocks = nil
+
+      filters.each do |item|
+        case item
+        when Proc
+          (@blocks ||= []) << item
+        when Regexp
+          if item.to_s.include?("\\.")
+            (@deep_regexps ||= []) << item
+          else
+            @regexps << item
+          end
+        else
+          s = Regexp.escape(item.to_s)
+          if s.include?("\\.")
+            (deep_strings ||= []) << s
           else
-            s = Regexp.escape(item.to_s)
-            if s.include?("\\.")
-              (deep_strings ||= []) << s
-            else
-              strings << s
-            end
+            strings << s
           end
         end
-
-        regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
-        (deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings&.any?
-
-        new regexps, deep_regexps, blocks, mask: mask
       end
 
-      attr_reader :regexps, :deep_regexps, :blocks
+      @regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
+      (@deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings
+    end
+
+    def call(params, full_parent_key = nil, original_params = params)
+      filtered_params = params.class.new
 
-      def initialize(regexps, deep_regexps, blocks, mask:)
-        @regexps = regexps
-        @deep_regexps = deep_regexps&.any? ? deep_regexps : nil
-        @blocks = blocks
-        @mask = mask
+      params.each do |key, value|
+        filtered_params[key] = value_for_key(key, value, full_parent_key, original_params)
       end
 
-      def call(params, parents = [], original_params = params)
-        filtered_params = params.class.new
-
-        params.each do |key, value|
-          filtered_params[key] = value_for_key(key, value, parents, original_params)
-        end
+      filtered_params
+    end
 
-        filtered_params
+    def value_for_key(key, value, full_parent_key = nil, original_params = nil)
+      if @deep_regexps
+        full_key = full_parent_key ? "#{full_parent_key}.#{key}" : key.to_s
       end
 
-      def value_for_key(key, value, parents = [], original_params = nil)
-        parents.push(key) if deep_regexps
-        if regexps.any? { |r| r.match?(key.to_s) }
-          value = @mask
-        elsif deep_regexps && (joined = parents.join(".")) && deep_regexps.any? { |r| r.match?(joined) }
-          value = @mask
-        elsif value.is_a?(Hash)
-          value = call(value, parents, original_params)
-        elsif value.is_a?(Array)
-          # If we don't pop the current parent it will be duplicated as we
-          # process each array value.
-          parents.pop if deep_regexps
-          value = value.map { |v| value_for_key(key, v, parents, original_params) }
-          # Restore the parent stack after processing the array.
-          parents.push(key) if deep_regexps
-        elsif blocks.any?
-          key = key.dup if key.duplicable?
-          value = value.dup if value.duplicable?
-          blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
-        end
-        parents.pop if deep_regexps
-        value
+      if @regexps.any? { |r| r.match?(key.to_s) }
+        value = @mask
+      elsif @deep_regexps&.any? { |r| r.match?(full_key) }
+        value = @mask
+      elsif value.is_a?(Hash)
+        value = call(value, full_key, original_params)
+      elsif value.is_a?(Array)
+        value = value.map { |v| value_for_key(key, v, full_parent_key, original_params) }
+      elsif @blocks
+        key = key.dup if key.duplicable?
+        value = value.dup if value.duplicable?
+        @blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
       end
+
+      value
     end
   end
 end

data/lib/active_support/proxy_object.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = Active Support Proxy \Object
+  #
   # A class with no predefined methods that behaves similarly to Builder's
   # BlankSlate. Used for proxy classes.
   class ProxyObject < ::BasicObject

data/lib/active_support/railtie.rb

@@ -6,10 +6,13 @@ require "active_support/i18n_railtie"
 module ActiveSupport
   class Railtie < Rails::Railtie # :nodoc:
     config.active_support = ActiveSupport::OrderedOptions.new
-    config.active_support.disable_to_s_conversion = false
 
     config.eager_load_namespaces << ActiveSupport
 
+    initializer "active_support.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_support] = ActiveSupport.deprecator
+    end
+
     initializer "active_support.isolation_level" do |app|
       config.after_initialize do
         if level = app.config.active_support.delete(:isolation_level)
@@ -18,11 +21,10 @@ module ActiveSupport
       end
     end
 
-    initializer "active_support.remove_deprecated_time_with_zone_name" do |app|
+    initializer "active_support.raise_on_invalid_cache_expiration_time" do |app|
       config.after_initialize do
-        if app.config.active_support.remove_deprecated_time_with_zone_name
-          require "active_support/time_with_zone"
-          TimeWithZone.singleton_class.remove_method(:name)
+        if app.config.active_support.raise_on_invalid_cache_expiration_time
+          ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time = true
         end
       end
     end
@@ -63,20 +65,20 @@ module ActiveSupport
 
     initializer "active_support.deprecation_behavior" do |app|
       if app.config.active_support.report_deprecations == false
-        ActiveSupport::Deprecation.silenced = true
-        ActiveSupport::Deprecation.behavior = :silence
-        ActiveSupport::Deprecation.disallowed_behavior = :silence
+        app.deprecators.silenced = true
+        app.deprecators.behavior = :silence
+        app.deprecators.disallowed_behavior = :silence
       else
         if deprecation = app.config.active_support.deprecation
-          ActiveSupport::Deprecation.behavior = deprecation
+          app.deprecators.behavior = deprecation
         end
 
         if disallowed_deprecation = app.config.active_support.disallowed_deprecation
-          ActiveSupport::Deprecation.disallowed_behavior = disallowed_deprecation
+          app.deprecators.disallowed_behavior = disallowed_deprecation
         end
 
         if disallowed_warnings = app.config.active_support.disallowed_deprecation_warnings
-          ActiveSupport::Deprecation.disallowed_warnings = disallowed_warnings
+          app.deprecators.disallowed_warnings = disallowed_warnings
         end
       end
     end
@@ -113,14 +115,18 @@ module ActiveSupport
       end
     end
 
-    initializer "active_support.set_error_reporter" do |app|
-      ActiveSupport.error_reporter = app.executor.error_reporter
-    end
-
     initializer "active_support.set_configs" do |app|
       app.config.active_support.each do |k, v|
-        k = "#{k}="
-        ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
+        if k == "disable_to_s_conversion"
+          ActiveSupport.deprecator.warn("config.active_support.disable_to_s_conversion is deprecated and will be removed in Rails 7.2.")
+        elsif k == "remove_deprecated_time_with_zone_name"
+          ActiveSupport.deprecator.warn("config.active_support.remove_deprecated_time_with_zone_name is deprecated and will be removed in Rails 7.2.")
+        elsif k == "use_rfc4122_namespaced_uuids"
+          ActiveSupport.deprecator.warn("config.active_support.use_rfc4122_namespaced_uuids is deprecated and will be removed in Rails 7.2.")
+        else
+          k = "#{k}="
+          ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
+        end
       end
     end
 
@@ -140,13 +146,19 @@ module ActiveSupport
       end
     end
 
-    initializer "active_support.set_rfc4122_namespaced_uuids" do |app|
+    initializer "active_support.set_default_message_serializer" do |app|
       config.after_initialize do
-        if app.config.active_support.use_rfc4122_namespaced_uuids
-          require "active_support/core_ext/digest"
-          ::Digest::UUID.use_rfc4122_namespaced_uuids = app.config.active_support.use_rfc4122_namespaced_uuids
+        if message_serializer = app.config.active_support.message_serializer
+          ActiveSupport::Messages::Codec.default_serializer = message_serializer
         end
       end
     end
+
+    initializer "active_support.set_use_message_serializer_for_metadata" do |app|
+      config.after_initialize do
+        ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata =
+          app.config.active_support.use_message_serializer_for_metadata
+      end
+    end
   end
 end

data/lib/active_support/reloader.rb

@@ -4,7 +4,8 @@ require "active_support/execution_wrapper"
 require "active_support/executor"
 
 module ActiveSupport
-  #--
+  # = Active Support \Reloader
+  #
   # This class defines several callbacks:
   #
   #   to_prepare -- Run once at application startup, and also from
@@ -67,9 +68,16 @@ module ActiveSupport
     end
 
     # Run the supplied block as a work unit, reloading code as needed
-    def self.wrap
-      executor.wrap do
-        super
+    def self.wrap(**kwargs)
+      return yield if active?
+
+      executor.wrap(**kwargs) do
+        instance = run!
+        begin
+          yield
+        ensure
+          instance.complete!
+        end
       end
     end
 

data/lib/active_support/rescuable.rb

@@ -5,6 +5,8 @@ require "active_support/core_ext/class/attribute"
 require "active_support/core_ext/string/inflections"
 
 module ActiveSupport
+  # = Active Support \Rescuable
+  #
   # Rescuable module adds support for easier exception handling.
   module Rescuable
     extend Concern

data/lib/active_support/secure_compare_rotator.rb

@@ -4,6 +4,8 @@ require "active_support/security_utils"
 require "active_support/messages/rotator"
 
 module ActiveSupport
+  # = Secure Compare Rotator
+  #
   # The ActiveSupport::SecureCompareRotator is a wrapper around ActiveSupport::SecurityUtils.secure_compare
   # and allows you to rotate a previously defined value to a new one.
   #
@@ -29,23 +31,28 @@ module ActiveSupport
   #   end
   class SecureCompareRotator
     include SecurityUtils
-    prepend Messages::Rotator
 
     InvalidMatch = Class.new(StandardError)
 
-    def initialize(value, **_options)
+    def initialize(value, on_rotation: nil)
       @value = value
+      @rotate_values = []
+      @on_rotation = on_rotation
     end
 
-    def secure_compare!(other_value, on_rotation: @on_rotation)
-      secure_compare(@value, other_value) ||
-        run_rotations(on_rotation) { |wrapper| wrapper.secure_compare!(other_value) } ||
-        raise(InvalidMatch)
+    def rotate(previous_value)
+      @rotate_values << previous_value
     end
 
-    private
-      def build_rotation(previous_value, _options)
-        self.class.new(previous_value)
+    def secure_compare!(other_value, on_rotation: @on_rotation)
+      if secure_compare(@value, other_value)
+        true
+      elsif @rotate_values.any? { |value| secure_compare(value, other_value) }
+        on_rotation&.call
+        true
+      else
+        raise InvalidMatch
       end
+    end
   end
 end

data/lib/active_support/string_inquirer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = \String Inquirer
+  #
   # Wrapping a string in this class gives you a prettier way to test
   # for equality. The value returned by <tt>Rails.env</tt> is wrapped
   # in a StringInquirer object, so instead of calling this:
@@ -11,7 +13,7 @@ module ActiveSupport
   #
   #   Rails.env.production?
   #
-  # == Instantiating a new StringInquirer
+  # == Instantiating a new \StringInquirer
   #
   #   vehicle = ActiveSupport::StringInquirer.new('car')
   #   vehicle.car?   # => true

data/lib/active_support/subscriber.rb

@@ -3,7 +3,9 @@
 require "active_support/notifications"
 
 module ActiveSupport
-  # ActiveSupport::Subscriber is an object set to consume
+  # = Active Support \Subscriber
+  #
+  # +ActiveSupport::Subscriber+ is an object set to consume
   # ActiveSupport::Notifications. The subscriber dispatches notifications to
   # a registered object based on its given namespace.
   #
@@ -20,9 +22,9 @@ module ActiveSupport
   #     end
   #   end
   #
-  # After configured, whenever a "sql.active_record" notification is published,
-  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
-  # the +sql+ method.
+  # After configured, whenever a <tt>"sql.active_record"</tt> notification is
+  # published, it will properly dispatch the event
+  # (ActiveSupport::Notifications::Event) to the +sql+ method.
   #
   # We can detach a subscriber as well:
   #
@@ -126,38 +128,18 @@ module ActiveSupport
     attr_reader :patterns # :nodoc:
 
     def initialize
-      @queue_key = [self.class.name, object_id].join "-"
       @patterns  = {}
       super
     end
 
-    def start(name, id, payload)
-      event = ActiveSupport::Notifications::Event.new(name, nil, nil, id, payload)
-      event.start!
-      parent = event_stack.last
-      parent << event if parent
-
-      event_stack.push event
-    end
-
-    def finish(name, id, payload)
-      event = event_stack.pop
-      event.finish!
-      event.payload.merge!(payload)
-
-      method = name.split(".").first
+    def call(event)
+      method = event.name[0, event.name.index(".")]
       send(method, event)
     end
 
     def publish_event(event) # :nodoc:
-      method = event.name.split(".").first
+      method = event.name[0, event.name.index(".")]
       send(method, event)
     end
-
-    private
-      def event_stack
-        registry = ActiveSupport::IsolatedExecutionState[:active_support_subscriber_queue_registry] ||= {}
-        registry[@queue_key] ||= []
-      end
   end
 end

data/lib/active_support/syntax_error_proxy.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ActiveSupport
+  # This is a class for wrapping syntax errors.  The purpose of this class
+  # is to enhance the backtraces on SyntaxError exceptions to include the
+  # source location of the syntax error.  That way we can display the error
+  # source on error pages in development.
+  class SyntaxErrorProxy < DelegateClass(SyntaxError) # :nodoc:
+    def backtrace
+      parse_message_for_trace + super
+    end
+
+    class BacktraceLocation < Struct.new(:path, :lineno, :to_s) # :nodoc:
+      def spot(_)
+      end
+
+      def label
+      end
+    end
+
+    class BacktraceLocationProxy < DelegateClass(Thread::Backtrace::Location) # :nodoc:
+      def initialize(loc, ex)
+        super(loc)
+        @ex = ex
+      end
+
+      def spot(_)
+        super(@ex.__getobj__)
+      end
+    end
+
+    def backtrace_locations
+      parse_message_for_trace.map { |trace|
+        file, line = trace.match(/^(.+?):(\d+).*$/, &:captures) || trace
+        BacktraceLocation.new(file, line.to_i, trace)
+        # We have to wrap these backtrace locations because we need the
+        # spot information to come from the originating exception, not the
+        # proxy object that's generating these
+      } + super.map { |loc| BacktraceLocationProxy.new(loc, self) }
+    end
+
+    private
+      def parse_message_for_trace
+        __getobj__.to_s.split("\n")
+      end
+  end
+end

data/lib/active_support/tagged_logging.rb

@@ -6,14 +6,16 @@ require "logger"
 require "active_support/logger"
 
 module ActiveSupport
+  # = Active Support Tagged Logging
+  #
   # Wraps any standard Logger object to provide tagging capabilities.
   #
   # May be called with a block:
   #
   #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-  #   logger.tagged('BCX') { logger.info 'Stuff' }                            # Logs "[BCX] Stuff"
-  #   logger.tagged('BCX', "Jason") { logger.info 'Stuff' }                   # Logs "[BCX] [Jason] Stuff"
-  #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } } # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged('BCX') { logger.info 'Stuff' }                                  # Logs "[BCX] Stuff"
+  #   logger.tagged('BCX', "Jason") { |tagged_logger| tagged_logger.info 'Stuff' }  # Logs "[BCX] [Jason] Stuff"
+  #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } }       # Logs "[BCX] [Jason] Stuff"
   #
   # If called without a block, a new logger will be returned with applied tags:
   #
@@ -29,52 +31,86 @@ module ActiveSupport
     module Formatter # :nodoc:
       # This method is invoked when a log event occurs.
       def call(severity, timestamp, progname, msg)
-        super(severity, timestamp, progname, "#{tags_text}#{msg}")
+        super(severity, timestamp, progname, tag_stack.format_message(msg))
       end
 
       def tagged(*tags)
-        new_tags = push_tags(*tags)
+        pushed_count = tag_stack.push_tags(tags).size
         yield self
       ensure
-        pop_tags(new_tags.size)
+        pop_tags(pushed_count)
       end
 
       def push_tags(*tags)
-        tags.flatten!
-        tags.reject!(&:blank?)
-        current_tags.concat tags
-        tags
+        tag_stack.push_tags(tags)
       end
 
-      def pop_tags(size = 1)
-        current_tags.pop size
+      def pop_tags(count = 1)
+        tag_stack.pop_tags(count)
       end
 
       def clear_tags!
-        current_tags.clear
+        tag_stack.clear
       end
 
-      def current_tags
+      def tag_stack
         # We use our object ID here to avoid conflicting with other instances
-        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
-        IsolatedExecutionState[thread_key] ||= []
+        @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
+        IsolatedExecutionState[@thread_key] ||= TagStack.new
+      end
+
+      def current_tags
+        tag_stack.tags
       end
 
       def tags_text
-        tags = current_tags
-        if tags.one?
-          "[#{tags[0]}] "
-        elsif tags.any?
-          tags.collect { |tag| "[#{tag}] " }.join
+        tag_stack.format_message("")
+      end
+    end
+
+    class TagStack # :nodoc:
+      attr_reader :tags
+
+      def initialize
+        @tags = []
+        @tags_string = nil
+      end
+
+      def push_tags(tags)
+        @tags_string = nil
+        tags.flatten!
+        tags.reject!(&:blank?)
+        @tags.concat(tags)
+        tags
+      end
+
+      def pop_tags(count)
+        @tags_string = nil
+        @tags.pop(count)
+      end
+
+      def clear
+        @tags_string = nil
+        @tags.clear
+      end
+
+      def format_message(message)
+        if @tags.empty?
+          message
+        elsif @tags.size == 1
+          "[#{@tags[0]}] #{message}"
+        else
+          @tags_string ||= "[#{@tags.join("] [")}] "
+          "#{@tags_string}#{message}"
         end
       end
     end
 
     module LocalTagStorage # :nodoc:
-      attr_accessor :current_tags
+      attr_accessor :tag_stack
 
       def self.extended(base)
-        base.current_tags = []
+        base.tag_stack = TagStack.new
       end
     end
 
@@ -82,7 +118,7 @@ module ActiveSupport
       logger = logger.clone
 
       if logger.formatter
-        logger.formatter = logger.formatter.dup
+        logger.formatter = logger.formatter.clone
       else
         # Ensure we set a default formatter so we aren't extending nil!
         logger.formatter = ActiveSupport::Logger::SimpleFormatter.new