i18n 0.9.5 → 1.10.0

data/lib/i18n/backend/fallbacks.rb

@@ -1,3 +1,5 @@
+# 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
@@ -14,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
+      @@fallbacks = fallbacks.is_a?(Array) ? I18n::Locale::Fallbacks.new(fallbacks) : fallbacks
+      Thread.current[:i18n_fallbacks] = @@fallbacks
     end
   end
 
@@ -34,25 +38,24 @@ module I18n
       # The default option takes precedence over fallback locales only when
       # it's a Symbol. When the default contains a String, Proc or Hash
       # it is evaluated last after all the fallback locales have been tried.
-      def translate(locale, key, options = {})
+      def translate(locale, key, options = EMPTY_HASH)
         return super unless options.fetch(:fallback, true)
         return super if options[:fallback_in_progress]
         default = extract_non_symbol_default!(options) if options[:default]
 
-        begin
-          options[:fallback_in_progress] = true
-          I18n.fallbacks[locale].each do |fallback|
-            begin
-              catch(:exception) do
-                result = super(fallback, key, options)
-                return result unless result.nil?
+        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.to_s != fallback.to_s
+                return result
               end
-            rescue I18n::InvalidLocale
-              # we do nothing when the locale is invalid, as this is a fallback anyways.
             end
+          rescue I18n::InvalidLocale
+            # we do nothing when the locale is invalid, as this is a fallback anyways.
           end
-        ensure
-          options.delete(:fallback_in_progress)
         end
 
         return if options.key?(:default) && options[:default].nil?
@@ -61,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)}
@@ -70,7 +91,8 @@ module I18n
         return first_non_symbol_default
       end
 
-      def exists?(locale, key)
+      def exists?(locale, key, options = EMPTY_HASH)
+        return super unless options.fetch(:fallback, true)
         I18n.fallbacks[locale].each do |fallback|
           begin
             return true if super(fallback, key)
@@ -81,6 +103,13 @@ module I18n
 
         false
       end
+
+      private
+
+        # Overwrite on_fallback to add specified logic when the fallback succeeds.
+        def on_fallback(_original_locale, _fallback_locale, _key, _optoins)
+          nil
+        end
     end
   end
 end

data/lib/i18n/backend/flatten.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module I18n
   module Backend
     # This module contains several helpers to assist flattening translations.
@@ -16,14 +18,17 @@ module I18n
       # and creates way less objects than the one at I18n.normalize_keys.
       # It also handles escaping the translation keys.
       def self.normalize_flat_keys(locale, key, scope, separator)
-        keys = [scope, key].flatten.compact
+        keys = [scope, key]
+        keys.flatten!
+        keys.compact!
+
         separator ||= I18n.default_separator
 
         if separator != FLATTEN_SEPARATOR
-          keys.map! do |k|
-            k.to_s.tr("#{FLATTEN_SEPARATOR}#{separator}",
-              "#{SEPARATOR_ESCAPE_CHAR}#{FLATTEN_SEPARATOR}")
-          end
+          from_str = "#{FLATTEN_SEPARATOR}#{separator}"
+          to_str = "#{SEPARATOR_ESCAPE_CHAR}#{FLATTEN_SEPARATOR}"
+
+          keys.map! { |k| k.to_s.tr from_str, to_str }
         end
 
         keys.join(".")

data/lib/i18n/backend/gettext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'i18n/gettext'
 require 'i18n/gettext/po_parser'
 
@@ -39,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)
@@ -57,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/interpolation_compiler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # The InterpolationCompiler module contains optimizations that can tremendously
 # speed up the interpolation process on the Simple backend.
 #
@@ -104,7 +106,7 @@ module I18n
         end
       end
 
-      def store_translations(locale, data, options = {})
+      def store_translations(locale, data, options = EMPTY_HASH)
         compile_all_strings_in(data)
         super
       end

data/lib/i18n/backend/key_value.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'i18n/backend/base'
 
 module I18n
@@ -74,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}"
@@ -83,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"
@@ -103,17 +109,37 @@ module I18n
 
       protected
 
+        # 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 = {})
+        def lookup(locale, key, scope = [], options = EMPTY_HASH)
           key   = normalize_flat_keys(locale, key, scope, options[:separator])
           value = @store["#{locale}.#{key}"]
           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
@@ -125,6 +151,7 @@ module I18n
           if subtrees?
             super
           else
+            return entry unless entry.is_a?(Hash)
             key = pluralization_key(entry, count)
             entry[key]
           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) }
+        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,3 +1,5 @@
+# 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.
 #
@@ -14,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
@@ -24,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]

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.
@@ -35,19 +37,19 @@ module I18n
         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| 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,3 +1,5 @@
+# frozen_string_literal: true
+
 # I18n Pluralization are useful when you want your application to
 # customize pluralization rules.
 #
@@ -27,7 +29,7 @@ module I18n
       # either pick a special :zero translation even for languages where the
       # pluralizer does not return a :zero key.
       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)

data/lib/i18n/backend/simple.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'i18n/backend/base'
+
 module I18n
   module Backend
     # A simple backend that reads translations from YAML files and stores them in
@@ -15,8 +19,6 @@ module I18n
     #
     # I18n::Backend::Simple.include(I18n::Backend::Pluralization)
     class Simple
-      (class << self; self; end).class_eval { public :include }
-
       module Implementation
         include Base
 
@@ -28,17 +30,16 @@ 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.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
@@ -57,6 +58,19 @@ 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 { |h, k| h[k] = Concurrent::Hash.new }
+        end
+
       protected
 
         def init_translations
@@ -64,24 +78,23 @@ module I18n
           @initialized = true
         end
 
-        def translations
-          @translations ||= {}
-        end
-
         # Looks up a translation from the translations hash. Returns nil if
         # 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)
+            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(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/transliterator.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 module I18n
   module Backend
     module Transliterator

data/lib/i18n/backend.rb

@@ -1,14 +1,18 @@
+# frozen_string_literal: true
+
 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'
     autoload :Chain,                 'i18n/backend/chain'
     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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module I18n
@@ -5,7 +7,7 @@ module I18n
     # The only configuration value that is not global and scoped to thread is :locale.
     # It defaults to the default_locale.
     def locale
-      defined?(@locale) && @locale ? @locale : default_locale
+      defined?(@locale) && @locale != nil ? @locale : default_locale
     end
 
     # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
@@ -57,7 +59,7 @@ module I18n
       @@available_locales = nil if @@available_locales.empty?
       @@available_locales_set = nil
     end
-    
+
     # Returns true if the available_locales have been initialized
     def available_locales_initialized?
       ( !!defined?(@@available_locales) && !!@@available_locales )
@@ -143,5 +145,21 @@ module I18n
     def enforce_available_locales=(enforce_available_locales)
       @@enforce_available_locales = enforce_available_locales
     end
+
+    # Returns the current interpolation patterns. Defaults to
+    # I18n::DEFAULT_INTERPOLATION_PATTERNS.
+    def interpolation_patterns
+      @@interpolation_patterns ||= I18n::DEFAULT_INTERPOLATION_PATTERNS.dup
+    end
+
+    # Sets the current interpolation patterns. Used to set a interpolation
+    # patterns.
+    #
+    # E.g. using {{}} as a placeholder like "{{hello}}, world!":
+    #
+    #   I18n.config.interpolation_patterns << /\{\{(\w+)\}\}/
+    def interpolation_patterns=(interpolation_patterns)
+      @@interpolation_patterns = interpolation_patterns
+    end
   end
 end