i18n 0.4.0 → 1.14.4

data/lib/i18n/backend/cache_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module I18n
+  module Backend
+    # Overwrites the Base load_file method to cache loaded file contents.
+    module CacheFile
+      # Optionally provide path_roots array to normalize filename paths,
+      # to make the cached i18n data portable across environments.
+      attr_accessor :path_roots
+
+      protected
+
+      # Track loaded translation files in the `i18n.load_file` scope,
+      # and skip loading the file if its contents are still up-to-date.
+      def load_file(filename)
+        initialized = !respond_to?(:initialized?) || initialized?
+        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 = OpenSSL::Digest::SHA256.file(filename).hexdigest) == old_digest
+        super
+        store_translations(:i18n, load_file: { key => [mtime, digest] })
+      end
+
+      # Translate absolute filename to relative path for i18n key.
+      def normalized_path(file)
+        return file unless path_roots
+        path = path_roots.find(&file.method(:start_with?)) ||
+               raise(InvalidLocaleData.new(file, 'outside expected path roots'))
+        file.sub(path, path_roots.index(path).to_s)
+      end
+    end
+  end
+end

data/lib/i18n/backend/cascade.rb

@@ -1,7 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-# EXPERIMENTAL
-#
 # The Cascade module adds the ability to do cascading lookups to backends that
 # are compatible to the Simple backend.
 #
@@ -35,22 +33,23 @@
 module I18n
   module Backend
     module Cascade
-      def lookup(locale, key, scope = [], options = {})
+      def lookup(locale, key, scope = [], options = EMPTY_HASH)
         return super unless cascade = options[:cascade]
 
+        cascade   = { :step => 1 } unless cascade.is_a?(Hash)
+        step      = cascade[:step]   || 1
+        offset    = cascade[:offset] || 1
         separator = options[:separator] || I18n.default_separator
         skip_root = cascade.has_key?(:skip_root) ? cascade[:skip_root] : true
-        step      = cascade[:step]
 
-        keys   = I18n.normalize_keys(nil, key, nil, separator)
-        offset = options[:cascade][:offset] || keys.length
-        scope  = I18n.normalize_keys(nil, nil, scope, separator) + keys
-        key    = scope.slice!(-offset, offset).join(separator)
+        scope = I18n.normalize_keys(nil, key, scope, separator)
+        key   = (scope.slice!(-offset, offset) || []).join(separator)
 
         begin
           result = super
           return result unless result.nil?
-        end while !scope.empty? && scope.slice!(-step, step) && (!scope.empty? || !skip_root)
+          scope = scope.dup
+        end while (!scope.empty? || !skip_root) && scope.slice!(-step, step)
       end
     end
   end

data/lib/i18n/backend/chain.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module I18n
   module Backend
@@ -16,62 +16,115 @@ 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
-      include Base
+      module Implementation
+        include Base
 
-      attr_accessor :backends
+        attr_accessor :backends
 
-      def initialize(*backends)
-        self.backends = backends
-      end
+        def initialize(*backends)
+          self.backends = backends
+        end
 
-      def reload!
-        backends.each { |backend| backend.reload! }
-      end
+        def initialized?
+          backends.all? do |backend|
+            backend.instance_eval do
+              return false unless initialized?
+            end
+          end
+          true
+        end
 
-      def store_translations(locale, data, options = {})
-        backends.first.store_translations(locale, data, options = {})
-      end
+        def reload!
+          backends.each { |backend| backend.reload! }
+        end
 
-      def available_locales
-        backends.map { |backend| backend.available_locales }.flatten.uniq
-      end
+        def eager_load!
+          backends.each { |backend| backend.eager_load! }
+        end
+
+        def store_translations(locale, data, options = EMPTY_HASH)
+          backends.first.store_translations(locale, data, options)
+        end
+
+        def available_locales
+          backends.map { |backend| backend.available_locales }.flatten.uniq
+        end
+
+        def translate(locale, key, default_options = EMPTY_HASH)
+          namespace = nil
+          options = Utils.except(default_options, :default)
 
