activesupport 7.0.8.6 → 7.1.0.beta1

data/lib/active_support/isolated_execution_state.rb

@@ -4,25 +4,30 @@ require "fiber"
 
 module ActiveSupport
   module IsolatedExecutionState # :nodoc:
-    @isolation_level = :thread
+    @isolation_level = nil
 
     Thread.attr_accessor :active_support_execution_state
     Fiber.attr_accessor :active_support_execution_state
 
     class << self
-      attr_reader :isolation_level
+      attr_reader :isolation_level, :scope
 
       def isolation_level=(level)
+        return if level == @isolation_level
+
         unless %i(thread fiber).include?(level)
           raise ArgumentError, "isolation_level must be `:thread` or `:fiber`, got: `#{level.inspect}`"
         end
 
-        if level != isolation_level
-          clear
-          singleton_class.alias_method(:current, "current_#{level}")
-          singleton_class.send(:private, :current)
-          @isolation_level = level
-        end
+        clear if @isolation_level
+
+        @scope =
+          case level
+          when :thread; Thread
+          when :fiber; Fiber
+          end
+
+        @isolation_level = level
       end
 
       def unique_id
@@ -30,43 +35,42 @@ module ActiveSupport
       end
 
       def [](key)
-        current[key]
+        state[key]
       end
 
       def []=(key, value)
-        current[key] = value
+        state[key] = value
       end
 
       def key?(key)
-        current.key?(key)
+        state.key?(key)
       end
 
       def delete(key)
-        current.delete(key)
+        state.delete(key)
       end
 
       def clear
-        current.clear
+        state.clear
+      end
+
+      def context
+        scope.current
       end
 
       def share_with(other)
         # Action Controller streaming spawns a new thread and copy thread locals.
         # We do the same here for backward compatibility, but this is very much a hack
         # and streaming should be rethought.
-        context = @isolation_level == :thread ? Thread.current : Fiber.current
         context.active_support_execution_state = other.active_support_execution_state.dup
       end
 
       private
-        def current_thread
-          Thread.current.active_support_execution_state ||= {}
-        end
-
-        def current_fiber
-          Fiber.current.active_support_execution_state ||= {}
+        def state
+          context.active_support_execution_state ||= {}
         end
-
-        alias_method :current, :current_thread
     end
+
+    self.isolation_level = :thread
   end
 end

data/lib/active_support/json/decoding.rb

@@ -5,7 +5,7 @@ require "active_support/core_ext/module/delegation"
 require "json"
 
 module ActiveSupport
-  # Look for and parse json strings that look like ISO 8601 times.
+  # Look for and parse JSON strings that look like ISO 8601 times.
   mattr_accessor :parse_json_times
 
   module JSON
@@ -28,6 +28,7 @@ module ActiveSupport
           data
         end
       end
+      alias_method :load, :decode
 
       # Returns the class of the error that will be raised when there is an
       # error in decoding JSON. Using this method means you won't directly

data/lib/active_support/json/encoding.rb

@@ -18,8 +18,11 @@ module ActiveSupport
     #
     #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
     #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
-    def self.encode(value, options = nil)
-      Encoding.json_encoder.new(options).encode(value)
+    class << self
+      def encode(value, options = nil)
+        Encoding.json_encoder.new(options).encode(value)
+      end
+      alias_method :dump, :encode
     end
 
     module Encoding # :nodoc:
@@ -32,49 +35,27 @@ module ActiveSupport
 
         # Encode the given object into a JSON string
         def encode(value)
-          stringify jsonify value.as_json(options.dup)
-        end
+          unless options.empty?
+            value = value.as_json(options.dup)
+          end
+          json = stringify(jsonify(value))
 
-        private
           # Rails does more escaping than the JSON gem natively does (we
           # escape \u2028 and \u2029 and optionally >, <, & to work around
           # certain browser problems).
