activesupport 6.1.0 → 7.0.4.1

data/lib/active_support/executor/test_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport::Executor::TestHelper # :nodoc:
+  def run(...)
+    Rails.application.executor.perform { super }
+  end
+end

data/lib/active_support/fork_tracker.rb

@@ -2,8 +2,18 @@
 
 module ActiveSupport
   module ForkTracker # :nodoc:
+    module ModernCoreExt
+      def _fork
+        pid = super
+        if pid == 0
+          ForkTracker.check!
+        end
+        pid
+      end
+    end
+
     module CoreExt
-      def fork(*)
+      def fork(...)
         if block_given?
           super do
             ForkTracker.check!
@@ -20,11 +30,7 @@ module ActiveSupport
 
     module CoreExtPrivate
       include CoreExt
-
-      private
-        def fork(*)
-          super
-        end
+      private :fork
     end
 
     @pid = Process.pid
@@ -32,15 +38,18 @@ module ActiveSupport
 
     class << self
       def check!
-        if @pid != Process.pid
+        new_pid = Process.pid
+        if @pid != new_pid
           @callbacks.each(&:call)
-          @pid = Process.pid
+          @pid = new_pid
         end
       end
 
       def hook!
-        if Process.respond_to?(:fork)
-          ::Object.prepend(CoreExtPrivate)
+        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)

data/lib/active_support/gem_version.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module ActiveSupport
-  # Returns the version of the currently loaded Active Support as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Active Support as a <tt>Gem::Version</tt>.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 6
-    MINOR = 1
-    TINY  = 0
-    PRE   = nil
+    MAJOR = 7
+    MINOR = 0
+    TINY  = 4
+    PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/hash_with_indifferent_access.rb

@@ -3,6 +3,7 @@
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/hash/reverse_merge"
 require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/slice"
 
 module ActiveSupport
   # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
@@ -64,7 +65,7 @@ module ActiveSupport
       self
     end
 
-    def initialize(constructor = {})
+    def initialize(constructor = nil)
       if constructor.respond_to?(:to_hash)
         super()
         update(constructor)
@@ -72,6 +73,8 @@ module ActiveSupport
         hash = constructor.is_a?(Hash) ? constructor : constructor.to_hash
         self.default = hash.default if hash.default
         self.default_proc = hash.default_proc if hash.default_proc
+      elsif constructor.nil?
+        super()
       else
         super(constructor)
       end
@@ -113,7 +116,7 @@ module ActiveSupport
     # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
     # In either case the merge respects the semantics of indifferent access.
     #
-    # If the argument is a regular hash with keys +:key+ and +"key"+ only one
+    # If the argument is a regular hash with keys +:key+ and <tt>"key"</tt> only one
     # of the values end up in the receiver, but which one is unspecified.
     #
     # When given a block, the value for duplicated keys will be determined
@@ -293,6 +296,10 @@ module ActiveSupport
       super(convert_key(key))
     end
 
+    # Returns a hash with indifferent access that includes everything except given keys.
+    #   hash = { a: "x", b: "y", c: 10 }.with_indifferent_access
+    #   hash.except(:a, "b") # => {c: 10}.with_indifferent_access
+    #   hash                 # => { a: "x", b: "y", c: 10 }.with_indifferent_access
     def except(*keys)
       slice(*self.keys - keys.map { |key| convert_key(key) })
     end

