activesupport 6.0.6.1 → 7.1.3.2

data/lib/active_support/fork_tracker.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ForkTracker # :nodoc:
+    module ModernCoreExt
+      def _fork
+        pid = super
+        if pid == 0
+          ForkTracker.after_fork_callback
+        end
+        pid
+      end
+    end
+
+    module CoreExt
+      def fork(...)
+        if block_given?
+          super do
+            ForkTracker.check!
+            yield
+          end
+        else
+          unless pid = super
+            ForkTracker.check!
+          end
+          pid
+        end
+      end
+    end
+
+    module CoreExtPrivate
+      include CoreExt
+      private :fork
+    end
+
+    @pid = Process.pid
+    @callbacks = []
+
+    class << self
+      def after_fork_callback
+        new_pid = Process.pid
+        if @pid != new_pid
+          @callbacks.each(&:call)
+          @pid = new_pid
+        end
+      end
+
+      if Process.respond_to?(:_fork) # Ruby 3.1+
+        def check!
+          # We trust the `_fork` callback
+        end
+      else
+        alias_method :check!, :after_fork_callback
+      end
+
+      def hook!
+        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)
+        end
+      end
+
+      def after_fork(&block)
+        @callbacks << block
+        block
+      end
+
+      def unregister(callback)
+        @callbacks.delete(callback)
+      end
+    end
+  end
+end
+
+ActiveSupport::ForkTracker.hook!

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 +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 6
-    MINOR = 0
-    TINY  = 6
-    PRE   = "1"
+    MAJOR = 7
+    MINOR = 1
+    TINY  = 3
+    PRE   = "2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/gzip.rb

@@ -4,6 +4,8 @@ require "zlib"
 require "stringio"
 
 module ActiveSupport
+  # = Active Support \Gzip
+  #
   # A convenient wrapper for the zlib standard library that allows
   # compression/decompression of strings with gzip.
   #

data/lib/active_support/hash_with_indifferent_access.rb

@@ -3,8 +3,11 @@
 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
+  # = \Hash With Indifferent Access
+  #
   # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
   # to be the same.
   #
@@ -36,7 +39,7 @@ module ActiveSupport
   #
   # but this class is intended for use cases where strings or symbols are the
   # expected keys and it is convenient to understand both as the same. For
-  # example the +params+ hash in Ruby on Rails.
+  # example the +params+ hash in Ruby on \Rails.
   #
   # Note that core extensions define <tt>Hash#with_indifferent_access</tt>:
   #
@@ -44,7 +47,7 @@ module ActiveSupport
   #
   # which may be handy.
   #
-  # To access this class outside of Rails, require the core extension with:
+  # To access this class outside of \Rails, require the core extension with:
   #
   #   require "active_support/core_ext/hash/indifferent_access"
   #
@@ -64,14 +67,16 @@ module ActiveSupport
       self
     end
 
-    def initialize(constructor = {})
+    def initialize(constructor = nil)
       if constructor.respond_to?(:to_hash)
         super()
         update(constructor)
 
-        hash = constructor.to_hash
+        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
@@ -91,12 +96,12 @@ module ActiveSupport
     #
     # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
     def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value, for: :assignment))
+      regular_writer(convert_key(key), convert_value(value, conversion: :assignment))
     end
 
     alias_method :store, :[]=
 
-    # Updates the receiver in-place, merging in the hash passed as argument:
+    # Updates the receiver in-place, merging in the hashes passed as arguments:
     #
     #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
     #   hash_1[:key] = 'value'
@@ -106,11 +111,14 @@ module ActiveSupport
     #
     #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
     #
-    # The argument can be either an
-    # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash.update({ "a" => 1 }, { "b" => 2 }) # => { "a" => 1, "b" => 2 }
+    #
+    # The arguments can be either an
+    # +ActiveSupport::HashWithIndifferentAccess+ 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
@@ -121,18 +129,15 @@ module ActiveSupport
     #   hash_1[:key] = 10
     #   hash_2['key'] = 12
     #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
-    def update(other_hash)
-      if other_hash.is_a? HashWithIndifferentAccess
-        super(other_hash)
+    def update(*other_hashes, &block)
+      if other_hashes.size == 1
+        update_with_single_argument(other_hashes.first, block)
       else
-        other_hash.to_hash.each_pair do |key, value|
-          if block_given? && key?(key)
-            value = yield(convert_key(key), self[key], value)
-          end
-          regular_writer(convert_key(key), convert_value(value))
+        other_hashes.each do |other_hash|
+          update_with_single_argument(other_hash, block)
         end
