i18n 1.12.0 → 1.14.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b92d195deaeca5e93f73cc62be2d2fb4c93d8a9787449e168b493773e5072458
-  data.tar.gz: f1172c9fac93f493c8a5b16cff4b27154ff917aed48cbc46a4a702363863111d
+  metadata.gz: edf1a48f0dd110066260f4d93cd2af16e73e9f91845a16126794d4c9af5b664c
+  data.tar.gz: 36a488fcbbaefdabb42e1a6f42af534fa36f640de5674d31a92407d6dfd1835d
 SHA512:
-  metadata.gz: 0174d10f7bac17e29cf7622d3ce69850e51755d53fd3d17d2f672bc9ca3c75823b851f6d04cbd367fea8ff5830c8c755fb9c80433bac9ec3c46590cbe9a874d0
-  data.tar.gz: ef22ed98cb7f223753a65b9d63d0f40e4b6821c93a41b1b41627e4c7b4e3de6b7bd411d8a6ed3d46dc6554432a776535c0461248e8d1fbfeee05dcda2ab89235
+  metadata.gz: 82897d5266dfb62379930d6f94346dc0e62c14e619995e3933dc6339d0dd6d06d4b491449d1f4eb43128de995e3d9837624e4132b7b506455e0169dece108b7f
+  data.tar.gz: 8938b0f8d862e989f7427ccb2299722914bd485af9afff24bf0bda6cd8f438dc750cacd8c85d45292787f2e78438ead7c7533d6c696f5d5b9fc7109535a48ee4

data/README.md

@@ -13,10 +13,14 @@ Currently maintained by @radar.
 
 You will most commonly use this library within a Rails app.
 