data/lib/active_support/html_safe_translation.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module HtmlSafeTranslation # :nodoc:
+    extend self
+
+    def translate(key, **options)
+      if html_safe_translation_key?(key)
+        html_safe_options = html_escape_translation_options(options)
+        translation = I18n.translate(key, **html_safe_options)
+        html_safe_translation(translation)
+      else
+        I18n.translate(key, **options)
+      end
+    end
+
+    private
+      def html_safe_translation_key?(key)
+        /(?:_|\b)html\z/.match?(key)
+      end
+
+      def html_escape_translation_options(options)
+        options.each do |name, value|
+          unless i18n_option?(name) || (name == :count && value.is_a?(Numeric))
+            options[name] = ERB::Util.html_escape(value.to_s)
+          end
+        end
+      end
+
+      def i18n_option?(name)
+        (@i18n_option_names ||= I18n::RESERVED_KEYS.to_set).include?(name)
+      end
+
+
+      def html_safe_translation(translation)
+        if translation.respond_to?(:map)
+          translation.map { |element| element.respond_to?(:html_safe) ? element.html_safe : element }
+        else
+          translation.respond_to?(:html_safe) ? translation.html_safe : translation
+        end
+      end
+  end
+end

data/lib/active_support/i18n.rb

@@ -5,6 +5,7 @@ require "active_support/core_ext/hash/except"
 require "active_support/core_ext/hash/slice"
 begin
   require "i18n"
+  require "i18n/backend/fallbacks"
 rescue LoadError => e
   $stderr.puts "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
   raise e

data/lib/active_support/i18n_railtie.rb

@@ -77,7 +77,7 @@ module I18n
 
     def self.forward_raise_on_missing_translations_config(app)
       ActiveSupport.on_load(:action_view) do
-        self.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
+        ActionView::Helpers::TranslationHelper.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
       end
 
       ActiveSupport.on_load(:action_controller) do

data/lib/active_support/inflector/inflections.rb

@@ -16,13 +16,13 @@ module ActiveSupport
     #     inflect.plural /^(ox)$/i, '\1\2en'
     #     inflect.singular /^(ox)en/i, '\1'
     #
-    #     inflect.irregular 'octopus', 'octopi'
+    #     inflect.irregular 'cactus', 'cacti'
     #
     #     inflect.uncountable 'equipment'
     #   end
     #
     # New rules are added at the top. So in the example above, the irregular
-    # rule for octopus will now be the first of the pluralization and
+    # rule for cactus will now be the first of the pluralization and
     # singularization rules that is runs. This guarantees that your rules run
     # before any of the rules that may already have been loaded.
     class Inflections
@@ -64,6 +64,13 @@ module ActiveSupport
         @__instance__[locale] ||= new
       end
 
+      def self.instance_or_fallback(locale)
+        I18n.fallbacks[locale].each do |k|
+          return @__instance__[k] if @__instance__.key?(k)
+        end
+        instance(locale)
+      end
+
       attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms
 
       attr_reader :acronyms_camelize_regex, :acronyms_underscore_regex # :nodoc:
@@ -160,7 +167,7 @@ module ActiveSupport
       # regular expressions. You simply pass the irregular in singular and
       # plural form.
       #
-      #   irregular 'octopus', 'octopi'
+      #   irregular 'cactus', 'cacti'
       #   irregular 'person', 'people'
       def irregular(singular, plural)
         @uncountables.delete(singular)
@@ -215,15 +222,24 @@ module ActiveSupport
       # Clears the loaded inflections within a given scope (default is
       # <tt>:all</tt>). Give the scope as a symbol of the inflection type, the
       # options are: <tt>:plurals</tt>, <tt>:singulars</tt>, <tt>:uncountables</tt>,
-      # <tt>:humans</tt>.
+      # <tt>:humans</tt>, <tt>:acronyms</tt>.
       #
       #   clear :all
       #   clear :plurals
       def clear(scope = :all)
         case scope
         when :all
-          @plurals, @singulars, @uncountables, @humans = [], [], Uncountables.new, []
-        else
+          clear(:acronyms)
+          clear(:plurals)
+          clear(:singulars)
+          clear(:uncountables)
+          clear(:humans)
+        when :acronyms
+          @acronyms = {}
+          define_acronym_regex_patterns
+        when :uncountables
+          @uncountables = Uncountables.new
+        when :plurals, :singulars, :humans
           instance_variable_set "@#{scope}", []
         end
       end
