activesupport 7.0.6 → 7.1.3.4

data/lib/active_support/i18n_railtie.rb

@@ -49,7 +49,7 @@ module I18n
         when :load_path
           I18n.load_path += value
         when :raise_on_missing_translations
-          forward_raise_on_missing_translations_config(app)
+          setup_raise_on_missing_translations_config(app)
         else
           I18n.public_send("#{setting}=", value)
         end
@@ -60,28 +60,35 @@ module I18n
       # Restore available locales check so it will take place from now on.
       I18n.enforce_available_locales = enforce_available_locales
 
-      directories = watched_dirs_with_extensions(reloadable_paths)
-      reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
-        I18n.load_path.keep_if { |p| File.exist?(p) }
-        I18n.load_path |= reloadable_paths.flat_map(&:existent)
-      end
+      if app.config.reloading_enabled?
+        directories = watched_dirs_with_extensions(reloadable_paths)
+        reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
+          I18n.load_path.keep_if { |p| File.exist?(p) }
+          I18n.load_path |= reloadable_paths.flat_map(&:existent)
+        end
 
-      app.reloaders << reloader
-      app.reloader.to_run do
-        reloader.execute_if_updated { require_unload_lock! }
+        app.reloaders << reloader
+        app.reloader.to_run do
+          reloader.execute_if_updated { require_unload_lock! }
+        end
+        reloader.execute
       end
-      reloader.execute
 
       @i18n_inited = true
     end
 
-    def self.forward_raise_on_missing_translations_config(app)
+    def self.setup_raise_on_missing_translations_config(app)
       ActiveSupport.on_load(:action_view) do
         ActionView::Helpers::TranslationHelper.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
       end
 
-      ActiveSupport.on_load(:action_controller) do
-        AbstractController::Translation.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
+      if app.config.i18n.raise_on_missing_translations &&
+          I18n.exception_handler.is_a?(I18n::ExceptionHandler) # Only override the i18n gem's default exception handler.
+
+        I18n.exception_handler = ->(exception, *) {
+          exception = exception.to_exception if exception.is_a?(I18n::MissingTranslation)
+          raise exception
+        }
       end
     end
 

data/lib/active_support/inflector/inflections.rb

@@ -7,6 +7,8 @@ module ActiveSupport
   module Inflector
     extend self
 
+    # = Active Support \Inflections
+    #
     # A singleton instance of this class is yielded by Inflector.inflections,
     # which can then be used to specify additional inflection rules. If passed
     # an optional locale, rules for other languages can be specified. The

data/lib/active_support/inflector/methods.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
 require "active_support/inflections"
-require "active_support/core_ext/object/blank"
 
 module ActiveSupport
+  # = Active Support \Inflector
+  #
   # The Inflector transforms words from singular to plural, class names to table
   # names, modularized class names to ones without, and class names to foreign
   # keys. The default inflections for pluralization, singularization, and
   # uncountable words are kept in inflections.rb.
   #
-  # The Rails core team has stated patches for the inflections library will not
+  # The \Rails core team has stated patches for the inflections library will not
   # be accepted in order to avoid breaking legacy applications which may be
   # relying on errant inflections. If you discover an incorrect inflection and
   # require it for your application or wish to define rules for languages other
@@ -71,6 +72,8 @@ module ActiveSupport
       # String#camelize takes a symbol (:upper or :lower), so here we also support :lower to keep the methods consistent.
       if !uppercase_first_letter || uppercase_first_letter == :lower
         string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase! || match }
+      elsif string.match?(/\A[a-z\d]*\z/)
+        return inflections.acronyms[string]&.dup || string.capitalize
       else
         string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize! || match }
       end
@@ -94,10 +97,10 @@ module ActiveSupport
     #
     #   camelize(underscore('SSLError'))  # => "SslError"
     def underscore(camel_cased_word)
-      return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
+      return camel_cased_word.to_s.dup unless /[A-Z-]|::/.match?(camel_cased_word)
       word = camel_cased_word.to_s.gsub("::", "/")
       word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
