i18n 1.8.7 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecfb802a53a50fa0b480295092adbe3064584ef69f06b81851b95bd15f49bca2
-  data.tar.gz: 84e6ce2a82b2ce6f52ba8358b5c409c7fe48ff790ca7f3680d922557b06c7f56
+  metadata.gz: b92d195deaeca5e93f73cc62be2d2fb4c93d8a9787449e168b493773e5072458
+  data.tar.gz: f1172c9fac93f493c8a5b16cff4b27154ff917aed48cbc46a4a702363863111d
 SHA512:
-  metadata.gz: c8cf31834170e4aea3f2b25cfad6930372f4ab5f781a9fb7c5f78e6ddabb5316f45a67c5258375d50b5b4ea7f7a97d3a44eda6c34d1a8e7b8c5e5a5f21a95042
-  data.tar.gz: 49532d4362b42b2dcf5f8ef60afd677e64d23aece076933623f0e102f3a803383bff1f6c9add7d00097044459cbd609dd71ead49a965af1636c7a3452f3a885b
+  metadata.gz: 0174d10f7bac17e29cf7622d3ce69850e51755d53fd3d17d2f672bc9ca3c75823b851f6d04cbd367fea8ff5830c8c755fb9c80433bac9ec3c46590cbe9a874d0
+  data.tar.gz: ef22ed98cb7f223753a65b9d63d0f40e4b6821c93a41b1b41627e4c7b4e3de6b7bd411d8a6ed3d46dc6554432a776535c0461248e8d1fbfeee05dcda2ab89235

data/README.md

@@ -1,5 +1,6 @@
 # Ruby I18n
 