+We support Rails versions from 6.0 and up.
+
 [See the Rails Guide](https://guides.rubyonrails.org/i18n.html) for an example of its usage.
 
 ### Ruby (without Rails)
 
+We support Ruby versions from 3.0 and up.
+
 If you want to use this library without Rails, you can simply add `i18n` to your `Gemfile`:
 
 ```ruby
@@ -26,7 +30,7 @@ gem 'i18n'
 Then configure I18n with some translations, and a default locale:
 
 ```ruby
-I18n.load_path << Dir[File.expand_path("config/locales") + "/*.yml"]
+I18n.load_path += Dir[File.expand_path("config/locales") + "/*.yml"]
 I18n.default_locale = :en # (note that `en` is already the default!)
 ```
 

data/lib/i18n/backend/base.rb

@@ -54,19 +54,22 @@ module I18n
         end
 
         deep_interpolation = options[:deep_interpolation]
-        values = Utils.except(options, *RESERVED_KEYS)
-        if values
+        skip_interpolation = options[:skip_interpolation]
+        values = Utils.except(options, *RESERVED_KEYS) unless options.empty?
+        if !skip_interpolation && values && !values.empty?
           entry = if deep_interpolation
             deep_interpolate(locale, entry, values)
           else
             interpolate(locale, entry, values)
           end
+        elsif entry.is_a?(String) && entry =~ I18n.reserved_keys_pattern
+          raise ReservedInterpolationKey.new($1.to_sym, entry)
         end
         entry
       end
 
       def exists?(locale, key, options = EMPTY_HASH)
-        lookup(locale, key) != nil
+        lookup(locale, key, options[:scope]) != nil
       end
 
       # Acts the same as +strftime+, but uses a localized version of the
@@ -123,7 +126,12 @@ module I18n
         # first translation that can be resolved. Otherwise it tries to resolve
         # the translation directly.
         def default(locale, object, subject, options = EMPTY_HASH)
-          options = options.reject { |key, value| key == :default }
+          if options.size == 1 && options.has_key?(:default)
+            options = {}
+          else
+            options = Utils.except(options, :default)
+          end
+
           case subject
           when Array
             subject.each do |item|
@@ -144,7 +152,14 @@ module I18n
           result = catch(:exception) do
             case subject
             when Symbol
-              I18n.translate(subject, **options.merge(:locale => locale, :throw => true))
+              I18n.translate(
+                subject,
+                **options.merge(
+                  :locale => locale,
+                  :throw => true,
+                  :skip_interpolation => true
+                )
+              )
             when Proc
               date_or_time = options.delete(:object) || object
               resolve(locale, object, subject.call(date_or_time, **options))
@@ -166,7 +181,7 @@ module I18n
         # Other backends can implement more flexible or complex pluralization rules.
         def pluralize(locale, entry, count)
           entry = entry.reject { |k, _v| k == :attributes } if entry.is_a?(Hash)
-          return entry unless entry.is_a?(Hash) && count && entry.values.none? { |v| v.is_a?(Hash) }
+          return entry unless entry.is_a?(Hash) && count
 
           key = pluralization_key(entry, count)
           raise InvalidPluralizationData.new(entry, count, key) unless entry.has_key?(key)
@@ -181,8 +196,8 @@ module I18n
         #
         #   if the given subject is an array then:
         #   each element of the array is recursively interpolated (until it finds a string)
-        #   method interpolates ["yes, %{user}", ["maybe no, %{user}, "no, %{user}"]], :user => "bartuz"
-        #   # => "["yes, bartuz",["maybe no, bartuz", "no, bartuz"]]"
+        #   method interpolates ["yes, %{user}", ["maybe no, %{user}", "no, %{user}"]], :user => "bartuz"
+        #   # => ["yes, bartuz", ["maybe no, bartuz", "no, bartuz"]]
         def interpolate(locale, subject, values = EMPTY_HASH)
           return subject if values.empty?
 
@@ -237,7 +252,7 @@ module I18n
         # 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)
-          translations = eval(IO.read(filename), binding, filename)
+          translations = eval(IO.read(filename), binding, filename.to_s)
           [translations, false]
         end
 
@@ -282,8 +297,8 @@ module I18n
             when '%^b' then I18n.t!(:"date.abbr_month_names",               :locale => locale, :format => format)[object.mon].upcase
             when '%B' then I18n.t!(:"date.month_names",                     :locale => locale, :format => format)[object.mon]
             when '%^B' then I18n.t!(:"date.month_names",                    :locale => locale, :format => format)[object.mon].upcase
-            when '%p' then I18n.t!(:"time.#{object.hour < 12 ? :am : :pm}", :locale => locale, :format => format).upcase if object.respond_to? :hour
-            when '%P' then I18n.t!(:"time.#{object.hour < 12 ? :am : :pm}", :locale => locale, :format => format).downcase if object.respond_to? :hour
+            when '%p' then I18n.t!(:"time.#{(object.respond_to?(:hour) ? object.hour : 0) < 12 ? :am : :pm}", :locale => locale, :format => format).upcase
+            when '%P' then I18n.t!(:"time.#{(object.respond_to?(:hour) ? object.hour : 0) < 12 ? :am : :pm}", :locale => locale, :format => format).downcase
             end
           end
         rescue MissingTranslationData => e

data/lib/i18n/backend/chain.rb

@@ -16,6 +16,8 @@ module I18n
     #
     # The implementation assumes that all backends added to the Chain implement
     # a lookup method with the same API as Simple backend does.
+    # 
+    # Fallback translations using the :default option are only used by the last backend of a chain.
     class Chain
       module Implementation
         include Base

data/lib/i18n/backend/fallbacks.rb

@@ -71,7 +71,11 @@ module I18n
 
           case subject
           when Symbol
-            I18n.translate(subject, **options.merge(:locale => options[:fallback_original_locale], :throw => true))
+            I18n.translate(subject, **options.merge(
+              :locale => options[:fallback_original_locale],
+              :throw => true,
+              :skip_interpolation => true
+            ))
           when Proc
             date_or_time = options.delete(:object) || object
             resolve_entry(options[:fallback_original_locale], object, subject.call(date_or_time, **options))
@@ -95,7 +99,7 @@ module I18n
         return super unless options.fetch(:fallback, true)
         I18n.fallbacks[locale].each do |fallback|
           begin
-            return true if super(fallback, key)
+            return true if super(fallback, key, options)
           rescue I18n::InvalidLocale
             # we do nothing when the locale is invalid, as this is a fallback anyways.
           end

data/lib/i18n/backend/interpolation_compiler.rb

@@ -21,11 +21,11 @@ module I18n
       module Compiler
         extend self
 
-        TOKENIZER                    = /(%%\{[^\}]+\}|%\{[^\}]+\})/
-        INTERPOLATION_SYNTAX_PATTERN = /(%)?(%\{([^\}]+)\})/
+        TOKENIZER = /(%%?\{[^}]+\})/
 
         def compile_if_an_interpolation(string)
           if interpolated_str?(string)
+            string = +string
             string.instance_eval <<-RUBY_EVAL, __FILE__, __LINE__
               def i18n_interpolate(v = {})
                 "#{compiled_interpolation_body(string)}"
@@ -37,7 +37,7 @@ module I18n
         end
 
         def interpolated_str?(str)
-          str.kind_of?(::String) && str =~ INTERPOLATION_SYNTAX_PATTERN
+          str.kind_of?(::String) && str =~ TOKENIZER
         end
 
         protected
@@ -48,13 +48,12 @@ module I18n
 
         def compiled_interpolation_body(str)
           tokenize(str).map do |token|
-            (matchdata = token.match(INTERPOLATION_SYNTAX_PATTERN)) ? handle_interpolation_token(token, matchdata) : escape_plain_str(token)
+            token.match(TOKENIZER) ? handle_interpolation_token(token) : escape_plain_str(token)
           end.join
         end
 
-        def handle_interpolation_token(interpolation, matchdata)
-          escaped, pattern, key = matchdata.values_at(1, 2, 3)
-          escaped ? pattern : compile_interpolation_token(key.to_sym)
+        def handle_interpolation_token(token)
+          token.start_with?('%%') ? token[1..] : compile_interpolation_token(token[2..-2])
         end
 
         def compile_interpolation_token(key)

data/lib/i18n/backend/lazy_loadable.rb

@@ -98,7 +98,7 @@ module I18n
       # Parse the load path and extract all locales.
       def available_locales
         if lazy_load?
-          I18n.load_path.map { |path| LocaleExtractor.locale_from_path(path) }
+          I18n.load_path.map { |path| LocaleExtractor.locale_from_path(path) }.uniq
         else
           super
         end

data/lib/i18n/backend/pluralization.rb

@@ -16,26 +16,57 @@ module I18n
     module Pluralization
       # Overwrites the Base backend translate method so that it will check the
       # translation meta data space (:i18n) for a locale specific pluralization
-      # rule and use it to pluralize the given entry. I.e. the library expects
+      # rule and use it to pluralize the given entry. I.e., the library expects
       # pluralization rules to be stored at I18n.t(:'i18n.plural.rule')
       #
       # Pluralization rules are expected to respond to #call(count) and
-      # return a pluralization key. Valid keys depend on the translation data
-      # hash (entry) but it is generally recommended to follow CLDR's style,
-      # i.e., return one of the keys :zero, :one, :few, :many, :other.
+      # return a pluralization key. Valid keys depend on the pluralization
+      # rules for the locale, as defined in the CLDR.
+      # As of v41, 6 locale-specific plural categories are defined:
+      #   :few, :many, :one, :other, :two, :zero
       #
-      # The :zero key is always picked directly when count equals 0 AND the
-      # translation data has the key :zero. This way translators are free to
-      # either pick a special :zero translation even for languages where the
-      # pluralizer does not return a :zero key.
+      # n.b., The :one plural category does not imply the number 1.
+      # Instead, :one is a category for any number that behaves like 1 in
+      # that locale. For example, in some locales, :one is used for numbers
+      # that end in "1" (like 1, 21, 151) but that don't end in
+      # 11 (like 11, 111, 10311).
+      # Similar notes apply to the :two, and :zero plural categories.
+      #
+      # If you want to have different strings for the categories of count == 0
+      # (e.g. "I don't have any cars") or count == 1 (e.g. "I have a single car")
+      # use the explicit `"0"` and `"1"` keys.
+      # https://unicode-org.github.io/cldr/ldml/tr35-numbers.html#Explicit_0_1_rules
       def pluralize(locale, entry, count)
         return entry unless entry.is_a?(Hash) && count
 
         pluralizer = pluralizer(locale)
         if pluralizer.respond_to?(:call)
-          key = count == 0 && entry.has_key?(:zero) ? :zero : pluralizer.call(count)
-          raise InvalidPluralizationData.new(entry, count, key) unless entry.has_key?(key)
-          entry[key]
+          # Deprecation: The use of the `zero` key in this way is incorrect.
+          # Users that want a different string for the case of `count == 0` should use the explicit "0" key instead.
+          # We keep this incorrect behaviour for now for backwards compatibility until we can remove it.
+          # Ref: https://github.com/ruby-i18n/i18n/issues/629
+          return entry[:zero] if count == 0 && entry.has_key?(:zero)
+
+          # "0" and "1" are special cases
+          # https://unicode-org.github.io/cldr/ldml/tr35-numbers.html#Explicit_0_1_rules
+          if count == 0 || count == 1
+            value = entry[symbolic_count(count)]
+            return value if value
+          end
+
+          # Lateral Inheritance of "count" attribute (http://www.unicode.org/reports/tr35/#Lateral_Inheritance):
+          # > If there is no value for a path, and that path has a [@count="x"] attribute and value, then:
+          # > 1. If "x" is numeric, the path falls back to the path with [@count=«the plural rules category for x for that locale»], within that the same locale.
+          # > 2. If "x" is anything but "other", it falls back to a path [@count="other"], within that the same locale.
+          # > 3. If "x" is "other", it falls back to the path that is completely missing the count item, within that the same locale.
+          # Note: We don't yet implement #3 above, since we haven't decided how lateral inheritance attributes should be represented.
+          plural_rule_category = pluralizer.call(count)
+
+          value = if entry.has_key?(plural_rule_category) || entry.has_key?(:other)
+            entry[plural_rule_category] || entry[:other]
+          else
+            raise InvalidPluralizationData.new(entry, count, plural_rule_category)
+          end
         else
           super
         end
@@ -43,13 +74,23 @@ module I18n
 
       protected
 
-        def pluralizers
-          @pluralizers ||= {}
-        end
+      def pluralizers
+        @pluralizers ||= {}
+      end
 
-        def pluralizer(locale)
-          pluralizers[locale] ||= I18n.t(:'i18n.plural.rule', :locale => locale, :resolve => false)
-        end
+      def pluralizer(locale)
+        pluralizers[locale] ||= I18n.t(:'i18n.plural.rule', :locale => locale, :resolve => false)
+      end
+
+      private
+
+      # Normalizes categories of 0.0 and 1.0
+      # and returns the symbolic version
+      def symbolic_count(count)
+        count = 0 if count == 0
+        count = 1 if count == 1
+        count.to_s.to_sym
+      end
     end
   end
 end

data/lib/i18n/backend/simple.rb

@@ -10,17 +10,20 @@ module I18n
     # The implementation is provided by a Implementation module allowing to easily
     # extend Simple backend's behavior by including modules. E.g.:
     #
-    # module I18n::Backend::Pluralization
-    #   def pluralize(*args)
-    #     # extended pluralization logic
-    #     super
-    #   end
-    # end
-    #
-    # I18n::Backend::Simple.include(I18n::Backend::Pluralization)
+    #     module I18n::Backend::Pluralization
+    #       def pluralize(*args)
+    #         # extended pluralization logic
+    #         super
+    #       end
+    #     end
+    #     
+    #     I18n::Backend::Simple.include(I18n::Backend::Pluralization)
     class Simple
       module Implementation
         include Base
+        
+        # Mutex to ensure that concurrent translations loading will be thread-safe
+        MUTEX = Mutex.new
 
         def initialized?
           @initialized ||= false
@@ -68,7 +71,11 @@ module I18n
           # call `init_translations`
           init_translations if do_init && !initialized?
 
-          @translations ||= Concurrent::Hash.new { |h, k| h[k] = Concurrent::Hash.new }
+          @translations ||= Concurrent::Hash.new do |h, k|
+            MUTEX.synchronize do
+              h[k] = Concurrent::Hash.new
+            end
+          end
         end
 
       protected
@@ -94,7 +101,7 @@ module I18n
               return nil unless result.has_key?(_key)
             end
             result = result[_key]
-            result = resolve_entry(locale, _key, result, options.merge(:scope => nil)) if result.is_a?(Symbol)
+            result = resolve_entry(locale, _key, result, Utils.except(options.merge(:scope => nil), :count)) if result.is_a?(Symbol)
             result
           end
         end

data/lib/i18n/backend/transliterator.rb

@@ -45,30 +45,30 @@ module I18n
           "Ç"=>"C", "È"=>"E", "É"=>"E", "Ê"=>"E", "Ë"=>"E", "Ì"=>"I", "Í"=>"I",
           "Î"=>"I", "Ï"=>"I", "Ð"=>"D", "Ñ"=>"N", "Ò"=>"O", "Ó"=>"O", "Ô"=>"O",
           "Õ"=>"O", "Ö"=>"O", "×"=>"x", "Ø"=>"O", "Ù"=>"U", "Ú"=>"U", "Û"=>"U",
-          "Ü"=>"U", "Ý"=>"Y", "Þ"=>"Th", "ß"=>"ss", "à"=>"a", "á"=>"a", "â"=>"a",
-          "ã"=>"a", "ä"=>"a", "å"=>"a", "æ"=>"ae", "ç"=>"c", "è"=>"e", "é"=>"e",
-          "ê"=>"e", "ë"=>"e", "ì"=>"i", "í"=>"i", "î"=>"i", "ï"=>"i", "ð"=>"d",
-          "ñ"=>"n", "ò"=>"o", "ó"=>"o", "ô"=>"o", "õ"=>"o", "ö"=>"o", "ø"=>"o",
-          "ù"=>"u", "ú"=>"u", "û"=>"u", "ü"=>"u", "ý"=>"y", "þ"=>"th", "ÿ"=>"y",
-          "Ā"=>"A", "ā"=>"a", "Ă"=>"A", "ă"=>"a", "Ą"=>"A", "ą"=>"a", "Ć"=>"C",
-          "ć"=>"c", "Ĉ"=>"C", "ĉ"=>"c", "Ċ"=>"C", "ċ"=>"c", "Č"=>"C", "č"=>"c",
-          "Ď"=>"D", "ď"=>"d", "Đ"=>"D", "đ"=>"d", "Ē"=>"E", "ē"=>"e", "Ĕ"=>"E",
-          "ĕ"=>"e", "Ė"=>"E", "ė"=>"e", "Ę"=>"E", "ę"=>"e", "Ě"=>"E", "ě"=>"e",
-          "Ĝ"=>"G", "ĝ"=>"g", "Ğ"=>"G", "ğ"=>"g", "Ġ"=>"G", "ġ"=>"g", "Ģ"=>"G",
-          "ģ"=>"g", "Ĥ"=>"H", "ĥ"=>"h", "Ħ"=>"H", "ħ"=>"h", "Ĩ"=>"I", "ĩ"=>"i",
-          "Ī"=>"I", "ī"=>"i", "Ĭ"=>"I", "ĭ"=>"i", "Į"=>"I", "į"=>"i", "İ"=>"I",
-          "ı"=>"i", "IJ"=>"IJ", "ij"=>"ij", "Ĵ"=>"J", "ĵ"=>"j", "Ķ"=>"K", "ķ"=>"k",
-          "ĸ"=>"k", "Ĺ"=>"L", "ĺ"=>"l", "Ļ"=>"L", "ļ"=>"l", "Ľ"=>"L", "ľ"=>"l",
-          "Ŀ"=>"L", "ŀ"=>"l", "Ł"=>"L", "ł"=>"l", "Ń"=>"N", "ń"=>"n", "Ņ"=>"N",
-          "ņ"=>"n", "Ň"=>"N", "ň"=>"n", "ʼn"=>"'n", "Ŋ"=>"NG", "ŋ"=>"ng",
-          "Ō"=>"O", "ō"=>"o", "Ŏ"=>"O", "ŏ"=>"o", "Ő"=>"O", "ő"=>"o", "Œ"=>"OE",
-          "œ"=>"oe", "Ŕ"=>"R", "ŕ"=>"r", "Ŗ"=>"R", "ŗ"=>"r", "Ř"=>"R", "ř"=>"r",
-          "Ś"=>"S", "ś"=>"s", "Ŝ"=>"S", "ŝ"=>"s", "Ş"=>"S", "ş"=>"s", "Š"=>"S",
-          "š"=>"s", "Ţ"=>"T", "ţ"=>"t", "Ť"=>"T", "ť"=>"t", "Ŧ"=>"T", "ŧ"=>"t",
-          "Ũ"=>"U", "ũ"=>"u", "Ū"=>"U", "ū"=>"u", "Ŭ"=>"U", "ŭ"=>"u", "Ů"=>"U",
-          "ů"=>"u", "Ű"=>"U", "ű"=>"u", "Ų"=>"U", "ų"=>"u", "Ŵ"=>"W", "ŵ"=>"w",
-          "Ŷ"=>"Y", "ŷ"=>"y", "Ÿ"=>"Y", "Ź"=>"Z", "ź"=>"z", "Ż"=>"Z", "ż"=>"z",
-          "Ž"=>"Z", "ž"=>"z"
+          "Ü"=>"U", "Ý"=>"Y", "Þ"=>"Th", "ß"=>"ss", "ẞ"=>"SS", "à"=>"a",
+          "á"=>"a", "â"=>"a", "ã"=>"a", "ä"=>"a", "å"=>"a", "æ"=>"ae", "ç"=>"c",
+          "è"=>"e", "é"=>"e", "ê"=>"e", "ë"=>"e", "ì"=>"i", "í"=>"i", "î"=>"i",
+          "ï"=>"i", "ð"=>"d", "ñ"=>"n", "ò"=>"o", "ó"=>"o", "ô"=>"o", "õ"=>"o",
+          "ö"=>"o", "ø"=>"o", "ù"=>"u", "ú"=>"u", "û"=>"u", "ü"=>"u", "ý"=>"y",
+          "þ"=>"th", "ÿ"=>"y", "Ā"=>"A", "ā"=>"a", "Ă"=>"A", "ă"=>"a", "Ą"=>"A",
+          "ą"=>"a", "Ć"=>"C", "ć"=>"c", "Ĉ"=>"C", "ĉ"=>"c", "Ċ"=>"C", "ċ"=>"c",
+          "Č"=>"C", "č"=>"c", "Ď"=>"D", "ď"=>"d", "Đ"=>"D", "đ"=>"d", "Ē"=>"E",
+          "ē"=>"e", "Ĕ"=>"E", "ĕ"=>"e", "Ė"=>"E", "ė"=>"e", "Ę"=>"E", "ę"=>"e",
+          "Ě"=>"E", "ě"=>"e", "Ĝ"=>"G", "ĝ"=>"g", "Ğ"=>"G", "ğ"=>"g", "Ġ"=>"G",
+          "ġ"=>"g", "Ģ"=>"G", "ģ"=>"g", "Ĥ"=>"H", "ĥ"=>"h", "Ħ"=>"H", "ħ"=>"h",
+          "Ĩ"=>"I", "ĩ"=>"i", "Ī"=>"I", "ī"=>"i", "Ĭ"=>"I", "ĭ"=>"i", "Į"=>"I",
+          "į"=>"i", "İ"=>"I", "ı"=>"i", "IJ"=>"IJ", "ij"=>"ij", "Ĵ"=>"J", "ĵ"=>"j",
+          "Ķ"=>"K", "ķ"=>"k", "ĸ"=>"k", "Ĺ"=>"L", "ĺ"=>"l", "Ļ"=>"L", "ļ"=>"l",
+          "Ľ"=>"L", "ľ"=>"l", "Ŀ"=>"L", "ŀ"=>"l", "Ł"=>"L", "ł"=>"l", "Ń"=>"N",
+          "ń"=>"n", "Ņ"=>"N", "ņ"=>"n", "Ň"=>"N", "ň"=>"n", "ʼn"=>"'n", "Ŋ"=>"NG",
+          "ŋ"=>"ng", "Ō"=>"O", "ō"=>"o", "Ŏ"=>"O", "ŏ"=>"o", "Ő"=>"O", "ő"=>"o",
+          "Œ"=>"OE", "œ"=>"oe", "Ŕ"=>"R", "ŕ"=>"r", "Ŗ"=>"R", "ŗ"=>"r", "Ř"=>"R",
+          "ř"=>"r", "Ś"=>"S", "ś"=>"s", "Ŝ"=>"S", "ŝ"=>"s", "Ş"=>"S", "ş"=>"s",
+          "Š"=>"S", "š"=>"s", "Ţ"=>"T", "ţ"=>"t", "Ť"=>"T", "ť"=>"t", "Ŧ"=>"T",
+          "ŧ"=>"t", "Ũ"=>"U", "ũ"=>"u", "Ū"=>"U", "ū"=>"u", "Ŭ"=>"U", "ŭ"=>"u",
+          "Ů"=>"U", "ů"=>"u", "Ű"=>"U", "ű"=>"u", "Ų"=>"U", "ų"=>"u", "Ŵ"=>"W",
+          "ŵ"=>"w", "Ŷ"=>"Y", "ŷ"=>"y", "Ÿ"=>"Y", "Ź"=>"Z", "ź"=>"z", "Ż"=>"Z",
+          "ż"=>"z", "Ž"=>"Z", "ž"=>"z"
         }.freeze
 
         def initialize(rule = nil)

data/lib/i18n/exceptions.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'cgi'
-
 module I18n
   class ExceptionHandler
     def call(exception, _locale, _key, _options)
@@ -47,7 +45,7 @@ module I18n
 
   class MissingTranslation < ArgumentError
     module Base
-      PERMITTED_KEYS = [:scope].freeze
+      PERMITTED_KEYS = [:scope, :default].freeze
 
       attr_reader :locale, :key, :options
 
@@ -63,8 +61,18 @@ module I18n
       end
 
       def message
-        "translation missing: #{keys.join('.')}"
+        if (default = options[:default]).is_a?(Array) && default.any?
+          other_options = ([key, *default]).map { |k| normalized_option(k).prepend('- ') }.join("\n")
+          "Translation missing. Options considered were:\n#{other_options}"
+        else
+          "Translation missing: #{keys.join('.')}"
+        end
       end
+
+      def normalized_option(key)
+        I18n.normalize_keys(locale, key, options[:scope]).join('.')
+      end
+
       alias :to_s :message
 
       def to_exception

data/lib/i18n/interpolate/ruby.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # heavily based on Masao Mutoh's gettext String interpolation extension
 # http://github.com/mutoh/gettext/blob/f6566738b981fe0952548c421042ad1e0cdfb31e/lib/gettext/core_ext/string.rb
 
@@ -10,6 +12,11 @@ module I18n
   INTERPOLATION_PATTERN = Regexp.union(DEFAULT_INTERPOLATION_PATTERNS)
   deprecate_constant :INTERPOLATION_PATTERN
 
+  INTERPOLATION_PATTERNS_CACHE = Hash.new do |hash, patterns|
+    hash[patterns] = Regexp.union(patterns)
+  end
+  private_constant :INTERPOLATION_PATTERNS_CACHE
+
   class << self
     # Return String or raises MissingInterpolationArgument exception.
     # Missing argument's logic is handled by I18n.config.missing_interpolation_argument_handler.
@@ -20,7 +27,12 @@ module I18n
     end
 
     def interpolate_hash(string, values)
-      string.gsub(Regexp.union(config.interpolation_patterns)) do |match|
+      pattern = INTERPOLATION_PATTERNS_CACHE[config.interpolation_patterns]
+      interpolated = false
+
+      interpolated_string = string.gsub(pattern) do |match|
+        interpolated = true
+
         if match == '%%'
           '%'
         else
@@ -34,6 +46,8 @@ module I18n
           $3 ? sprintf("%#{$3}", value) : value
         end
       end
+
+      interpolated ? interpolated_string : string
     end
   end
 end

data/lib/i18n/locale/fallbacks.rb

@@ -79,14 +79,24 @@ module I18n
         end
       end
 
+      def empty?
+        @map.empty? && @defaults.empty?
+      end
+
+      def inspect
+       "#<#{self.class.name} @map=#{@map.inspect} @defaults=#{@defaults.inspect}>"
+      end
+
       protected
 
       def compute(tags, include_defaults = true, exclude = [])
-        result = Array(tags).flat_map do |tag|
+        result = []
+        Array(tags).each do |tag|
           tags = I18n::Locale::Tag.tag(tag).self_and_parents.map! { |t| t.to_sym } - exclude
-          tags.each { |_tag| tags += compute(@map[_tag], false, exclude + tags) if @map[_tag] }
-          tags
+          result += tags
+          tags.each { |_tag| result += compute(@map[_tag], false, exclude + result) if @map[_tag] }
         end
+
         result.push(*defaults) if include_defaults
         result.uniq!
         result.compact!

data/lib/i18n/middleware.rb

@@ -10,7 +10,7 @@ module I18n
     def call(env)
       @app.call(env)
     ensure
-      Thread.current[:i18n_config] = I18n::Config.new
+      Thread.current.thread_variable_set(:i18n_config, I18n::Config.new)
     end
 
   end

data/lib/i18n/tests/defaults.rb

@@ -47,6 +47,13 @@ module I18n
         I18n.backend.store_translations(:en, { :foo => { :bar => 'bar' } }, { :separator => '|' })
         assert_equal 'bar', I18n.t(nil, :default => :'foo|bar', :separator => '|')
       end
+
+      # Addresses issue: #599
+      test "defaults: only interpolates once when resolving defaults" do
+        I18n.backend.store_translations(:en, :greeting => 'hey %{name}')
+        assert_equal 'hey %{dont_interpolate_me}',
+          I18n.t(:does_not_exist, :name => '%{dont_interpolate_me}', default: [:greeting])
+      end
     end
   end
 end

data/lib/i18n/tests/interpolation.rb

@@ -89,14 +89,14 @@ module I18n
         end
 
         test "interpolation: ASCII strings in the backend should be encoded to UTF8 if interpolation options are in UTF8" do
-          I18n.backend.store_translations 'en', 'encoding' => ('%{who} let me go'.force_encoding("ASCII"))
+          I18n.backend.store_translations 'en', 'encoding' => ('%{who} let me go'.dup.force_encoding(Encoding::US_ASCII))
           result = I18n.t 'encoding', :who => "måmmå miå"
           assert_equal Encoding::UTF_8, result.encoding
         end
 
         test "interpolation: UTF8 strings in the backend are still returned as UTF8 with ASCII interpolation" do
           I18n.backend.store_translations 'en', 'encoding' => 'måmmå miå %{what}'
-          result = I18n.t 'encoding', :what => 'let me go'.force_encoding("ASCII")
+          result = I18n.t 'encoding', :what => 'let me go'.dup.force_encoding(Encoding::US_ASCII)
           assert_equal Encoding::UTF_8, result.encoding
         end
 
@@ -112,6 +112,28 @@ module I18n
         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}') }
+        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '%{scope}') }
+
+        I18n.backend.store_translations(:en, :interpolate => 'Hi %{scope}!')
+        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:interpolate) }
+      end
+
+      test "interpolation: it does not raise I18n::ReservedInterpolationKey for escaped variables" do
+        assert_nothing_raised do
+          assert_equal '%{separator}', interpolate(:foo => :bar, :default => '%%{separator}')
+        end
+
+        # Note: The two interpolations below do not remove the escape character (%) because
+        #   I18n should not alter the strings when no interpolation parameters are given,
+        #   see the comment at the top of this file.
+        assert_nothing_raised do
+          assert_equal '%%{scope}', interpolate(:default => '%%{scope}')
+        end
+
+        I18n.backend.store_translations(:en, :interpolate => 'Hi %%{scope}!')
+        assert_nothing_raised do
+          assert_equal 'Hi %%{scope}!', interpolate(:interpolate)
+        end
       end
 
       test "interpolation: deep interpolation for default string" do
@@ -150,7 +172,7 @@ module I18n
       end
 
       def euc_jp(string)
-        string.encode!(Encoding::EUC_JP)
+        string.encode(Encoding::EUC_JP)
       end
 
       def interpolate(*args)

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

@@ -34,6 +34,11 @@ module I18n
           assert_equal 'Sa', I18n.l(@date, :format => '%a', :locale => :de)
         end
 
+        test "localize Date: given an meridian indicator format it returns the correct meridian indicator" do
+          assert_equal 'AM', I18n.l(@date, :format => '%p', :locale => :de)
+          assert_equal 'am', I18n.l(@date, :format => '%P', :locale => :de)
+        end
+
         test "localize Date: given an abbreviated and uppercased day name format it returns the correct abbreviated day name in upcase" do
           assert_equal 'sa'.upcase, I18n.l(@date, :format => '%^a', :locale => :de)
         end
@@ -59,7 +64,7 @@ module I18n
         end
 
         test "localize Date: given missing translations it returns the correct error message" do
-          assert_equal 'translation missing: fr.date.abbr_month_names', I18n.l(@date, :format => '%b', :locale => :fr)
+          assert_equal 'Translation missing: fr.date.abbr_month_names', I18n.l(@date, :format => '%b', :locale => :fr)
         end
 
         test "localize Date: given an unknown format it does not fail" do

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

@@ -60,7 +60,7 @@ module I18n
         end
 
         test "localize DateTime: given missing translations it returns the correct error message" do
-          assert_equal 'translation missing: fr.date.abbr_month_names', I18n.l(@datetime, :format => '%b', :locale => :fr)
+          assert_equal 'Translation missing: fr.date.abbr_month_names', I18n.l(@datetime, :format => '%b', :locale => :fr)
         end
 
         test "localize DateTime: given a meridian indicator format it returns the correct meridian indicator" do

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

@@ -34,7 +34,7 @@ module I18n
         test "localize Date: given a format that resolves to a Proc it calls the Proc with the object and extra options" do
           setup_time_proc_translations
           date = ::Date.new(2008, 3, 1)
-          assert_equal '[Sat, 01 Mar 2008, {:foo=>"foo"}]', I18n.l(date, :format => :proc, :foo => 'foo', :locale => :ru)
+          assert_equal %|[Sat, 01 Mar 2008, #{{:foo=>"foo"}}]|, I18n.l(date, :format => :proc, :foo => 'foo', :locale => :ru)
         end
 
         test "localize DateTime: given a format that resolves to a Proc it calls the Proc with the object" do
@@ -46,7 +46,7 @@ module I18n
         test "localize DateTime: given a format that resolves to a Proc it calls the Proc with the object and extra options" do
           setup_time_proc_translations
           datetime = ::DateTime.new(2008, 3, 1, 6)
-          assert_equal '[Sat, 01 Mar 2008 06:00:00 +00:00, {:foo=>"foo"}]', I18n.l(datetime, :format => :proc, :foo => 'foo', :locale => :ru)
+          assert_equal %|[Sat, 01 Mar 2008 06:00:00 +00:00, #{{:foo=>"foo"}}]|, I18n.l(datetime, :format => :proc, :foo => 'foo', :locale => :ru)
         end
 
         test "localize Time: given a format that resolves to a Proc it calls the Proc with the object" do

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

@@ -61,7 +61,7 @@ module I18n
         end
 
         test "localize Time: given missing translations it returns the correct error message" do
-          assert_equal 'translation missing: fr.date.abbr_month_names', I18n.l(@time, :format => '%b', :locale => :fr)
+          assert_equal 'Translation missing: fr.date.abbr_month_names', I18n.l(@time, :format => '%b', :locale => :fr)
         end
 
         test "localize Time: given a meridian indicator format it returns the correct meridian indicator" do

data/lib/i18n/tests/lookup.rb

@@ -30,7 +30,7 @@ module I18n
       end
 
       test "lookup: given a missing key, no default and no raise option it returns an error message" do
-        assert_equal "translation missing: en.missing", I18n.t(:missing)
+        assert_equal "Translation missing: en.missing", I18n.t(:missing)
       end
 
       test "lookup: given a missing key, no default and the raise option it raises MissingTranslationData" do
@@ -76,6 +76,12 @@ module I18n
       test "lookup: a resulting Hash is not frozen" do
         assert !I18n.t(:hash).frozen?
       end
+
+      # Addresses issue: #599
+      test "lookup: only interpolates once when resolving symbols" do
+        I18n.backend.store_translations(:en, foo: :bar, bar: '%{value}')
+        assert_equal '%{dont_interpolate_me}', I18n.t(:foo, value: '%{dont_interpolate_me}')
+      end
     end
   end
 end

data/lib/i18n/tests/procs.rb

@@ -5,34 +5,38 @@ module I18n
     module Procs
       test "lookup: given a translation is a proc it calls the proc with the key and interpolation values" do
         I18n.backend.store_translations(:en, :a_lambda => lambda { |*args| I18n::Tests::Procs.filter_args(*args) })
-        assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(:a_lambda, :foo => 'foo')
+        assert_equal %|[:a_lambda, #{{:foo=>"foo"}}]|, I18n.t(:a_lambda, :foo => 'foo')
       end
 
       test "lookup: given a translation is a proc it passes the interpolation values as keyword arguments" do
         I18n.backend.store_translations(:en, :a_lambda => lambda { |key, foo:, **| I18n::Tests::Procs.filter_args(key, foo: foo) })
-        assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(:a_lambda, :foo => 'foo')
+        assert_equal %|[:a_lambda, #{{:foo=>"foo"}}]|, I18n.t(:a_lambda, :foo => 'foo')
       end
 
       test "defaults: given a default is a Proc it calls it with the key and interpolation values" do
         proc = lambda { |*args| I18n::Tests::Procs.filter_args(*args) }
-        assert_equal '[nil, {:foo=>"foo"}]', I18n.t(nil, :default => proc, :foo => 'foo')
+        assert_equal %|[nil, #{{:foo=>"foo"}}]|, I18n.t(nil, :default => proc, :foo => 'foo')
       end
 
       test "defaults: given a default is a key that resolves to a Proc it calls it with the key and interpolation values" do
         the_lambda = lambda { |*args| I18n::Tests::Procs.filter_args(*args) }
         I18n.backend.store_translations(:en, :a_lambda => the_lambda)
-        assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(nil, :default => :a_lambda, :foo => 'foo')
-        assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(nil, :default => [nil, :a_lambda], :foo => 'foo')
+        assert_equal %|[:a_lambda, #{{:foo=>"foo"}}]|, I18n.t(nil, :default => :a_lambda, :foo => 'foo')
+        assert_equal %|[:a_lambda, #{{:foo=>"foo"}}]|, I18n.t(nil, :default => [nil, :a_lambda], :foo => 'foo')
       end
 
       test "interpolation: given an interpolation value is a lambda it calls it with key and values before interpolating it" do
         proc = lambda { |*args| I18n::Tests::Procs.filter_args(*args) }
-        assert_match %r(\[\{:foo=>#<Proc.*>\}\]), I18n.t(nil, :default => '%{foo}', :foo => proc)
+        if RUBY_VERSION < "3.4"
+          assert_match %r(\[\{:foo=>#<Proc.*>\}\]), I18n.t(nil, :default => '%{foo}', :foo => proc)
+        else
+          assert_match %r(\[\{foo: #<Proc.*>\}\]), I18n.t(nil, :default => '%{foo}', :foo => proc)
+        end
       end
 
       test "interpolation: given a key resolves to a Proc that returns a string then interpolation still works" do
         proc = lambda { |*args| "%{foo}: " + I18n::Tests::Procs.filter_args(*args) }
-        assert_equal 'foo: [nil, {:foo=>"foo"}]', I18n.t(nil, :default => proc, :foo => 'foo')
+        assert_equal %|foo: [nil, #{{:foo=>"foo"}}]|, I18n.t(nil, :default => proc, :foo => 'foo')
       end
 
       test "pluralization: given a key resolves to a Proc that returns valid data then pluralization still works" do
@@ -57,6 +61,7 @@ module I18n
           if arg.is_a?(Hash)
             arg.delete(:fallback_in_progress)
             arg.delete(:fallback_original_locale)
+            arg.delete(:skip_interpolation)
           end
           arg
         end.inspect

data/lib/i18n/version.rb

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

data/lib/i18n.rb

@@ -19,6 +19,7 @@ module I18n
   RESERVED_KEYS = %i[
     cascade
     deep_interpolation
+    skip_interpolation
     default
     exception_handler
     fallback
@@ -48,18 +49,19 @@ module I18n
   end
 
   def self.reserved_keys_pattern # :nodoc:
-    @reserved_keys_pattern ||= /%\{(#{RESERVED_KEYS.join("|")})\}/
+    @reserved_keys_pattern ||= /(?<!%)%\{(#{RESERVED_KEYS.join("|")})\}/
   end
 
   module Base
     # Gets I18n configuration object.
     def config
-      Thread.current[:i18n_config] ||= I18n::Config.new
+      Thread.current.thread_variable_get(:i18n_config) ||
+        Thread.current.thread_variable_set(:i18n_config, I18n::Config.new)
     end
 
     # Sets I18n configuration object.
     def config=(value)
-      Thread.current[:i18n_config] = value
+      Thread.current.thread_variable_set(:i18n_config, value)
     end
 
     # Write methods which delegates to the configuration object
@@ -161,7 +163,7 @@ module I18n
     # or <tt>default</tt> if no translations for <tt>:foo</tt> and <tt>:bar</tt> were found.
     #   I18n.t :foo, :default => [:bar, 'default']
     #
-    # *BULK LOOKUP*
+    # <b>BULK LOOKUP</b>
     #
     # This returns an array with the translations for <tt>:foo</tt> and <tt>:bar</tt>.
     #   I18n.t [:foo, :bar]
@@ -180,7 +182,7 @@ module I18n
     # E.g. assuming the key <tt>:salutation</tt> resolves to:
     #   lambda { |key, options| options[:gender] == 'm' ? "Mr. #{options[:name]}" : "Mrs. #{options[:name]}" }
     #
-    # Then <tt>I18n.t(:salutation, :gender => 'w', :name => 'Smith') will result in "Mrs. Smith".
+    # Then <tt>I18n.t(:salutation, :gender => 'w', :name => 'Smith')</tt> will result in "Mrs. Smith".
     #
     # Note that the string returned by lambda will go through string interpolation too,
     # so the following lambda would give the same result:
@@ -192,7 +194,7 @@ module I18n
     # always return the same translations/values per unique combination of argument
     # values.
     #
-    # *Ruby 2.7+ keyword arguments warning*
+    # <b>Ruby 2.7+ keyword arguments warning</b>
     #
     # This method uses keyword arguments.
     # There is a breaking change in ruby that produces warning with ruby 2.7 and won't work as expected with ruby 3.0
@@ -231,11 +233,41 @@ module I18n
     end
     alias :t! :translate!
 
+    # Returns an array of interpolation keys for the given translation key
+    #
+    # *Examples*
+    #
+    # Suppose we have the following:
+    #   I18n.t 'example.zero' == 'Zero interpolations'
+    #   I18n.t 'example.one' == 'One interpolation %{foo}'
+    #   I18n.t 'example.two' == 'Two interpolations %{foo} %{bar}'
+    #   I18n.t 'example.three' == ['One %{foo}', 'Two %{bar}', 'Three %{baz}']
+    #   I18n.t 'example.one', locale: :other == 'One interpolation %{baz}'
+    #
+    # Then we can expect the following results:
+    #   I18n.interpolation_keys('example.zero') #=> []
+    #   I18n.interpolation_keys('example.one') #=> ['foo']
+    #   I18n.interpolation_keys('example.two') #=> ['foo', 'bar']
+    #   I18n.interpolation_keys('example.three') #=> ['foo', 'bar', 'baz']
+    #   I18n.interpolation_keys('one', scope: 'example', locale: :other) #=> ['baz']
+    #   I18n.interpolation_keys('does-not-exist') #=> []
+    #   I18n.interpolation_keys('example') #=> []
+    def interpolation_keys(key, **options)
+      raise I18n::ArgumentError if !key.is_a?(String) || key.empty?
+
+      return [] unless exists?(key, **options.slice(:locale, :scope))
+
+      translation = translate(key, **options.slice(:locale, :scope))
+      interpolation_keys_from_translation(translation)
+        .flatten.compact
+    end
+
     # Returns true if a translation exists for a given key, otherwise returns false.
     def exists?(key, _locale = nil, locale: _locale, **options)
       locale ||= config.locale
       raise Disabled.new('exists?') if locale == false
-      raise I18n::ArgumentError if key.is_a?(String) && key.empty?
+      raise I18n::ArgumentError if (key.is_a?(String) && key.empty?) || key.nil?
+
       config.backend.exists?(locale, key, options)
     end
 
@@ -429,6 +461,17 @@ module I18n
           keys
         end
     end
+
+    def interpolation_keys_from_translation(translation)
+      case translation
+      when ::String
+        translation.scan(Regexp.union(I18n.config.interpolation_patterns))
+      when ::Array
+        translation.map { |element| interpolation_keys_from_translation(element) }
+      else
+        []
+      end
+    end
   end
 
   extend Base

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: i18n
 version: !ruby/object:Gem::Version
-  version: 1.12.0
+  version: 1.14.8
 platform: ruby
 authors:
 - Sven Fuchs
@@ -13,7 +13,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-13 00:00:00.000000000 Z
+date: 2025-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -106,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.5
 requirements: []
-rubygems_version: 3.3.16
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: New wave Internationalization support for Ruby