-          ESCAPED_CHARS = {
-            "\u2028" => '\u2028',
-            "\u2029" => '\u2029',
-            ">"      => '\u003e',
-            "<"      => '\u003c',
-            "&"      => '\u0026',
-            }
-
-          ESCAPE_REGEX_WITH_HTML_ENTITIES = /[\u2028\u2029><&]/u
-          ESCAPE_REGEX_WITHOUT_HTML_ENTITIES = /[\u2028\u2029]/u
-
-          # This class wraps all the strings we see and does the extra escaping
-          class EscapedString < String # :nodoc:
-            def to_json(*)
-              if Encoding.escape_html_entities_in_json
-                s = super
-                s.gsub! ESCAPE_REGEX_WITH_HTML_ENTITIES, ESCAPED_CHARS
-                s
-              else
-                s = super
-                s.gsub! ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, ESCAPED_CHARS
-                s
-              end
-            end
-
-            def to_s
-              self
-            end
+          if Encoding.escape_html_entities_in_json
+            json.gsub!(">", '\u003e')
+            json.gsub!("<", '\u003c')
+            json.gsub!("&", '\u0026')
           end
+          json.gsub!("\u2028", '\u2028')
+          json.gsub!("\u2029", '\u2029')
+          json
+        end
 
-          # Mark these as private so we don't leak encoding-specific constructs
-          private_constant :ESCAPED_CHARS, :ESCAPE_REGEX_WITH_HTML_ENTITIES,
-            :ESCAPE_REGEX_WITHOUT_HTML_ENTITIES, :EscapedString
-
+        private
           # Convert an object into a "JSON-ready" representation composed of
-          # primitives like Hash, Array, String, Numeric,
+          # primitives like Hash, Array, String, Symbol, Numeric,
           # and +true+/+false+/+nil+.
           # Recursively calls #as_json to the object to recursively build a
           # fully JSON-ready object.
@@ -88,14 +69,15 @@ module ActiveSupport
           # calls.
           def jsonify(value)
             case value
-            when String
-              EscapedString.new(value)
-            when Numeric, NilClass, TrueClass, FalseClass
+            when String, Integer, Symbol, nil, true, false
+              value
+            when Numeric
               value.as_json
             when Hash
               result = {}
               value.each do |k, v|
-                result[jsonify(k)] = jsonify(v)
+                k = k.to_s unless Symbol === k || String === k
+                result[k] = jsonify(v)
               end
               result
             when Array
@@ -124,7 +106,7 @@ module ActiveSupport
         # Defaults to 3 (equivalent to millisecond precision)
         attr_accessor :time_precision
 
-        # Sets the encoder used by Rails to encode Ruby objects into JSON strings
+        # Sets the encoder used by \Rails to encode Ruby objects into JSON strings
         # in +Object#to_json+ and +ActiveSupport::JSON.encode+.
         attr_accessor :json_encoder
       end

data/lib/active_support/key_generator.rb

@@ -4,9 +4,11 @@ require "concurrent/map"
 require "openssl"
 
 module ActiveSupport
+  # = Key Generator
+  #
   # KeyGenerator is a simple wrapper around OpenSSL's implementation of PBKDF2.
   # It can be used to derive a number of keys for various purposes from a given secret.
-  # This lets Rails applications have a single secure secret, but avoid reusing that
+  # This lets \Rails applications have a single secure secret, but avoid reusing that
   # key in multiple incompatible contexts.
   class KeyGenerator
     class << self
@@ -39,8 +41,14 @@ module ActiveSupport
     def generate_key(salt, key_size = 64)
       OpenSSL::PKCS5.pbkdf2_hmac(@secret, salt, @iterations, key_size, @hash_digest_class.new)
     end
+
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+    end
   end
 
+  # = Caching Key Generator
+  #
   # CachingKeyGenerator is a wrapper around KeyGenerator which allows users to avoid
   # re-executing the key generation process when it's called using the same +salt+ and
   # +key_size+.

data/lib/active_support/lazy_load_hooks.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 module ActiveSupport
-  # LazyLoadHooks allows Rails to lazily load a lot of components and thus
+  # = Lazy Load Hooks
+  #
+  # LazyLoadHooks allows \Rails to lazily load a lot of components and thus
   # making the app boot faster. Because of this feature now there is no need to
-  # require <tt>ActiveRecord::Base</tt> at boot time purely to apply
+  # require +ActiveRecord::Base+ at boot time purely to apply
   # configuration. Instead a hook is registered that applies configuration once
-  # <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> is
+  # +ActiveRecord::Base+ is loaded. Here +ActiveRecord::Base+ is
   # used as example but this feature can be applied elsewhere too.
   #
   # Here is an example where on_load method is called to register a hook.