-      def translate(locale, key, options = {})
-        return key.map { |k| translate(locale, k, options) } if key.is_a?(Array)
-
-        default = options.delete(:default)
-        namespace = {}
-        backends.each do |backend|
-          begin
-            options.update(:default => default) if default and backend == backends.last
-            translation = backend.translate(locale, key, options)
-            if namespace_lookup?(translation, options)
-              namespace.update(translation)
-            elsif !translation.nil?
-              return translation
+          backends.each do |backend|
+            catch(:exception) do
+              options = default_options if backend == backends.last
+              translation = backend.translate(locale, key, options)
+              if namespace_lookup?(translation, options)
+                namespace = _deep_merge(translation, namespace || {})
+              elsif !translation.nil? || (options.key?(:default) && options[:default].nil?)
+                return translation
+              end
             end
-          rescue MissingTranslationData
           end
+
+          return namespace if namespace
+          throw(:exception, I18n::MissingTranslation.new(locale, key, options))
         end
-        return namespace unless namespace.empty?
-        raise(I18n::MissingTranslationData.new(locale, key, options))
-      end
 
-      def localize(locale, object, format = :default, options = {})
-        backends.each do |backend|
-          begin
-            result = backend.localize(locale, object, format, options) and return result
-          rescue MissingTranslationData
+        def exists?(locale, key, options = EMPTY_HASH)
+          backends.any? do |backend|
+            backend.exists?(locale, key, options)
           end
         end
-        raise(I18n::MissingTranslationData.new(locale, format, options))
-      end
 
-      protected
-        def namespace_lookup?(result, options)
-          result.is_a?(Hash) and not options.has_key?(:count)
+        def localize(locale, object, format = :default, options = EMPTY_HASH)
+          backends.each do |backend|
+            catch(:exception) do
+              result = backend.localize(locale, object, format, options) and return result
+            end
+          end
+          throw(:exception, I18n::MissingTranslation.new(locale, format, options))
         end
+
+        protected
+          def init_translations
+            backends.each do |backend|
+              backend.send(:init_translations)
+            end
+          end
+
+          def translations
+            backends.reverse.each_with_object({}) do |backend, memo|
+              partial_translations = backend.instance_eval do
+                init_translations unless initialized?
+                translations
+              end
+              Utils.deep_merge!(memo, partial_translations) { |_, a, b| b || a }
+            end
+          end
+
+          def namespace_lookup?(result, options)
+            result.is_a?(Hash) && !options.has_key?(:count)
+          end
+
+        private
+          # This is approximately what gets used in ActiveSupport.
+          # However since we are not guaranteed to run in an ActiveSupport context
+          # it is wise to have our own copy. We underscore it
+          # to not pollute the namespace of the including class.
+          def _deep_merge(hash, other_hash)
+            copy = hash.dup
+            other_hash.each_pair do |k,v|
+              value_from_other = hash[k]
+              copy[k] = value_from_other.is_a?(Hash) && v.is_a?(Hash) ? _deep_merge(value_from_other, v) : v
+            end
+            copy
+          end
+      end
+
+      include Implementation
     end
   end
 end

data/lib/i18n/backend/fallbacks.rb

@@ -1,4 +1,4 @@
-# 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
@@ -8,7 +8,7 @@
 # To enable locale fallbacks you can simply include the Fallbacks module to
 # the Simple backend - or whatever other backend you are using:
 #
-#   I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+#   I18n::Backend::Simple.include(I18n::Backend::Fallbacks)
 module I18n
   @@fallbacks = nil
 
@@ -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
+      @@fallbacks = fallbacks.is_a?(Array) ? I18n::Locale::Fallbacks.new(fallbacks) : fallbacks
+      Thread.current[:i18n_fallbacks] = @@fallbacks
     end
   end
 
@@ -31,39 +33,83 @@ module I18n
       # locale :"de-DE" it might try the locales :"de-DE", :de and :en
       # (depends on the fallbacks implementation) until it finds a result with
       # the given options. If it does not find any result for any of the
-      # locales it will then raise a MissingTranslationData exception as
-      # usual.
+      # locales it will then throw MissingTranslation as usual.
       #
