i18n 0.4.0 → 1.14.4

data/lib/i18n/backend/key_value.rb

@@ -1,9 +1,26 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'i18n/backend/base'
-require 'active_support/json'
 
 module I18n
+
+  begin
+    require 'oj'
+    class JSON
+      class << self
+        def encode(value)
+          Oj::Rails.encode(value)
+        end
+        def decode(value)
+          Oj.load(value)
+        end
+      end
+    end
+  rescue LoadError
+    require 'active_support/json'
+    JSON = ActiveSupport::JSON
+  end
+
   module Backend
     # This is a basic backend for key value stores. It receives on
     # initialization the store, which should respond to three methods:
@@ -59,7 +76,11 @@ module I18n
           @store, @subtrees = store, subtrees
         end
 
-        def store_translations(locale, data, options = {})
+        def initialized?
+          !@store.nil?
+        end
+
+        def store_translations(locale, data, options = EMPTY_HASH)
           escape = options.fetch(:escape, true)
           flatten_translations(locale, data, escape, @subtrees).each do |key, value|
             key = "#{locale}.#{key}"
@@ -67,14 +88,14 @@ module I18n
             case value
             when Hash
               if @subtrees && (old_value = @store[key])
-                old_value = ActiveSupport::JSON.decode(old_value)
-                value = old_value.deep_symbolize_keys.deep_merge!(value) if old_value.is_a?(Hash)
+                old_value = JSON.decode(old_value)
+                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"
             end
 
-            @store[key] = ActiveSupport::JSON.encode(value) unless value.is_a?(Symbol)
+            @store[key] = JSON.encode(value) unless value.is_a?(Symbol)
           end
         end
 
@@ -88,15 +109,96 @@ module I18n
 
       protected
 
-        def lookup(locale, key, scope = [], options = {})
+        # Queries the translations from the key-value store and converts
+        # them into a hash such as the one returned from loading the
+        # haml files
+        def translations
+          @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| Utils.deep_merge!(hash, elem)})
+        end
+
+        def init_translations
+          # NO OP
+          # This call made also inside Simple Backend and accessed by
+          # other plugins like I18n-js and babilu and
+          # to use it along with the Chain backend we need to
+          # provide a uniform API even for protected methods :S
+        end
+
+        def subtrees?
+          @subtrees
+        end
+
+        def lookup(locale, key, scope = [], options = EMPTY_HASH)
           key   = normalize_flat_keys(locale, key, scope, options[:separator])
           value = @store["#{locale}.#{key}"]
-          value = ActiveSupport::JSON.decode(value) if value
-          value.is_a?(Hash) ? value.deep_symbolize_keys : value
+          value = JSON.decode(value) if value
+
+          if value.is_a?(Hash)
+            Utils.deep_symbolize_keys(value)
+          elsif !value.nil?
+            value
+          elsif !@subtrees
+            SubtreeProxy.new("#{locale}.#{key}", @store)
+          end
+        end
+
+        def pluralize(locale, entry, count)
+          if subtrees?
+            super
+          else
+            return entry unless entry.is_a?(Hash)
+            key = pluralization_key(entry, count)
+            entry[key]
+          end
+        end
+      end
+
+      class SubtreeProxy
+        def initialize(master_key, store)
+          @master_key = master_key
+          @store = store
+          @subtree = nil
+        end
+
+        def has_key?(key)
+          @subtree && @subtree.has_key?(key) || self[key]
+        end
+
+        def [](key)
+          unless @subtree && value = @subtree[key]
+            value = @store["#{@master_key}.#{key}"]
+            if value
+              value = JSON.decode(value)
+              (@subtree ||= {})[key] = value
+            end
+          end
+          value
+        end
+
+        def is_a?(klass)
+          Hash == klass || super
+        end
+        alias :kind_of? :is_a?
+
+        def instance_of?(klass)
+          Hash == klass || super
+        end
+
+        def nil?
+          @subtree.nil?
+        end
+
+        def inspect
+          @subtree.inspect
         end
       end
 
       include Implementation
     end
   end
-end
+end

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) }.uniq
+        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/memoize.rb

@@ -1,11 +1,11 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # Memoize module simply memoizes the values returned by lookup using
 # a flat hash and can tremendously speed up the lookup process in a backend.
 #
 # To enable it you can simply include the Memoize module to your backend:
 #
-#   I18n::Backend::Simple.send(:include, I18n::Backend::Memoize)
+#   I18n::Backend::Simple.include(I18n::Backend::Memoize)
 #
 # Notice that it's the responsibility of the backend to define whenever the
 # cache should be cleaned.
@@ -16,7 +16,7 @@ module I18n
         @memoized_locales ||= super
       end
 
-      def store_translations(locale, data, options = {})
+      def store_translations(locale, data, options = EMPTY_HASH)
         reset_memoizations!(locale)
         super
       end
@@ -26,9 +26,15 @@ module I18n
         super
       end
 
+      def eager_load!
+        memoized_lookup
+        available_locales
+        super
+      end
+
       protected
 
-        def lookup(locale, key, scope = nil, options = {})
+        def lookup(locale, key, scope = nil, options = EMPTY_HASH)
           flat_key  = I18n::Backend::Flatten.normalize_flat_keys(locale,
             key, scope, options[:separator]).to_sym
           flat_hash = memoized_lookup[locale.to_sym]
@@ -36,7 +42,7 @@ module I18n
         end
 
         def memoized_lookup
-          @memoized_lookup ||= Hash.new { |h, k| h[k] = {} }
+          @memoized_lookup ||= I18n.new_double_nested_cache
         end
 
         def reset_memoizations!(locale=nil)