@@ -47,7 +49,7 @@ module ActiveSupport
       end
     end
 
-    # Declares a block that will be executed when a Rails component is fully
+    # Declares a block that will be executed when a \Rails component is fully
     # loaded. If the component has already loaded, the block is executed
     # immediately.
     #

data/lib/active_support/locale/en.yml

@@ -57,6 +57,7 @@ en:
       format:
         # Where is the currency sign? %u is the currency unit, %n is the number (default: $5.00)
         format: "%u%n"
+        negative_format: "-%u%n"
         unit: "$"
         # These six are to override number.format and are optional
         separator: "."
@@ -112,6 +113,7 @@ en:
           tb: "TB"
           pb: "PB"
           eb: "EB"
+          zb: "ZB"
       # Used in NumberHelper.number_to_human()
       decimal_units:
         format: "%n %u"

data/lib/active_support/log_subscriber.rb

@@ -3,9 +3,12 @@
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/class/attribute"
 require "active_support/subscriber"
+require "active_support/deprecation/proxy_wrappers"
 
 module ActiveSupport
-  # <tt>ActiveSupport::LogSubscriber</tt> is an object set to consume
+  # = Active Support Log \Subscriber
+  #
+  # +ActiveSupport::LogSubscriber+ is an object set to consume
   # ActiveSupport::Notifications with the sole purpose of logging them.
   # The log subscriber dispatches notifications to a registered object based
   # on its given namespace.
@@ -15,29 +18,23 @@ module ActiveSupport
   #
   #   module ActiveRecord
   #     class LogSubscriber < ActiveSupport::LogSubscriber
+  #       attach_to :active_record
+  #
   #       def sql(event)
   #         info "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
   #       end
   #     end
   #   end
   #
-  # And it's finally registered as:
-  #
-  #   ActiveRecord::LogSubscriber.attach_to :active_record
+  # ActiveRecord::LogSubscriber.logger must be set as well, but it is assigned
+  # automatically in a \Rails environment.
   #
-  # Since we need to know all instance methods before attaching the log
-  # subscriber, the line above should be called after your
-  # <tt>ActiveRecord::LogSubscriber</tt> definition.
-  #
-  # A logger also needs to be set with <tt>ActiveRecord::LogSubscriber.logger=</tt>.
-  # This is assigned automatically in a Rails environment.
-  #
-  # After configured, whenever a <tt>"sql.active_record"</tt> notification is published,
-  # it will properly dispatch the event
-  # (<tt>ActiveSupport::Notifications::Event</tt>) 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.
   #
   # Being an ActiveSupport::Notifications consumer,
-  # <tt>ActiveSupport::LogSubscriber</tt> exposes a simple interface to check if
+  # +ActiveSupport::LogSubscriber+ exposes a simple interface to check if
   # instrumented code raises an exception. It is common to log a different
   # message in case of an error, and this can be achieved by extending
   # the previous example:
@@ -59,15 +56,24 @@ module ActiveSupport
   #     end
   #   end
   #
-  # Log subscriber also has some helpers to deal with logging and automatically
-  # flushes all logs when the request finishes
-  # (via <tt>action_dispatch.callback</tt> notification) in a Rails environment.
+  # +ActiveSupport::LogSubscriber+ also has some helpers to deal with
+  # logging. For example, ActiveSupport::LogSubscriber.flush_all! will ensure
+  # 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   = "\e[0m"
-    BOLD    = "\e[1m"
-
-    # Colors
+    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,
+      bold:      1,
+      italic:    3,
+      underline: 4,
+    }
+
+    # ANSI sequence colors
     BLACK   = "\e[30m"
     RED     = "\e[31m"
     GREEN   = "\e[32m"
@@ -78,6 +84,7 @@ module ActiveSupport
     WHITE   = "\e[37m"
 
     mattr_accessor :colorize_logging, default: true
+    class_attribute :log_levels, instance_accessor: false, default: {} # :nodoc:
 
     class << self
       def logger
@@ -86,6 +93,12 @@ module ActiveSupport
         end
       end
 
+      def attach_to(...) # :nodoc:
+        result = super
+        set_event_levels
+        result
+      end
+
       attr_writer :logger
 
       def log_subscribers