@@ -248,7 +264,7 @@ module ActiveSupport
       if block_given?
         yield Inflections.instance(locale)
       else
-        Inflections.instance(locale)
+        Inflections.instance_or_fallback(locale)
       end
     end
   end

data/lib/active_support/inflector/methods.rb

@@ -68,13 +68,17 @@ module ActiveSupport
     #   camelize(underscore('SSLError'))        # => "SslError"
     def camelize(term, uppercase_first_letter = true)
       string = term.to_s
-      if uppercase_first_letter
-        string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize }
+      # 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 }
       else
-        string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase }
+        string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize! || match }
+      end
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
+        word = $2
+        substituted = inflections.acronyms[word] || word.capitalize! || word
+        $1 ? "::#{substituted}" : substituted
       end
-      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
-      string.gsub!("/", "::")
       string
     end
 
@@ -90,11 +94,10 @@ module ActiveSupport
     #
     #   camelize(underscore('SSLError'))  # => "SslError"
     def underscore(camel_cased_word)
-      return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
+      return camel_cased_word.to_s 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\d]+)([A-Z][a-z])/, '\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.gsub!(/([A-Z])(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" }
       word.tr!("-", "_")
       word.downcase!
       word
@@ -106,7 +109,7 @@ module ActiveSupport
     #
     # * Applies human inflection rules to the argument.
     # * Deletes leading underscores, if any.
-    # * Removes a "_id" suffix if present.
+    # * Removes an "_id" suffix if present.
     # * Replaces underscores with spaces, if any.
     # * Downcases all words except acronyms.
     # * Capitalizes the first word.
@@ -120,7 +123,7 @@ module ActiveSupport
     #   humanize('author_id')                        # => "Author"
     #   humanize('author_id', capitalize: false)     # => "author"
     #   humanize('_id')                              # => "Id"
-    #   humanize('author_id', keep_id_suffix: true)  # => "Author Id"
+    #   humanize('author_id', keep_id_suffix: true)  # => "Author id"
     #
     # If "SSL" was defined to be an acronym:
     #
@@ -131,18 +134,22 @@ module ActiveSupport
 
       inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
 
-      result.sub!(/\A_+/, "")
+      result.tr!("_", " ")
+      result.lstrip!
       unless keep_id_suffix
-        result.delete_suffix!("_id")
+        result.delete_suffix!(" id")
       end
-      result.tr!("_", " ")
 
-      result.gsub!(/([a-z\d]*)/i) do |match|
-        "#{inflections.acronyms[match.downcase] || match.downcase}"
+      result.gsub!(/([a-z\d]+)/i) do |match|
+        match.downcase!
+        inflections.acronyms[match] || match
       end
 
       if capitalize
-        result.sub!(/\A\w/) { |match| match.upcase }
+        result.sub!(/\A\w/) do |match|
+          match.upcase!
+          match
+        end
       end
 
       result
@@ -270,38 +277,7 @@ module ActiveSupport
     # NameError is raised when the name is not in CamelCase or the constant is
     # unknown.
     def constantize(camel_cased_word)
-      if camel_cased_word.blank? || !camel_cased_word.include?("::")
-        Object.const_get(camel_cased_word)
-      else
-        names = camel_cased_word.split("::")
-
-        # Trigger a built-in NameError exception including the ill-formed constant in the message.
-        Object.const_get(camel_cased_word) if names.empty?
-
-        # Remove the first blank element in case of '::ClassName' notation.
-        names.shift if names.size > 1 && names.first.empty?
-
-        names.inject(Object) do |constant, name|
-          if constant == Object
-            constant.const_get(name)
-          else
-            candidate = constant.const_get(name)
-            next candidate if constant.const_defined?(name, false)
-            next candidate unless Object.const_defined?(name)
-
-            # Go down the ancestors to check if it is owned directly. The check
-            # stops when we reach Object or the end of ancestors tree.
-            constant = constant.ancestors.inject(constant) do |const, ancestor|
-              break const    if ancestor == Object
-              break ancestor if ancestor.const_defined?(name, false)
-              const
-            end
-
-            # owner is in Object, so raise
-            constant.const_get(name, false)
-          end
-        end
-      end
+      Object.const_get(camel_cased_word)
     end
 
     # Tries to find a constant with the name specified in the argument string.