@@ -45,4 +51,4 @@ module I18n
         end
     end
   end
-end
+end

data/lib/i18n/backend/metadata.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # I18n translation metadata is useful when you want to access information
 # about how a translation was looked up, pluralized or interpolated in
 # your application.
@@ -12,7 +14,7 @@
 # To enable translation metadata you can simply include the Metadata module
 # into the Simple backend class - or whatever other backend you are using:
 #
-#   I18n::Backend::Simple.send(:include, I18n::Backend::Metadata)
+#   I18n::Backend::Simple.include(I18n::Backend::Metadata)
 #
 module I18n
   module Backend
@@ -21,29 +23,33 @@ module I18n
         def included(base)
           Object.class_eval do
             def translation_metadata
-              @translation_metadata ||= {}
+              unless self.frozen?
+                @translation_metadata ||= {}
+              else
+                {}
+              end
             end
 
             def translation_metadata=(translation_metadata)
-              @translation_metadata = translation_metadata
+              @translation_metadata = translation_metadata unless self.frozen?
             end
           end unless Object.method_defined?(:translation_metadata)
         end
       end
 
-      def translate(locale, key, options = {})
+      def translate(locale, key, options = EMPTY_HASH)
         metadata = {
           :locale    => locale,
           :key       => key,
           :scope     => options[:scope],
           :default   => options[:default],
           :separator => options[:separator],
-          :values    => options.reject { |name, value| Base::RESERVED_KEYS.include?(name) }
+          :values    => options.reject { |name, _value| RESERVED_KEYS.include?(name) }
         }
         with_metadata(metadata) { super }
       end
 
-      def interpolate(locale, entry, values = {})
+      def interpolate(locale, entry, values = EMPTY_HASH)
         metadata = entry.translation_metadata.merge(:original => entry)
         with_metadata(metadata) { super }
       end

data/lib/i18n/backend/pluralization.rb

@@ -1,15 +1,13 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-# I18n locale fallbacks are useful when you want your application to use
-# translations from other locales when translations for the current locale are
-# missing. E.g. you might want to use :en translations when translations in
-# your applications main locale :de are missing.
+# I18n Pluralization are useful when you want your application to
+# customize pluralization rules.
 #
 # To enable locale specific pluralizations you can simply include the
 # Pluralization module to the Simple backend - or whatever other backend you
 # are using.
 #
-#   I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
+#   I18n::Backend::Simple.include(I18n::Backend::Pluralization)
 #
 # You also need to make sure to provide pluralization algorithms to the
 # backend, i.e. include them to your I18n.load_path accordingly.
@@ -18,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(entry, 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.
+      # Pluralization rules are expected to respond to #call(count) and
+      # 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) and 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) 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
@@ -45,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

@@ -1,4 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require 'i18n/backend/base'
 
 module I18n
   module Backend
@@ -15,10 +17,13 @@ module I18n
     #   end
     # end
     #
-    # I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
+    # 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
@@ -28,18 +33,23 @@ module I18n
         # This uses a deep merge for the translations hash, so existing
         # translations will be overwritten by new ones only at the deepest
         # level of the hash.
-        def store_translations(locale, data, options = {})
+        def store_translations(locale, data, options = EMPTY_HASH)
+          if I18n.enforce_available_locales &&
+            I18n.available_locales_initialized? &&
+            !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
         def available_locales
           init_translations unless initialized?
           translations.inject([]) do |locales, (locale, data)|
-            locales << locale unless (data.keys - [:i18n]).empty?
+            locales << locale unless data.size <= 1 && (data.empty? || data.has_key?(:i18n))
             locales
           end
         end
@@ -51,6 +61,23 @@ module I18n
           super
         end
 
+        def eager_load!
+          init_translations unless initialized?
+          super
+        end
+
+        def translations(do_init: false)
+          # To avoid returning empty translations,
+          # call `init_translations`
+          init_translations if do_init && !initialized?
+
+          @translations ||= Concurrent::Hash.new do |h, k|
+            MUTEX.synchronize do
+              h[k] = Concurrent::Hash.new
+            end
+          end
+        end
+
       protected
 
         def init_translations
@@ -58,24 +85,23 @@ module I18n
           @initialized = true
         end
 
-        def translations
-          @translations ||= {}
-        end
-
         # Looks up a translation from the translations hash. Returns nil if
-        # eiher key is nil, or locale, scope or key do not exist as a key in the
+        # either key is nil, or locale, scope or key do not exist as a key in the
         # nested translations hash. Splits keys or scopes containing dots
         # into multiple keys, i.e. <tt>currency.format</tt> is regarded the same as
         # <tt>%w(currency format)</tt>.
-        def lookup(locale, key, scope = [], options = {})
+        def lookup(locale, key, scope = [], options = EMPTY_HASH)
           init_translations unless initialized?
           keys = I18n.normalize_keys(locale, key, scope, options[:separator])
 
-          keys.inject(translations) do |result, key|
-            key = key.to_sym
-            return nil unless result.is_a?(Hash) && result.has_key?(key)
-            result = result[key]
-            result = resolve(locale, key, result, options.merge(:scope => nil)) if result.is_a?(Symbol)
+          keys.inject(translations) do |result, _key|
+            return nil unless result.is_a?(Hash)
+            unless result.has_key?(_key)
+              _key = _key.to_s.to_sym
+              return nil unless result.has_key?(_key)
+            end
+            result = result[_key]
+            result = resolve_entry(locale, _key, result, Utils.except(options.merge(:scope => nil), :count)) if result.is_a?(Symbol)
             result
           end
         end