@@ -101,20 +114,36 @@ module ActiveSupport
         def fetch_public_methods(subscriber, inherit_all)
           subscriber.public_methods(inherit_all) - LogSubscriber.public_instance_methods(true)
         end
+
+        def set_event_levels
+          if subscriber
+            subscriber.event_levels = log_levels.transform_keys { |k| "#{k}.#{namespace}" }
+          end
+        end
+
+        def subscribe_log_level(method, level)
+          self.log_levels = log_levels.merge(method => ::Logger.const_get(level.upcase))
+          set_event_levels
+        end
+    end
+
+    def initialize
+      super
+      @event_levels = {}
     end
 
     def logger
       LogSubscriber.logger
     end
 
-    def start(name, id, payload)
-      super if logger
+    def silenced?(event)
+      logger.nil? || logger.level > @event_levels.fetch(event, Float::INFINITY)
     end
 
-    def finish(name, id, payload)
+    def call(event)
       super if logger
     rescue => e
-      log_exception(name, e)
+      log_exception(event.name, e)
     end
 
     def publish_event(event)
@@ -123,6 +152,8 @@ module ActiveSupport
       log_exception(event.name, e)
     end
 
+    attr_writer :event_levels # :nodoc:
+
   private
     %w(info debug warn error fatal unknown).each do |level|
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
@@ -132,15 +163,29 @@ module ActiveSupport
       METHOD
     end
 
-    # Set color by using a symbol or one of the defined constants. If a third
-    # option is set to +true+, it also adds bold to the string. This is based
-    # on the Highline implementation and will automatically append CLEAR to the
-    # end of the returned String.
-    def color(text, color, bold = false) # :doc:
+    # Set color by using a symbol or one of the defined constants. Set modes
+    # by specifying bold, italic, or underline options. Inspired by Highline,
+    # this method will automatically clear formatting at the end of the returned String.
+    def color(text, color, mode_options = {}) # :doc:
       return text unless colorize_logging
       color = self.class.const_get(color.upcase) if color.is_a?(Symbol)
-      bold  = bold ? BOLD : ""
-      "#{bold}#{color}#{text}#{CLEAR}"
+      mode = mode_from(mode_options)
+      clear = "\e[#{MODES[:clear]}m"
+      "#{mode}#{color}#{text}#{clear}"
+    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?
     end
 
     def log_exception(name, e)

data/lib/active_support/logger.rb

@@ -79,7 +79,7 @@ module ActiveSupport
 
     def initialize(*args, **kwargs)
       super
-      @formatter = SimpleFormatter.new
+      @formatter ||= SimpleFormatter.new
     end
 
     # Simple formatter which only displays the message.

data/lib/active_support/logger_thread_safe_level.rb

@@ -18,7 +18,7 @@ module ActiveSupport
     end
 
     def local_level
-      IsolatedExecutionState[:logger_thread_safe_level]
+      IsolatedExecutionState[local_level_key]
     end
 
     def local_level=(level)
@@ -30,7 +30,11 @@ module ActiveSupport
       else
         raise ArgumentError, "Invalid log level: #{level.inspect}"
       end
-      IsolatedExecutionState[:logger_thread_safe_level] = level
+      if level.nil?
+        IsolatedExecutionState.delete(local_level_key)
+      else
+        IsolatedExecutionState[local_level_key] = level
+      end
     end
 
     def level
@@ -45,25 +49,9 @@ module ActiveSupport
       self.local_level = old_local_level
     end
 
-    # Redefined to check severity against #level, and thus the thread-local level, rather than +@level+.
-    # FIXME: Remove when the minimum Ruby version supports overriding Logger#level.
-    def add(severity, message = nil, progname = nil, &block) # :nodoc:
-      severity ||= UNKNOWN
-      progname ||= @progname
-
-      return true if @logdev.nil? || severity < level
-
-      if message.nil?
-        if block_given?
-          message  = yield
-        else
-          message  = progname
-          progname = @progname
-        end
+    private
+      def local_level_key
+        @local_level_key ||= :"logger_thread_safe_level_#{object_id}"
       end
-
-      @logdev.write \
-        format_message(format_severity(severity), Time.now, progname, message)
-    end
   end
 end