-        self
       end
+      self
     end
 
     alias_method :merge!, :update
@@ -215,8 +220,12 @@ module ActiveSupport
     #   hash.default                   # => nil
     #   hash.default('foo')            # => 'foo'
     #   hash.default(:foo)             # => 'foo'
-    def default(*args)
-      super(*args.map { |arg| convert_key(arg) })
+    def default(key = (no_key = true))
+      if no_key
+        super()
+      else
+        super(convert_key(key))
+      end
     end
 
     # Returns an array of the values at the specified indices:
@@ -226,7 +235,8 @@ module ActiveSupport
     #   hash[:b] = 'y'
     #   hash.values_at('a', 'b') # => ["x", "y"]
     def values_at(*keys)
-      super(*keys.map { |key| convert_key(key) })
+      keys.map! { |key| convert_key(key) }
+      super
     end
 
     # Returns an array of the values at the specified indices, but also
@@ -239,7 +249,8 @@ module ActiveSupport
     #   hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
     #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
     def fetch_values(*indices, &block)
-      super(*indices.map { |key| convert_key(key) }, &block)
+      indices.map! { |key| convert_key(key) }
+      super
     end
 
     # Returns a shallow copy of the hash.
@@ -259,8 +270,8 @@ module ActiveSupport
     # This method has the same semantics of +update+, except it does not
     # modify the receiver but rather returns a new hash with indifferent
     # access with the result of the merge.
-    def merge(hash, &block)
-      dup.update(hash, &block)
+    def merge(*hashes, &block)
+      dup.update(*hashes, &block)
     end
 
     # Like +merge+ but the other way around: Merges the receiver into the
@@ -293,8 +304,12 @@ 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) })
+      dup.except!(*keys)
     end
     alias_method :without, :except
 
@@ -319,21 +334,31 @@ module ActiveSupport
       dup.tap { |hash| hash.reject!(*args, &block) }
     end
 
-    def transform_values(*args, &block)
+    def transform_values(&block)
       return to_enum(:transform_values) unless block_given?
-      dup.tap { |hash| hash.transform_values!(*args, &block) }
+      dup.tap { |hash| hash.transform_values!(&block) }
     end
 
-    def transform_keys(*args, &block)
-      return to_enum(:transform_keys) unless block_given?
-      dup.tap { |hash| hash.transform_keys!(*args, &block) }
+    NOT_GIVEN = Object.new # :nodoc:
+
+    def transform_keys(hash = NOT_GIVEN, &block)
+      return to_enum(:transform_keys) if NOT_GIVEN.equal?(hash) && !block_given?
+      dup.tap { |h| h.transform_keys!(hash, &block) }
     end
 
-    def transform_keys!
-      return enum_for(:transform_keys!) { size } unless block_given?
-      keys.each do |key|
-        self[yield(key)] = delete(key)
+    def transform_keys!(hash = NOT_GIVEN, &block)
+      return to_enum(:transform_keys!) if NOT_GIVEN.equal?(hash) && !block_given?
+
+      if hash.nil?
+        super
+      elsif NOT_GIVEN.equal?(hash)
+        keys.each { |key| self[yield(key)] = delete(key) }
+      elsif block_given?
+        keys.each { |key| self[hash[key] || yield(key)] = delete(key) }
+      else
+        keys.each { |key| self[hash[key] || key] = delete(key) }
       end
+
       self
     end
 
@@ -357,40 +382,59 @@ module ActiveSupport
       set_defaults(_new_hash)
 
       each do |key, value|
-        _new_hash[key] = convert_value(value, for: :to_hash)
+        _new_hash[key] = convert_value(value, conversion: :to_hash)
       end
       _new_hash
     end
 
     private
-      def convert_key(key) # :doc:
-        key.kind_of?(Symbol) ? key.to_s : key
+      if Symbol.method_defined?(:name)
+        def convert_key(key)
+          key.kind_of?(Symbol) ? key.name : key
+        end
+      else
+        def convert_key(key)
+          key.kind_of?(Symbol) ? key.to_s : key
+        end
       end
 
-      def convert_value(value, options = {}) # :doc:
+      def convert_value(value, conversion: nil)
         if value.is_a? Hash
-          if options[:for] == :to_hash
+          if conversion == :to_hash
             value.to_hash
           else
             value.nested_under_indifferent_access
           end
         elsif value.is_a?(Array)
-          if options[:for] != :assignment || value.frozen?
+          if conversion != :assignment || value.frozen?
             value = value.dup
           end