-      # The default option takes precedence over fallback locales
-      # only when it's not a String. When default contains String it
-      # is evaluated after fallback locales.
-      def translate(locale, key, options = {})
-        default = extract_string_default!(options) if options[:default]
+      # 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 = 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]
 
+        fallback_options = options.merge(:fallback_in_progress => true, fallback_original_locale: locale)
         I18n.fallbacks[locale].each do |fallback|
           begin
-            result = super(fallback, key, options)
-            return result unless result.nil?
-          rescue I18n::MissingTranslationData
+            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
+            end
+          rescue I18n::InvalidLocale
+            # we do nothing when the locale is invalid, as this is a fallback anyways.
           end
         end
 
+        return if options.key?(:default) && options[:default].nil?
+
         return super(locale, nil, options.merge(:default => default)) if default
-        raise(I18n::MissingTranslationData.new(locale, key, options))
+        throw(:exception, I18n::MissingTranslation.new(locale, key, options))
       end
 
-      def extract_string_default!(options)
-        defaults = Array(options[:default])
-        if index = find_first_string_default(defaults)
-          options[:default] = defaults[0, index]
-          defaults[index]
+      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 find_first_string_default(defaults)
-        defaults.each_index { |ix| return ix if String === defaults[ix] }
-        nil
+      def extract_non_symbol_default!(options)
+        defaults = [options[:default]].flatten
+        first_non_symbol_default = defaults.detect{|default| !default.is_a?(Symbol)}
+        if first_non_symbol_default
+          options[:default] = defaults[0, defaults.index(first_non_symbol_default)]
+        end
+        return first_non_symbol_default
+      end
+
+      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, options)
+          rescue I18n::InvalidLocale
+            # we do nothing when the locale is invalid, as this is a fallback anyways.
+          end
+        end
+
+        false
       end
+
+      private
+
+        # Overwrite on_fallback to add specified logic when the fallback succeeds.
+        def on_fallback(_original_locale, _fallback_locale, _key, _options)
+          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(".")
@@ -43,7 +48,7 @@ module I18n
 
       # Store flattened links.
       def links
-        @links ||= Hash.new { |h,k| h[k] = {} }
+        @links ||= I18n.new_double_nested_cache
       end
 
       # Flatten keys for nested Hashes by chaining up keys:
@@ -99,7 +104,7 @@ module I18n
         end
 
         def find_link(locale, key) #:nodoc:
-          links[locale].each do |from, to|
+          links[locale].each_pair do |from, to|
             return [from, to] if key[0, from.length] == from
           end && nil
         end
@@ -110,4 +115,4 @@ module I18n
 
     end
   end
-end
+end

data/lib/i18n/backend/gettext.rb

@@ -1,26 +1,35 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'i18n/gettext'
 require 'i18n/gettext/po_parser'
 
-# Experimental support for using Gettext po files to store translations.
-#
-# To use this you can simply include the module to the Simple backend - or
-# whatever other backend you are using.
-#
-#   I18n::Backend::Simple.send(:include, I18n::Backend::Gettext)
-#
-# Now you should be able to include your Gettext translation (*.po) files to
-# the I18n.load_path so they're loaded to the backend and you can use them as
-# usual:
-#
-#  I18n.load_path += Dir["path/to/locales/*.po"]
-#
-# Following the Gettext convention this implementation expects that your
-# translation files are named by their locales. E.g. the file en.po would
-# contain the translations for the English locale.
 module I18n
   module Backend
+    # Experimental support for using Gettext po files to store translations.
+    #
+    # To use this you can simply include the module to the Simple backend - or
+    # whatever other backend you are using.
+    #
+    #  I18n::Backend::Simple.include(I18n::Backend::Gettext)
+    #
+    # Now you should be able to include your Gettext translation (*.po) files to
+    # the +I18n.load_path+ so they're loaded to the backend and you can use them as
+    # usual:
+    #
+    #  I18n.load_path += Dir["path/to/locales/*.po"]
+    #
+    # Following the Gettext convention this implementation expects that your
+    # translation files are named by their locales. E.g. the file en.po would
+    # contain the translations for the English locale.
+    #
+    # To translate text <b>you must use</b> one of the translate methods provided by
+    # I18n::Gettext::Helpers.
+    #
+    #  include I18n::Gettext::Helpers
+    #  puts _("some string")
+    #
+    # Without it strings containing periods (".") will not be translated.
+
     module Gettext
       class PoData < Hash
         def set_comment(msgid_or_sym, comment)