data/lib/active_support/inflector/transliterate.rb

@@ -59,7 +59,7 @@ module ActiveSupport
     #   transliterate('Jürgen', locale: :de)
     #   # => "Juergen"
     #
-    # Transliteration is restricted to UTF-8, US-ASCII and GB18030 strings
+    # 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?

data/lib/active_support/isolated_execution_state.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "fiber"
+
+module ActiveSupport
+  module IsolatedExecutionState # :nodoc:
+    @isolation_level = :thread
+
+    Thread.attr_accessor :active_support_execution_state
+    Fiber.attr_accessor :active_support_execution_state
+
+    class << self
+      attr_reader :isolation_level
+
+      def isolation_level=(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
+      end
+
+      def unique_id
+        self[:__id__] ||= Object.new
+      end
+
+      def [](key)
+        current[key]
+      end
+
+      def []=(key, value)
+        current[key] = value
+      end
+
+      def key?(key)
+        current.key?(key)
+      end
+
+      def delete(key)
+        current.delete(key)
+      end
+
+      def clear
+        current.clear
+      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 ||= {}
+        end
+
+        alias_method :current, :current_thread
+    end
+  end
+end

data/lib/active_support/json/encoding.rb

@@ -22,8 +22,8 @@ module ActiveSupport
       Encoding.json_encoder.new(options).encode(value)
     end
 
-    module Encoding #:nodoc:
-      class JSONGemEncoder #:nodoc:
+    module Encoding # :nodoc:
+      class JSONGemEncoder # :nodoc:
         attr_reader :options
 
         def initialize(options = nil)
@@ -51,7 +51,7 @@ module ActiveSupport
           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:
+          class EscapedString < String # :nodoc:
             def to_json(*)
               if Encoding.escape_html_entities_in_json
                 s = super

data/lib/active_support/key_generator.rb

@@ -9,24 +9,41 @@ module ActiveSupport
   # This lets Rails applications have a single secure secret, but avoid reusing that
   # key in multiple incompatible contexts.
   class KeyGenerator
+    class << self
+      def hash_digest_class=(klass)
+        if klass.kind_of?(Class) && klass < OpenSSL::Digest
+          @hash_digest_class = klass
+        else
+          raise ArgumentError, "#{klass} is expected to be an OpenSSL::Digest subclass"
+        end
+      end
+
+      def hash_digest_class
+        @hash_digest_class ||= OpenSSL::Digest::SHA1
+      end
+    end
+
     def initialize(secret, options = {})
       @secret = secret
       # The default iterations are higher than required for our key derivation uses
       # on the off chance someone uses this for password storage
       @iterations = options[:iterations] || 2**16
+      # Also allow configuration here so people can use this to build a rotation
+      # scheme when switching the digest class.
+      @hash_digest_class = options[:hash_digest_class] || self.class.hash_digest_class
     end
 
-    # Returns a derived key suitable for use.  The default key_size is chosen
+    # Returns a derived key suitable for use.  The default +key_size+ is chosen
     # to be compatible with the default settings of ActiveSupport::MessageVerifier.
-    # i.e. OpenSSL::Digest::SHA1#block_length
+    # i.e. <tt>OpenSSL::Digest::SHA1#block_length</tt>
     def generate_key(salt, key_size = 64)
-      OpenSSL::PKCS5.pbkdf2_hmac_sha1(@secret, salt, @iterations, key_size)
+      OpenSSL::PKCS5.pbkdf2_hmac(@secret, salt, @iterations, key_size, @hash_digest_class.new)
     end
   end
 
   # 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.
+  # re-executing the key generation process when it's called using the same +salt+ and
+  # +key_size+.
   class CachingKeyGenerator
     def initialize(key_generator)
       @key_generator = key_generator

data/lib/active_support/lazy_load_hooks.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module ActiveSupport
-  # lazy_load_hooks allows Rails to lazily load a lot of components and thus
+  # 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
   # configuration. Instead a hook is registered that applies configuration once
   # <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> 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.
+  # Here is an example where on_load method is called to register a hook.
   #
   #   initializer 'active_record.initialize_timezone' do
   #     ActiveSupport.on_load(:active_record) do
@@ -18,10 +18,26 @@ module ActiveSupport
   #   end
   #
   # When the entirety of +ActiveRecord::Base+ has been
-  # evaluated then +run_load_hooks+ is invoked. The very last line of
+  # evaluated then run_load_hooks is invoked. The very last line of
   # +ActiveRecord::Base+ is:
   #
   #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
+  #
+  # run_load_hooks will then execute all the hooks that were registered
+  # with the on_load method. In the case of the above example, it will
+  # execute the block of code that is in the +initializer+.
+  #
+  # Registering a hook that has already run results in that hook executing
+  # immediately. This allows hooks to be nested for code that relies on
+  # multiple lazily loaded components:
+  #
+  #   initializer "action_text.renderer" do
+  #     ActiveSupport.on_load(:action_controller_base) do
+  #       ActiveSupport.on_load(:action_text_content) do
+  #         self.default_renderer = Class.new(ActionController::Base).renderer
+  #       end
+  #     end
+  #   end
   module LazyLoadHooks
     def self.extended(base) # :nodoc:
       base.class_eval do
@@ -32,7 +48,8 @@ module ActiveSupport
     end
 
     # Declares a block that will be executed when a Rails component is fully
-    # loaded.
+    # loaded. If the component has already loaded, the block is executed
+    # immediately.
     #
     # Options:
     #
@@ -46,6 +63,13 @@ module ActiveSupport
       @load_hooks[name] << [block, options]
     end
 
+    # Executes all blocks registered to +name+ via on_load, using +base+ as the
+    # evaluation context.
+    #
+    #  ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
+    #
+    # In the case of the above example, it will execute all hooks registered
+    # for +:active_record+ within the class +ActiveRecord::Base+.
     def run_load_hooks(name, base = Object)
       @loaded[name] << base
       @load_hooks[name].each do |hook, options|

data/lib/active_support/locale/en.yml

@@ -45,7 +45,7 @@ en:
       # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
       precision: 3
       # Determine how rounding is performed (see BigDecimal::mode)
-      round_mode: !ruby/sym default
+      round_mode: default
       # If set to true, precision will mean the number of significant digits instead
       # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
       significant: false
@@ -55,7 +55,7 @@ en:
     # Used in NumberHelper.number_to_currency()
     currency:
       format:
-        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
+        # Where is the currency sign? %u is the currency unit, %n is the number (default: $5.00)
         format: "%u%n"
         unit: "$"
         # These six are to override number.format and are optional

data/lib/active_support/log_subscriber/test_helper.rb

@@ -27,13 +27,13 @@ module ActiveSupport
     #
     # All you need to do is to ensure that your log subscriber is added to
     # Rails::Subscriber, as in the second line of the code above. The test
-    # helpers are responsible for setting up the queue, subscriptions and
+    # helpers are responsible for setting up the queue and subscriptions, and
     # turning colors in logs off.
     #
     # The messages are available in the @logger instance, which is a logger with
     # limited powers (it actually does not send anything to your output), and
     # you can collect them doing @logger.logged(level), where level is the level
-    # used in logging, like info, debug, warn and so on.
+    # used in logging, like info, debug, warn, and so on.
     module TestHelper
       def setup # :nodoc:
         @logger   = MockLogger.new