-          value.map! { |e| convert_value(e, options) }
+          value.map! { |e| convert_value(e, conversion: conversion) }
         else
           value
         end
       end
 
-      def set_defaults(target) # :doc:
+      def set_defaults(target)
         if default_proc
           target.default_proc = default_proc.dup
         else
           target.default = default
         end
       end
+
+      def update_with_single_argument(other_hash, block)
+        if other_hash.is_a? HashWithIndifferentAccess
+          regular_update(other_hash, &block)
+        else
+          other_hash.to_hash.each_pair do |key, value|
+            if block && key?(key)
+              value = block.call(convert_key(key), self[key], value)
+            end
+            regular_writer(convert_key(key), convert_value(value))
+          end
+        end
+      end
   end
 end
 

data/lib/active_support/html_safe_translation.rb

@@ -0,0 +1,53 @@
+# 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)
+
+        exception = false
+        exception_handler = ->(*args) do
+          exception = true
+          I18n.exception_handler.call(*args)
+        end
+        translation = I18n.translate(key, **html_safe_options, exception_handler: exception_handler)
+        if exception
+          translation
+        else
+          html_safe_translation(translation)
+        end
+      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,8 +5,9 @@ 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"
+  warn "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
   raise e
 end
 require "active_support/lazy_load_hooks"

data/lib/active_support/i18n_railtie.rb

@@ -12,9 +12,7 @@ module I18n
     config.i18n.load_path = []
     config.i18n.fallbacks = ActiveSupport::OrderedOptions.new
 
-    if I18n.respond_to?(:eager_load!)
-      config.eager_load_namespaces << I18n
-    end
+    config.eager_load_namespaces << I18n
 
     # Set the i18n configuration after initialization since a lot of
     # configuration is still usually done in application initializers.
@@ -50,8 +48,10 @@ module I18n
           app.config.i18n.load_path.unshift(*value.flat_map(&:existent))
         when :load_path
           I18n.load_path += value
+        when :raise_on_missing_translations
+          setup_raise_on_missing_translations_config(app)
         else
-          I18n.send("#{setting}=", value)
+          I18n.public_send("#{setting}=", value)
         end
       end
 
@@ -60,21 +60,36 @@ 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)
+      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
 
-        I18n.reload!
+        app.reloaders << reloader
+        app.reloader.to_run do
+          reloader.execute_if_updated { require_unload_lock! }
+        end
+        reloader.execute
       end
 
-      app.reloaders << reloader
-      app.reloader.to_run do
-        reloader.execute_if_updated { require_unload_lock! }
+      @i18n_inited = true
+    end
+
+    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
-      reloader.execute
 
-      @i18n_inited = true
+      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
 
     def self.include_fallbacks_module
@@ -94,19 +109,6 @@ module I18n
           [I18n.default_locale]
         end
 
-      if args.empty? || args.first.is_a?(Hash)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          Using I18n fallbacks with an empty `defaults` sets the defaults to
-          include the `default_locale`. This behavior will change in Rails 6.1.
-          If you desire the default locale to be included in the defaults, please
-          explicitly configure it with `config.i18n.fallbacks.defaults =
-          [I18n.default_locale]` or `config.i18n.fallbacks = [I18n.default_locale,
-          {...}]`. If you want to opt-in to the new behavior, use
-          `config.i18n.fallbacks.defaults = [nil, {...}]`.
-        MSG
-        args.unshift I18n.default_locale
-      end
-
       I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
     end
 

data/lib/active_support/inflector/inflections.rb

@@ -2,12 +2,13 @@
 
 require "concurrent/map"
 require "active_support/i18n"
-require "active_support/deprecation"
 
 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
@@ -17,13 +18,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
@@ -65,6 +66,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:
@@ -77,7 +85,7 @@ module ActiveSupport
       # Private, for the test suite.
       def initialize_dup(orig) # :nodoc:
         %w(plurals singulars uncountables humans acronyms).each do |scope|
-          instance_variable_set("@#{scope}", orig.send(scope).dup)
+          instance_variable_set("@#{scope}", orig.public_send(scope).dup)
         end
         define_acronym_regex_patterns
       end
@@ -161,7 +169,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)
@@ -216,15 +224,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
@@ -249,7 +266,7 @@ module ActiveSupport
       if block_given?
         yield Inflections.instance(locale)
       else
-        Inflections.instance(locale)
+        Inflections.instance_or_fallback(locale)
       end
     end
   end