+[![Gem Version](https://badge.fury.io/rb/i18n.svg)](https://badge.fury.io/rb/i18n)
 [![Build Status](https://github.com/ruby-i18n/i18n/workflows/Ruby/badge.svg)](https://github.com/ruby-i18n/i18n/actions?query=workflow%3ARuby)
 
 Ruby internationalization and localization (i18n) solution.

data/lib/i18n/backend/base.rb

@@ -2,12 +2,10 @@
 
 require 'yaml'
 require 'json'
-require 'i18n/core_ext/hash'
 
 module I18n
   module Backend
     module Base
-      using I18n::HashRefinements
       include I18n::Backend::Transliterator
 
       # Accepts a list of paths to translation files. Loads translations from
@@ -15,7 +13,10 @@ module I18n
       # for details.
       def load_translations(*filenames)
         filenames = I18n.load_path if filenames.empty?
-        filenames.flatten.each { |filename| load_file(filename) }
+        filenames.flatten.each do |filename|
+          loaded_translations = load_file(filename)
+          yield filename, loaded_translations if block_given?
+        end
       end
 
       # This method receives a locale, a data hash and options for storing translations.
@@ -34,7 +35,7 @@ module I18n
         if entry.nil? && options.key?(:default)
           entry = default(locale, key, options[:default], options)
         else
-          entry = resolve(locale, key, entry, options)
+          entry = resolve_entry(locale, key, entry, options)
         end
 
         count = options[:count]
@@ -53,7 +54,7 @@ module I18n
         end
 
         deep_interpolation = options[:deep_interpolation]
-        values = options.except(*RESERVED_KEYS)
+        values = Utils.except(options, *RESERVED_KEYS)
         if values
           entry = if deep_interpolation
             deep_interpolate(locale, entry, values)
@@ -153,6 +154,7 @@ module I18n
           end
           result unless result.is_a?(MissingTranslation)
         end
+        alias_method :resolve_entry, :resolve
 
         # Picks a translation from a pluralized mnemonic subkey according to English
         # pluralization rules :
@@ -223,24 +225,31 @@ module I18n
         def load_file(filename)
           type = File.extname(filename).tr('.', '').downcase
           raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}", true)
-          data = send(:"load_#{type}", filename)
+          data, keys_symbolized = send(:"load_#{type}", filename)
           unless data.is_a?(Hash)
             raise InvalidLocaleData.new(filename, 'expects it to return a hash, but does not')
           end
-          data.each { |locale, d| store_translations(locale, d || {}) }
+          data.each { |locale, d| store_translations(locale, d || {}, skip_symbolize_keys: keys_symbolized) }
+
+          data
         end
 
         # Loads a plain Ruby translations file. eval'ing the file must yield
         # a Hash containing translation data with locales as toplevel keys.
         def load_rb(filename)
-          eval(IO.read(filename), binding, filename)
+          translations = eval(IO.read(filename), binding, filename)
+          [translations, false]
         end
 
         # Loads a YAML translations file. The data must have locales as
         # toplevel keys.
         def load_yml(filename)
           begin
-            YAML.load_file(filename)
+            if YAML.respond_to?(:unsafe_load_file) # Psych 4.0 way
+              [YAML.unsafe_load_file(filename, symbolize_names: true, freeze: true), true]
+            else
+              [YAML.load_file(filename), false]
+            end
           rescue TypeError, ScriptError, StandardError => e
             raise InvalidLocaleData.new(filename, e.inspect)
           end
@@ -251,7 +260,12 @@ module I18n
         # toplevel keys.
         def load_json(filename)
           begin
-            ::JSON.parse(File.read(filename))
+            # Use #load_file as a proxy for a version of JSON where symbolize_names and freeze are supported.
+            if ::JSON.respond_to?(:load_file)
+              [::JSON.load_file(filename, symbolize_names: true, freeze: true), true]
+            else
+              [::JSON.parse(File.read(filename)), false]
+            end
           rescue TypeError, StandardError => e
             raise InvalidLocaleData.new(filename, e.inspect)
           end

data/lib/i18n/backend/cache.rb

@@ -17,11 +17,11 @@
 #
 # The cache_key implementation by default assumes you pass values that return
 # a valid key from #hash (see
-# http://www.ruby-doc.org/core/classes/Object.html#M000337). However, you can
+# https://www.ruby-doc.org/core/classes/Object.html#M000337). However, you can
 # configure your own digest method via which responds to #hexdigest (see
-# http://ruby-doc.org/stdlib/libdoc/digest/rdoc/index.html):
+# https://ruby-doc.org/stdlib/libdoc/openssl/rdoc/OpenSSL/Digest.html):
 #
-#   I18n.cache_key_digest = Digest::MD5.new
+#   I18n.cache_key_digest = OpenSSL::Digest::SHA256.new
 #
 # If you use a lambda as a default value in your translation like this:
 #

data/lib/i18n/backend/cache_file.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest/sha2'
+require 'openssl'
 
 module I18n
   module Backend
@@ -19,7 +19,7 @@ module I18n
         key = I18n::Backend::Flatten.escape_default_separator(normalized_path(filename))
         old_mtime, old_digest = initialized && lookup(:i18n, key, :load_file)
         return if (mtime = File.mtime(filename).to_i) == old_mtime ||
-                  (digest = Digest::SHA2.file(filename).hexdigest) == old_digest
+                  (digest = OpenSSL::Digest::SHA256.file(filename).hexdigest) == old_digest
         super
         store_translations(:i18n, load_file: { key => [mtime, digest] })
       end

data/lib/i18n/backend/chain.rb

@@ -17,8 +17,6 @@ module I18n
     # The implementation assumes that all backends added to the Chain implement
     # a lookup method with the same API as Simple backend does.
     class Chain
-      using I18n::HashRefinements
-
       module Implementation
         include Base
 
@@ -55,7 +53,7 @@ module I18n
 
         def translate(locale, key, default_options = EMPTY_HASH)
           namespace = nil
-          options = default_options.except(:default)
+          options = Utils.except(default_options, :default)
 
           backends.each do |backend|
             catch(:exception) do
@@ -101,7 +99,7 @@ module I18n
                 init_translations unless initialized?
                 translations
               end
-              memo.deep_merge!(partial_translations) { |_, a, b| b || a }
+              Utils.deep_merge!(memo, partial_translations) { |_, a, b| b || a }
             end
           end
 

data/lib/i18n/backend/fallbacks.rb

@@ -16,11 +16,13 @@ module I18n
     # Returns the current fallbacks implementation. Defaults to +I18n::Locale::Fallbacks+.
     def fallbacks
       @@fallbacks ||= I18n::Locale::Fallbacks.new
+      Thread.current[:i18n_fallbacks] || @@fallbacks
     end
 
     # Sets the current fallbacks implementation. Use this to set a different fallbacks implementation.
     def fallbacks=(fallbacks)
       @@fallbacks = fallbacks.is_a?(Array) ? I18n::Locale::Fallbacks.new(fallbacks) : fallbacks
+      Thread.current[:i18n_fallbacks] = @@fallbacks
     end
   end
 
@@ -41,13 +43,13 @@ module I18n
         return super if options[:fallback_in_progress]
         default = extract_non_symbol_default!(options) if options[:default]
 
-        fallback_options = options.merge(:fallback_in_progress => true)
+        fallback_options = options.merge(:fallback_in_progress => true, fallback_original_locale: locale)
         I18n.fallbacks[locale].each do |fallback|
           begin
             catch(:exception) do
               result = super(fallback, key, fallback_options)
               unless result.nil?
-                on_fallback(locale, fallback, key, options) if locale != fallback
+                on_fallback(locale, fallback, key, options) if locale.to_s != fallback.to_s
                 return result
               end
             end
@@ -62,6 +64,24 @@ module I18n
         throw(:exception, I18n::MissingTranslation.new(locale, key, options))
       end
 
+      def resolve_entry(locale, object, subject, options = EMPTY_HASH)
+        return subject if options[:resolve] == false
+        result = catch(:exception) do
+          options.delete(:fallback_in_progress) if options.key?(:fallback_in_progress)
+
+          case subject
+          when Symbol
+            I18n.translate(subject, **options.merge(:locale => options[:fallback_original_locale], :throw => true))
+          when Proc
+            date_or_time = options.delete(:object) || object
+            resolve_entry(options[:fallback_original_locale], object, subject.call(date_or_time, **options))
+          else
+            subject
+          end
+        end
+        result unless result.is_a?(MissingTranslation)
+      end
+
       def extract_non_symbol_default!(options)
         defaults = [options[:default]].flatten
         first_non_symbol_default = defaults.detect{|default| !default.is_a?(Symbol)}
@@ -87,7 +107,7 @@ module I18n
       private
 
         # Overwrite on_fallback to add specified logic when the fallback succeeds.
-        def on_fallback(_original_locale, _fallback_locale, _key, _optoins)
+        def on_fallback(_original_locale, _fallback_locale, _key, _options)
           nil
         end
     end

data/lib/i18n/backend/gettext.rb

@@ -31,8 +31,6 @@ module I18n
     # Without it strings containing periods (".") will not be translated.
 
     module Gettext
-      using I18n::HashRefinements
-
       class PoData < Hash
         def set_comment(msgid_or_sym, comment)
           # ignore
@@ -43,7 +41,7 @@ module I18n
         def load_po(filename)
           locale = ::File.basename(filename, '.po').to_sym
           data = normalize(locale, parse(filename))
-          { locale => data }
+          [{ locale => data }, false]
         end
 
         def parse(filename)
@@ -61,7 +59,7 @@ module I18n
                 { part => _normalized.empty? ? value : _normalized }
               end
 
-              result.deep_merge!(normalized)
+              Utils.deep_merge!(result, normalized)
             end
             result
           end

data/lib/i18n/backend/key_value.rb

@@ -67,8 +67,6 @@ module I18n
     #
     # This is useful if you are using a KeyValue backend chained to a Simple backend.
     class KeyValue
-      using I18n::HashRefinements
-
       module Implementation
         attr_accessor :store
 
@@ -91,7 +89,7 @@ module I18n
             when Hash
               if @subtrees && (old_value = @store[key])
                 old_value = JSON.decode(old_value)
-                value = old_value.deep_symbolize_keys.deep_merge!(value) if old_value.is_a?(Hash)
+                value = Utils.deep_merge!(Utils.deep_symbolize_keys(old_value), value) if old_value.is_a?(Hash)
               end
             when Proc
               raise "Key-value stores cannot handle procs"
@@ -115,12 +113,12 @@ module I18n
         # them into a hash such as the one returned from loading the
         # haml files
         def translations
-          @translations = @store.keys.clone.map do |main_key|
+          @translations = Utils.deep_symbolize_keys(@store.keys.clone.map do |main_key|
             main_value = JSON.decode(@store[main_key])
             main_key.to_s.split(".").reverse.inject(main_value) do |value, key|
               {key.to_sym => value}
             end
-          end.inject{|hash, elem| hash.deep_merge!(elem)}.deep_symbolize_keys
+          end.inject{|hash, elem| Utils.deep_merge!(hash, elem)})
         end
 
         def init_translations
@@ -141,7 +139,7 @@ module I18n
           value = JSON.decode(value) if value
 
           if value.is_a?(Hash)
-            value.deep_symbolize_keys
+            Utils.deep_symbolize_keys(value)
           elsif !value.nil?
             value
           elsif !@subtrees

data/lib/i18n/backend/lazy_loadable.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module I18n
+  module Backend
+    # Backend that lazy loads translations based on the current locale. This
+    # implementation avoids loading all translations up front. Instead, it only
+    # loads the translations that belong to the current locale. This offers a
+    # performance incentive in local development and test environments for
+    # applications with many translations for many different locales. It's
+    # particularly useful when the application only refers to a single locales'
+    # translations at a time (ex. A Rails workload).  The implementation
+    # identifies which translation files from the load path belong to the
+    # current locale by pattern matching against their path name.
+    #
+    # Specifically, a translation file is considered to belong to a locale if:
+    # a) the filename is in the I18n load path
+    # b) the filename ends in a supported extension (ie. .yml, .json, .po, .rb)
+    # c) the filename starts with the locale identifier
+    # d) the locale identifier and optional proceeding text is separated by an underscore, ie. "_".
+    #
+    # Examples:
+    # Valid files that will be selected by this backend:
+    #
+    # "files/locales/en_translation.yml" (Selected for locale "en")
+    # "files/locales/fr.po"  (Selected for locale "fr")
+    #
+    # Invalid files that won't be selected by this backend:
+    #
+    # "files/locales/translation-file"
+    # "files/locales/en-translation.unsupported"
+    # "files/locales/french/translation.yml"
+    # "files/locales/fr/translation.yml"
+    #
+    # The implementation uses this assumption to defer the loading of
+    # translation files until the current locale actually requires them.
+    #
+    # The backend has two working modes: lazy_load and eager_load.
+    #
+    # Note: This backend should only be enabled in test environments!
+    # When the mode is set to false, the backend behaves exactly like the
+    # Simple backend, with an additional check that the paths being loaded
+    # abide by the format. If paths can't be matched to the format, an error is raised.
+    #
+    # You can configure lazy loaded backends through the initializer or backends
+    # accessor:
+    #
+    #   # In test environments
+    #
+    #   I18n.backend = I18n::Backend::LazyLoadable.new(lazy_load: true)
+    #
+    #   # In other environments, such as production and CI
+    #
+    #   I18n.backend = I18n::Backend::LazyLoadable.new(lazy_load: false) # default
+    #
+    class LocaleExtractor
+      class << self
+        def locale_from_path(path)
+          name = File.basename(path, ".*")
+          locale = name.split("_").first
+          locale.to_sym unless locale.nil?
+        end
+      end
+    end
+
+    class LazyLoadable < Simple
+      def initialize(lazy_load: false)
+        @lazy_load = lazy_load
+      end
+
+      # Returns whether the current locale is initialized.
+      def initialized?
+        if lazy_load?
+          initialized_locales[I18n.locale]
+        else
+          super
+        end
+      end
+
+      # Clean up translations and uninitialize all locales.
+      def reload!
+        if lazy_load?
+          @initialized_locales = nil
+          @translations = nil
+        else
+          super
+        end
+      end
+
+      # Eager loading is not supported in the lazy context.
+      def eager_load!
+        if lazy_load?
+          raise UnsupportedMethod.new(__method__, self.class, "Cannot eager load translations because backend was configured with lazy_load: true.")
+        else
+          super
+        end
+      end
+
+      # Parse the load path and extract all locales.
+      def available_locales
+        if lazy_load?
+          I18n.load_path.map { |path| LocaleExtractor.locale_from_path(path) }
+        else
+          super
+        end
+      end
+
+      def lookup(locale, key, scope = [], options = EMPTY_HASH)
+        if lazy_load?
+          I18n.with_locale(locale) do
+            super
+          end
+        else
+          super
+        end
+      end
+
+      protected
+
+
+      # Load translations from files that belong to the current locale.
+      def init_translations
+        file_errors = if lazy_load?
+          initialized_locales[I18n.locale] = true
+          load_translations_and_collect_file_errors(filenames_for_current_locale)
+        else
+          @initialized = true
+          load_translations_and_collect_file_errors(I18n.load_path)
+        end
+
+        raise InvalidFilenames.new(file_errors) unless file_errors.empty?
+      end
+
+      def initialized_locales
+        @initialized_locales ||= Hash.new(false)
+      end
+
+      private
+
+      def lazy_load?
+        @lazy_load
+      end
+
+      class FilenameIncorrect < StandardError
+        def initialize(file, expected_locale, unexpected_locales)
+          super "#{file} can only load translations for \"#{expected_locale}\". Found translations for: #{unexpected_locales}."
+        end
+      end
+
+      # Loads each file supplied and asserts that the file only loads
+      # translations as expected by the name. The method returns a list of
+      # errors corresponding to offending files.
+      def load_translations_and_collect_file_errors(files)
+        errors = []
+
+        load_translations(files) do |file, loaded_translations|
+          assert_file_named_correctly!(file, loaded_translations)
+        rescue FilenameIncorrect => e
+          errors << e
+        end
+
+        errors
+      end
+
+      # Select all files from I18n load path that belong to current locale.
+      # These files must start with the locale identifier (ie. "en", "pt-BR"),
+      # followed by an "_" demarcation to separate proceeding text.
+      def filenames_for_current_locale
+        I18n.load_path.flatten.select do |path|
+          LocaleExtractor.locale_from_path(path) == I18n.locale
+        end
+      end
+
+      # Checks if a filename is named in correspondence to the translations it loaded.
+      # The locale extracted from the path must be the single locale loaded in the translations.
+      def assert_file_named_correctly!(file, translations)
+        loaded_locales = translations.keys.map(&:to_sym)
+        expected_locale = LocaleExtractor.locale_from_path(file)
+        unexpected_locales = loaded_locales.reject { |locale| locale == expected_locale }
+
+        raise FilenameIncorrect.new(file, expected_locale, unexpected_locales) unless unexpected_locales.empty?
+      end
+    end
+  end
+end

data/lib/i18n/backend/simple.rb

@@ -19,8 +19,6 @@ module I18n
     #
     # I18n::Backend::Simple.include(I18n::Backend::Pluralization)
     class Simple
-      using I18n::HashRefinements
-
       module Implementation
         include Base
 
@@ -35,14 +33,13 @@ module I18n
         def store_translations(locale, data, options = EMPTY_HASH)
           if I18n.enforce_available_locales &&
             I18n.available_locales_initialized? &&
-            !I18n.available_locales.include?(locale.to_sym) &&
-            !I18n.available_locales.include?(locale.to_s)
+            !I18n.locale_available?(locale)
             return data
           end
           locale = locale.to_sym
-          translations[locale] ||= {}
-          data = data.deep_symbolize_keys
-          translations[locale].deep_merge!(data)
+          translations[locale] ||= Concurrent::Hash.new
+          data = Utils.deep_symbolize_keys(data) unless options.fetch(:skip_symbolize_keys, false)
+          Utils.deep_merge!(translations[locale], data)
         end
 
         # Get available locales from the translations hash
@@ -71,7 +68,7 @@ module I18n
           # call `init_translations`
           init_translations if do_init && !initialized?
 
-          @translations ||= {}
+          @translations ||= Concurrent::Hash.new { |h, k| h[k] = Concurrent::Hash.new }
         end
 
       protected
@@ -97,7 +94,7 @@ module I18n
               return nil unless result.has_key?(_key)
             end
             result = result[_key]
-            result = resolve(locale, _key, result, options.merge(:scope => nil)) if result.is_a?(Symbol)
+            result = resolve_entry(locale, _key, result, options.merge(:scope => nil)) if result.is_a?(Symbol)
             result
           end
         end

data/lib/i18n/backend.rb

@@ -3,7 +3,6 @@
 module I18n
   module Backend
     autoload :Base,                  'i18n/backend/base'
-    autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
     autoload :Cache,                 'i18n/backend/cache'
     autoload :CacheFile,             'i18n/backend/cache_file'
     autoload :Cascade,               'i18n/backend/cascade'
@@ -11,7 +10,9 @@ module I18n
     autoload :Fallbacks,             'i18n/backend/fallbacks'
     autoload :Flatten,               'i18n/backend/flatten'
     autoload :Gettext,               'i18n/backend/gettext'
+    autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
     autoload :KeyValue,              'i18n/backend/key_value'
+    autoload :LazyLoadable,          'i18n/backend/lazy_loadable'
     autoload :Memoize,               'i18n/backend/memoize'
     autoload :Metadata,              'i18n/backend/metadata'
     autoload :Pluralization,         'i18n/backend/pluralization'

data/lib/i18n/config.rb

@@ -38,7 +38,7 @@ module I18n
     end
 
     # Returns an array of locales for which translations are available.
-    # Unless you explicitely set these through I18n.available_locales=
+    # Unless you explicitly set these through I18n.available_locales=
     # the call will be delegated to the backend.
     def available_locales
       @@available_locales ||= nil
@@ -106,7 +106,7 @@ module I18n
     # if you don't care about arity.
     #
     # == Example:
-    # You can supress raising an exception and return string instead:
+    # You can suppress raising an exception and return string instead:
     #
     #   I18n.config.missing_interpolation_argument_handler = Proc.new do |key|
     #     "#{key} is missing"

data/lib/i18n/exceptions.rb

@@ -24,7 +24,7 @@ module I18n
         been set is likely to display text from the wrong locale to some users.
 
         If you have a legitimate reason to access i18n data outside of the user flow, you can do so by passing
-        the desired locale explictly with the `locale` argument, e.g. `I18n.#{method}(..., locale: :en)`
+        the desired locale explicitly with the `locale` argument, e.g. `I18n.#{method}(..., locale: :en)`
       MESSAGE
     end
   end
@@ -47,10 +47,12 @@ module I18n
 
   class MissingTranslation < ArgumentError
     module Base
+      PERMITTED_KEYS = [:scope].freeze
+
       attr_reader :locale, :key, :options
 
       def initialize(locale, key, options = EMPTY_HASH)
-        @key, @locale, @options = key, locale, options.dup
+        @key, @locale, @options = key, locale, options.slice(*PERMITTED_KEYS)
         options.each { |k, v| self.options[k] = v.inspect if v.is_a?(Proc) }
       end
 
@@ -108,4 +110,38 @@ module I18n
       super "can not load translations from #{filename}, the file type #{type} is not known"
     end
   end
+
+  class UnsupportedMethod < ArgumentError
+    attr_reader :method, :backend_klass, :msg
+    def initialize(method, backend_klass, msg)
+      @method = method
+      @backend_klass = backend_klass
+      @msg = msg
+      super "#{backend_klass} does not support the ##{method} method. #{msg}"
+    end
+  end
+
+  class InvalidFilenames < ArgumentError
+    NUMBER_OF_ERRORS_SHOWN = 20
+    def initialize(file_errors)
+      super <<~MSG
+        Found #{file_errors.count} error(s).
+        The first #{[file_errors.count, NUMBER_OF_ERRORS_SHOWN].min} error(s):
+        #{file_errors.map(&:message).first(NUMBER_OF_ERRORS_SHOWN).join("\n")}
+
+        To use the LazyLoadable backend:
+        1. Filenames must start with the locale.
+        2. An underscore must separate the locale with any optional text that follows.
+        3. The file must only contain translation data for the single locale.
+
+        Example:
+        "/config/locales/fr.yml" which contains:
+        ```yml
+          fr:
+            dog:
+              chien
+        ```
+      MSG
+    end
+  end
 end

data/lib/i18n/interpolate/ruby.rb

@@ -5,7 +5,7 @@ module I18n
   DEFAULT_INTERPOLATION_PATTERNS = [
     /%%/,
     /%\{([\w|]+)\}/,                            # matches placeholders like "%{foo} or %{foo|word}"
-    /%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/  # matches placeholders like "%<foo>.d"
+    /%<(\w+)>([^\d]*?\d*\.?\d*[bBdiouxXeEfgGcps])/  # matches placeholders like "%<foo>.d"
   ].freeze
   INTERPOLATION_PATTERN = Regexp.union(DEFAULT_INTERPOLATION_PATTERNS)
   deprecate_constant :INTERPOLATION_PATTERN
@@ -14,7 +14,7 @@ module I18n
     # Return String or raises MissingInterpolationArgument exception.
     # Missing argument's logic is handled by I18n.config.missing_interpolation_argument_handler.
     def interpolate(string, values)
-      raise ReservedInterpolationKey.new($1.to_sym, string) if string =~ RESERVED_KEYS_PATTERN
+      raise ReservedInterpolationKey.new($1.to_sym, string) if string =~ I18n.reserved_keys_pattern
       raise ArgumentError.new('Interpolation values must be a Hash.') unless values.kind_of?(Hash)
       interpolate_hash(string, values)
     end

data/lib/i18n/locale/fallbacks.rb

@@ -15,19 +15,12 @@
 #   * all parent locales of a given locale (e.g. :es for :"es-MX") first,
 #   * the current default locales and all of their parents second
 #
-# The default locales are set to [I18n.default_locale] by default but can be
-# set to something else.
+# The default locales are set to [] by default but can be set to something else.
 #
 # One can additionally add any number of additional fallback locales manually.
 # These will be added before the default locales to the fallback chain. For
 # example:
 #
-#   # using the default locale as default fallback locale
-#
-#   I18n.default_locale = :"en-US"
-#   I18n.fallbacks = I18n::Locale::Fallbacks.new(:"de-AT" => :"de-DE")
-#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :de, :"de-DE"]
-#
 #   # using a custom locale as default fallback locale
 #
 #   I18n.fallbacks = I18n::Locale::Fallbacks.new(:"en-GB", :"de-AT" => :de, :"de-CH" => :de)
@@ -46,7 +39,7 @@
 #   fallbacks[:"ar-PS"] # => [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en]
 #   fallbacks[:"ar-EG"] # => [:"ar-EG", :ar, :"en-US", :en]
 #
-#   # people speaking Sami as spoken in Finnland also speak Swedish and Finnish as spoken in Finnland
+#   # people speaking Sami as spoken in Finland also speak Swedish and Finnish as spoken in Finland
 #   fallbacks.map(:sms => [:"se-FI", :"fi-FI"])
 #   fallbacks[:sms] # => [:sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en]
 
@@ -71,13 +64,18 @@ module I18n
         super || store(locale, compute(locale))
       end
 
-      def map(mappings)
-        mappings.each do |from, to|
-          from, to = from.to_sym, Array(to)
-          to.each do |_to|
-            @map[from] ||= []
-            @map[from] << _to.to_sym
+      def map(*args, &block)
+        if args.count == 1 && !block_given?
+          mappings = args.first
+          mappings.each do |from, to|
+            from, to = from.to_sym, Array(to)
+            to.each do |_to|
+              @map[from] ||= []
+              @map[from] << _to.to_sym
+            end
           end
+        else
+          @map.map(*args, &block)
         end
       end
 

data/lib/i18n/locale/tag/simple.rb

@@ -1,5 +1,5 @@
 # Simple Locale tag implementation that computes subtags by simply splitting
-# the locale tag at '-' occurences.
+# the locale tag at '-' occurrences.
 module I18n
   module Locale
     module Tag

data/lib/i18n/tests/basics.rb

@@ -5,12 +5,11 @@ module I18n
         I18n.available_locales = nil
       end
 
-      test "available_locales returns the locales stored to the backend by default" do
+      test "available_locales returns the available_locales produced by the backend, by default" do
         I18n.backend.store_translations('de', :foo => 'bar')
         I18n.backend.store_translations('en', :foo => 'foo')
 
-        assert I18n.available_locales.include?(:de)
-        assert I18n.available_locales.include?(:en)
+        assert_equal I18n.available_locales, I18n.backend.available_locales
       end
 
       test "available_locales can be set to something else independently from the actual locale data" do
@@ -24,11 +23,10 @@ module I18n
         assert_equal [:foo, :bar], I18n.available_locales
 
         I18n.available_locales = nil
-        assert I18n.available_locales.include?(:de)
-        assert I18n.available_locales.include?(:en)
+        assert_equal I18n.available_locales, I18n.backend.available_locales
       end
 
-      test "available_locales memoizes when set explicitely" do
+      test "available_locales memoizes when set explicitly" do
         I18n.backend.expects(:available_locales).never
         I18n.available_locales = [:foo]
         I18n.backend.store_translations('de', :bar => 'baz')
@@ -36,7 +34,7 @@ module I18n
         assert_equal [:foo], I18n.available_locales
       end
 
-      test "available_locales delegates to the backend when not set explicitely" do
+      test "available_locales delegates to the backend when not set explicitly" do
         original_available_locales_value = I18n.backend.available_locales
         I18n.backend.expects(:available_locales).returns(original_available_locales_value).twice
         assert_equal I18n.backend.available_locales, I18n.available_locales

data/lib/i18n/tests/defaults.rb

@@ -37,7 +37,7 @@ module I18n
       end
 
       test "defaults: given an array of missing keys it raises a MissingTranslationData exception" do
-        assert_raise I18n::MissingTranslationData do
+        assert_raises I18n::MissingTranslationData do
           I18n.t(:does_not_exist, :default => [:does_not_exist_2, :does_not_exist_3], :raise => true)
         end
       end

data/lib/i18n/tests/interpolation.rb

@@ -41,7 +41,7 @@ module I18n
       end
 
       test "interpolation: given values but missing a key it raises I18n::MissingInterpolationArgument" do
-        assert_raise(I18n::MissingInterpolationArgument) do
+        assert_raises(I18n::MissingInterpolationArgument) do
           interpolate(:default => '%{foo}', :bar => 'bar')
         end
       end
@@ -77,13 +77,13 @@ module I18n
 
       if Object.const_defined?(:Encoding)
         test "interpolation: given a euc-jp translation and a utf-8 value it raises Encoding::CompatibilityError" do
-          assert_raise(Encoding::CompatibilityError) do
+          assert_raises(Encoding::CompatibilityError) do
             interpolate(:default => euc_jp('こんにちは、%{name}さん!'), :name => 'ゆきひろ')
           end
         end
 
         test "interpolation: given a utf-8 translation and a euc-jp value it raises Encoding::CompatibilityError" do
-          assert_raise(Encoding::CompatibilityError) do
+          assert_raises(Encoding::CompatibilityError) do
             interpolate(:default => 'こんにちは、%{name}さん!', :name => euc_jp('ゆきひろ'))
           end
         end
@@ -108,10 +108,10 @@ module I18n
       end
 
       test "interpolation: given a translations containing a reserved key it raises I18n::ReservedInterpolationKey" do
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{exception_handler}') }
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{default}') }
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{separator}') }
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{scope}') }
+        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{exception_handler}') }
+        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{default}') }
+        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{separator}') }
+        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{scope}') }
       end
 
       test "interpolation: deep interpolation for default string" do

data/lib/i18n/tests/localization/date.rb

@@ -78,15 +78,15 @@ module I18n
         end
 
         test "localize Date: given nil it raises I18n::ArgumentError" do
-          assert_raise(I18n::ArgumentError) { I18n.l(nil) }
+          assert_raises(I18n::ArgumentError) { I18n.l(nil) }
         end
 
         test "localize Date: given a plain Object it raises I18n::ArgumentError" do
-          assert_raise(I18n::ArgumentError) { I18n.l(Object.new) }
+          assert_raises(I18n::ArgumentError) { I18n.l(Object.new) }
         end
 
         test "localize Date: given a format is missing it raises I18n::MissingTranslationData" do
-          assert_raise(I18n::MissingTranslationData) { I18n.l(@date, :format => :missing) }
+          assert_raises(I18n::MissingTranslationData) { I18n.l(@date, :format => :missing) }
         end
 
         test "localize Date: it does not alter the format string" do

data/lib/i18n/tests/localization/date_time.rb

@@ -78,7 +78,7 @@ module I18n
         end
 
         test "localize DateTime: given a format is missing it raises I18n::MissingTranslationData" do
-          assert_raise(I18n::MissingTranslationData) { I18n.l(@datetime, :format => :missing) }
+          assert_raises(I18n::MissingTranslationData) { I18n.l(@datetime, :format => :missing) }
         end
 
         protected

data/lib/i18n/tests/localization/procs.rb

@@ -74,6 +74,7 @@ module I18n
                 arg.strftime('%a, %d %b %Y')
               when Hash
                 arg.delete(:fallback_in_progress)
+                arg.delete(:fallback_original_locale)
                 arg.inspect
               else
                 arg.inspect

data/lib/i18n/tests/localization/time.rb

@@ -79,7 +79,7 @@ module I18n
         end
 
         test "localize Time: given a format is missing it raises I18n::MissingTranslationData" do
-          assert_raise(I18n::MissingTranslationData) { I18n.l(@time, :format => :missing) }
+          assert_raises(I18n::MissingTranslationData) { I18n.l(@time, :format => :missing) }
         end
 
         protected

data/lib/i18n/tests/lookup.rb

@@ -34,7 +34,7 @@ module I18n
       end
 
       test "lookup: given a missing key, no default and the raise option it raises MissingTranslationData" do
-        assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+        assert_raises(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
       end
 
       test "lookup: does not raise an exception if no translation data is present for the given locale" do
@@ -61,7 +61,7 @@ module I18n
       # In fact it probably *should* fail but Rails currently relies on using the default locale instead.
       # So we'll stick to this for now until we get it fixed in Rails.
       test "lookup: given nil as a locale it does not raise but use the default locale" do
-        # assert_raise(I18n::InvalidLocale) { I18n.t(:bar, :locale => nil) }
+        # assert_raises(I18n::InvalidLocale) { I18n.t(:bar, :locale => nil) }
         assert_nothing_raised { I18n.t(:bar, :locale => nil) }
       end
 

data/lib/i18n/tests/pluralization.rb

@@ -28,7 +28,7 @@ module I18n
       end
 
       test "pluralization: given incomplete pluralization data it raises I18n::InvalidPluralizationData" do
-        assert_raise(I18n::InvalidPluralizationData) { I18n.t(:default => { :one => 'bar' }, :count => 2) }
+        assert_raises(I18n::InvalidPluralizationData) { I18n.t(:default => { :one => 'bar' }, :count => 2) }
       end
     end
   end

data/lib/i18n/tests/procs.rb

@@ -53,7 +53,13 @@ module I18n
 
 
       def self.filter_args(*args)
-        args.map {|arg| arg.delete(:fallback_in_progress) if arg.is_a?(Hash) ; arg }.inspect
+        args.map do |arg|
+          if arg.is_a?(Hash)
+            arg.delete(:fallback_in_progress)
+            arg.delete(:fallback_original_locale)
+          end
+          arg
+        end.inspect
       end
     end
   end

data/lib/i18n/utils.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module I18n
+  module Utils
+    class << self
+      if Hash.method_defined?(:except)
+        def except(hash, *keys)
+          hash.except(*keys)
+        end
+      else
+        def except(hash, *keys)
+          hash = hash.dup
+          keys.each { |k| hash.delete(k) }
+          hash
+        end
+      end
+
+      def deep_merge(hash, other_hash, &block)
+        deep_merge!(hash.dup, other_hash, &block)
+      end
+
+      def deep_merge!(hash, other_hash, &block)
+        hash.merge!(other_hash) do |key, this_val, other_val|
+          if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+            deep_merge(this_val, other_val, &block)
+          elsif block_given?
+            yield key, this_val, other_val
+          else
+            other_val
+          end
+        end
+      end
+
+      def deep_symbolize_keys(hash)
+        hash.each_with_object({}) do |(key, value), result|
+          result[key.respond_to?(:to_sym) ? key.to_sym : key] = deep_symbolize_keys_in_object(value)
+          result
+        end
+      end
+
+      private
+
+      def deep_symbolize_keys_in_object(value)
+        case value
+        when Hash
+          deep_symbolize_keys(value)
+        when Array
+          value.map { |e| deep_symbolize_keys_in_object(e) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/i18n/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module I18n
-  VERSION = "1.8.7"
+  VERSION = "1.12.0"
 end

data/lib/i18n.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'concurrent/map'
+require 'concurrent/hash'
 
 require 'i18n/version'
+require 'i18n/utils'
 require 'i18n/exceptions'
 require 'i18n/interpolate/ruby'
 
@@ -21,6 +23,7 @@ module I18n
     exception_handler
     fallback
     fallback_in_progress
+    fallback_original_locale
     format
     object
     raise
@@ -28,12 +31,24 @@ module I18n
     scope
     separator
     throw
-  ].freeze
-  RESERVED_KEYS_PATTERN = /%\{(#{RESERVED_KEYS.join("|")})\}/
+  ]
   EMPTY_HASH = {}.freeze
 
   def self.new_double_nested_cache # :nodoc:
-    Concurrent::Map.new { |h,k| h[k] = Concurrent::Map.new }
+    Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
+  end
+
+  # Marks a key as reserved. Reserved keys are used internally,
+  # and can't also be used for interpolation. If you are using any
+  # extra keys as I18n options, you should call I18n.reserve_key
+  # before any I18n.translate (etc) calls are made.
+  def self.reserve_key(key)
+    RESERVED_KEYS << key.to_sym
+    @reserved_keys_pattern = nil
+  end
+
+  def self.reserved_keys_pattern # :nodoc:
+    @reserved_keys_pattern ||= /%\{(#{RESERVED_KEYS.join("|")})\}/
   end
 
   module Base
@@ -199,18 +214,12 @@ module I18n
 
       backend = config.backend
 
-      result = catch(:exception) do
-        if key.is_a?(Array)
-          key.map { |k| backend.translate(locale, k, options) }
-        else
-          backend.translate(locale, key, options)
+      if key.is_a?(Array)
+        key.map do |k|
+          translate_key(k, throw, raise, locale, backend, options)
         end
-      end
-
-      if result.is_a?(MissingTranslation)
-        handle_exception((throw && :throw || raise && :raise), result, locale, key, options)
       else
-        result
+        translate_key(key, throw, raise, locale, backend, options)
       end
     end
     alias :t :translate
@@ -259,14 +268,14 @@ module I18n
     #
     # Setting a Hash using Ruby:
     #
-    #     store_translations(:de, :i18n => {
-    #       :transliterate => {
-    #         :rule => {
-    #           "ü" => "ue",
-    #           "ö" => "oe"
-    #         }
-    #       }
-    #     )
+    #     store_translations(:de, i18n: {
+    #                          transliterate: {
+    #                            rule: {
+    #                              'ü' => 'ue',
+    #                              'ö' => 'oe'
+    #                            }
+    #                          }
+    #                        })
     #
     # Setting a Proc:
     #
@@ -323,11 +332,11 @@ module I18n
     def normalize_keys(locale, key, scope, separator = nil)
       separator ||= I18n.default_separator
 
-      keys = []
-      keys.concat normalize_key(locale, separator)
-      keys.concat normalize_key(scope, separator)
-      keys.concat normalize_key(key, separator)
-      keys
+      [
+        *normalize_key(locale, separator),
+        *normalize_key(scope, separator),
+        *normalize_key(key, separator)
+      ]
     end
 
     # Returns true when the passed locale, which can be either a String or a
@@ -349,6 +358,18 @@ module I18n
 
   private
 
+    def translate_key(key, throw, raise, locale, backend, options)
+      result = catch(:exception) do
+        backend.translate(locale, key, options)
+      end
+
+      if result.is_a?(MissingTranslation)
+        handle_exception((throw && :throw || raise && :raise), result, locale, key, options)
+      else
+        result
+      end
+    end
+
     # Any exceptions thrown in translate will be sent to the @@exception_handler
     # which can be a Symbol, a Proc or any other Object unless they're forced to
     # be raised or thrown (MissingTranslation).
@@ -395,7 +416,7 @@ module I18n
           keys.delete('')
           keys.map! do |k|
             case k
-            when /\A[-+]?[1-9]\d*\z/ # integer
+            when /\A[-+]?([1-9]\d*|0)\z/ # integer
               k.to_i
             when 'true'
               true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: i18n
 version: !ruby/object:Gem::Version
-  version: 1.8.7
+  version: 1.12.0
 platform: ruby
 authors:
 - Sven Fuchs
@@ -13,7 +13,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-04 00:00:00.000000000 Z
+date: 2022-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -49,13 +49,13 @@ files:
 - lib/i18n/backend/gettext.rb
 - lib/i18n/backend/interpolation_compiler.rb
 - lib/i18n/backend/key_value.rb
+- lib/i18n/backend/lazy_loadable.rb
 - lib/i18n/backend/memoize.rb
 - lib/i18n/backend/metadata.rb
 - lib/i18n/backend/pluralization.rb
 - lib/i18n/backend/simple.rb
 - lib/i18n/backend/transliterator.rb
 - lib/i18n/config.rb
-- lib/i18n/core_ext/hash.rb
 - lib/i18n/exceptions.rb
 - lib/i18n/gettext.rb
 - lib/i18n/gettext/helpers.rb
@@ -81,6 +81,7 @@ files:
 - lib/i18n/tests/lookup.rb
 - lib/i18n/tests/pluralization.rb
 - lib/i18n/tests/procs.rb
+- lib/i18n/utils.rb
 - lib/i18n/version.rb
 homepage: https://github.com/ruby-i18n/i18n
 licenses:
@@ -90,23 +91,7 @@ metadata:
   changelog_uri: https://github.com/ruby-i18n/i18n/releases
   documentation_uri: https://guides.rubyonrails.org/i18n.html
   source_code_uri: https://github.com/ruby-i18n/i18n
-post_install_message: |2+
-
-  HEADS UP! i18n 1.1 changed fallbacks to exclude default locale.
-  But that may break your application.
-
-  If you are upgrading your Rails application from an older version of Rails:
-
-  Please check your Rails app for 'config.i18n.fallbacks = true'.
-  If you're using I18n (>= 1.1.0) and Rails (< 5.2.2), this should be
-  'config.i18n.fallbacks = [I18n.default_locale]'.
-  If not, fallbacks will be broken in your app by I18n 1.1.x.
-
-  If you are starting a NEW Rails application, you can ignore this notice.
-
-  For more info see:
-  https://github.com/svenfuchs/i18n/releases/tag/v1.1.0
-
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -121,9 +106,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.5
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.16
 signing_key:
 specification_version: 4
 summary: New wave Internationalization support for Ruby
 test_files: []
-...

data/lib/i18n/core_ext/hash.rb

@@ -1,59 +0,0 @@
-module I18n
-  module HashRefinements
-    refine Hash do
-      using I18n::HashRefinements
-      def except(*keys)
-        dup.except!(*keys)
-      end
-
-      def except!(*keys)
-        keys.each { |key| delete(key) }
-        self
-      end
-
-      def deep_symbolize_keys
-        each_with_object({}) do |(key, value), result|
-          result[symbolize_key(key)] = deep_symbolize_keys_in_object(value)
-          result
-        end
-      end
-
-      # deep_merge from activesupport 5
-      # Copyright (c) 2005-2019 David Heinemeier Hansson
-      def deep_merge(other_hash, &block)
-        dup.deep_merge!(other_hash, &block)
-      end
-
-      # deep_merge! from activesupport 5
-      # Copyright (c) 2005-2019 David Heinemeier Hansson
-      def deep_merge!(other_hash, &block)
-        merge!(other_hash) do |key, this_val, other_val|
-          if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-            this_val.deep_merge(other_val, &block)
-          elsif block_given?
-            block.call(key, this_val, other_val)
-          else
-            other_val
-          end
-        end
-      end
-
-      def symbolize_key(key)
-        key.respond_to?(:to_sym) ? key.to_sym : key
-      end
-
-      private
-
-      def deep_symbolize_keys_in_object(value)
-        case value
-        when Hash
-          value.deep_symbolize_keys
-        when Array
-          value.map { |e| deep_symbolize_keys_in_object(e) }
-        else
-          value
-        end
-      end
-    end
-  end
-end