-      word.gsub!(/([A-Z])(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" }
+      word.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, "_")
       word.tr!("-", "_")
       word.downcase!
       word
@@ -136,7 +139,7 @@ module ActiveSupport
 
       result.tr!("_", " ")
       result.lstrip!
-      if !keep_id_suffix && lower_case_and_underscored_word.end_with?("_id")
+      if !keep_id_suffix && lower_case_and_underscored_word&.end_with?("_id")
         result.delete_suffix!(" id")
       end
 
@@ -155,18 +158,27 @@ module ActiveSupport
       result
     end
 
-    # Converts just the first character to uppercase.
+    # Converts the first character in the string to uppercase.
     #
     #   upcase_first('what a Lovely Day') # => "What a Lovely Day"
     #   upcase_first('w')                 # => "W"
     #   upcase_first('')                  # => ""
     def upcase_first(string)
-      string.length > 0 ? string[0].upcase.concat(string[1..-1]) : ""
+      string.length > 0 ? string[0].upcase.concat(string[1..-1]) : +""
+    end
+
+    # Converts the first character in the string to lowercase.
+    #
+    #   downcase_first('If they enjoyed The Matrix') # => "if they enjoyed The Matrix"
+    #   downcase_first('I')                          # => "i"
+    #   downcase_first('')                           # => ""
+    def downcase_first(string)
+      string.length > 0 ? string[0].downcase.concat(string[1..-1]) : +""
     end
 
     # Capitalizes all the words and replaces some characters in the string to
     # create a nicer looking title. +titleize+ is meant for creating pretty
-    # output. It is not used in the Rails internals.
+    # output. It is not used in the \Rails internals.
     #
     # The trailing '_id','Id'.. can be kept and capitalized by setting the
     # optional parameter +keep_id_suffix+ to true.
@@ -183,7 +195,7 @@ module ActiveSupport
       end
     end
 
-    # Creates the name of a table like Rails does for models to table names.
+    # Creates the name of a table like \Rails does for models to table names.
     # This method uses the #pluralize method on the last word in the string.
     #
     #   tableize('RawScaledScorer') # => "raw_scaled_scorers"
@@ -193,7 +205,7 @@ module ActiveSupport
       pluralize(underscore(class_name))
     end
 
-    # Creates a class name from a plural table name like Rails does for table
+    # Creates a class name from a plural table name like \Rails does for table
     # names to models. Note that this returns a string and not a Class. (To
     # convert to an actual class follow +classify+ with #constantize.)
     #
@@ -226,7 +238,7 @@ module ActiveSupport
     def demodulize(path)
       path = path.to_s
       if i = path.rindex("::")
-        path[(i + 2)..-1]
+        path[(i + 2), path.length]
       else
         path
       end
@@ -345,7 +357,7 @@ module ActiveSupport
       def const_regexp(camel_cased_word)
         parts = camel_cased_word.split("::")
 
-        return Regexp.escape(camel_cased_word) if parts.blank?
+        return Regexp.escape(camel_cased_word) if parts.empty?
 
         last = parts.pop
 

data/lib/active_support/inflector/transliterate.rb

@@ -62,10 +62,12 @@ module ActiveSupport
     # Transliteration is restricted to UTF-8, US-ASCII, and GB18030 strings.
     # Other encodings will raise an ArgumentError.
     def transliterate(string, replacement = "?", locale: nil)
-      string = string.dup if string.frozen?
       raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
       raise ArgumentError, "Cannot transliterate strings with #{string.encoding} encoding" unless ALLOWED_ENCODINGS_FOR_TRANSLITERATE.include?(string.encoding)
 
+      return string.dup if string.ascii_only?
+      string = string.dup if string.frozen?
+
       input_encoding = string.encoding
 
       # US-ASCII is a subset of UTF-8 so we'll force encoding as UTF-8 if

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 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"