@@ -32,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)
@@ -42,16 +51,15 @@ module I18n
         def normalize(locale, data)
           data.inject({}) do |result, (key, value)|
             unless key.nil? || key.empty?
+              key = key.gsub(I18n::Gettext::CONTEXT_SEPARATOR, '|')
               key, value = normalize_pluralization(locale, key, value) if key.index("\000")
 
               parts = key.split('|').reverse
-              normalized = parts.inject({}) do |normalized, part|
-                normalized = { part => normalized.empty? ? value : normalized }
+              normalized = parts.inject({}) do |_normalized, part|
+                { part => _normalized.empty? ? value : _normalized }
               end
 
-              # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
-              merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-              result.merge!(normalized, &merger)
+              Utils.deep_merge!(result, normalized)
             end
             result
           end
@@ -63,10 +71,10 @@ module I18n
 
           keys = I18n::Gettext.plural_keys(locale)
           values = value.split("\000")
-          raise "invalid number of plurals: #{values.size}, keys: #{keys.inspect}" if values.size != keys.size
+          raise "invalid number of plurals: #{values.size}, keys: #{keys.inspect} on #{locale} locale for msgid #{key.inspect} with values #{values.inspect}" if values.size != keys.size
 
           result = {}
-          values.each_with_index { |value, ix| result[keys[ix]] = value }
+          values.each_with_index { |_value, ix| result[keys[ix]] = _value }
           [key, result]
         end
 

data/lib/i18n/backend/interpolation_compiler.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # The InterpolationCompiler module contains optimizations that can tremendously
 # speed up the interpolation process on the Simple backend.
@@ -10,19 +10,18 @@
 # To enable pre-compiled interpolations you can simply include the
 # InterpolationCompiler module to the Simple backend:
 #
-#   I18n::Backend::Simple.send(:include, I18n::Backend::InterpolationCompiler)
+#   I18n::Backend::Simple.include(I18n::Backend::InterpolationCompiler)
 #
 # Note that InterpolationCompiler does not yield meaningful results and consequently
 # should not be used with Ruby 1.9 (YARV) but improves performance everywhere else
-# (jRuby, Rubinius and 1.8.7).
+# (jRuby, Rubinius).
 module I18n
   module Backend
     module InterpolationCompiler
       module Compiler
         extend self
 
-        TOKENIZER                    = /(%%\{[^\}]+\}|%\{[^\}]+\})/
-        INTERPOLATION_SYNTAX_PATTERN = /(%)?(%\{([^\}]+)\})/
+        TOKENIZER = /(%%?\{[^}]+\})/
 
         def compile_if_an_interpolation(string)
           if interpolated_str?(string)
@@ -37,7 +36,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 +47,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)
@@ -63,7 +61,7 @@ module I18n
 
         def interpolate_or_raise_missing(key)
           escaped_key = escape_key_sym(key)
-          Base::RESERVED_KEYS.include?(key) ? reserved_key(escaped_key) : interpolate_key(escaped_key)
+          RESERVED_KEYS.include?(key) ? reserved_key(escaped_key) : interpolate_key(escaped_key)
         end
 
         def interpolate_key(key)
@@ -79,7 +77,7 @@ module I18n
         end
 
         def missing_key(key)
-          "raise(MissingInterpolationArgument.new(#{key}, self))"
+          "I18n.config.missing_interpolation_argument_handler.call(#{key}, v, self)"
         end
 
         def reserved_key(key)
@@ -106,7 +104,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
@@ -120,4 +118,4 @@ module I18n
       end
     end
   end
-end
+end