i18n 1.0.1 → 1.6.0

data/lib/i18n/backend/gettext.rb

@@ -31,6 +31,8 @@ module I18n
     # Without it strings containing periods (".") will not be translated.
 
     module Gettext
+      using I18n::HashRefinements
+
       class PoData < Hash
         def set_comment(msgid_or_sym, comment)
           # ignore

data/lib/i18n/backend/key_value.rb

@@ -67,6 +67,8 @@ module I18n
     #
     # This is useful if you are using a KeyValue backend chained to a Simple backend.
     class KeyValue
+      using I18n::HashRefinements
+
       module Implementation
         attr_accessor :store
 
@@ -76,6 +78,10 @@ module I18n
           @store, @subtrees = store, subtrees
         end
 
+        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|
@@ -105,6 +111,26 @@ 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 = @store.keys.clone.map do |main_key|
+            main_value = JSON.decode(@store[main_key])
+            main_key.to_s.split(".").reverse.inject(main_value) do |value, key|
+              {key.to_sym => value}
+            end
+          end.inject{|hash, elem| hash.deep_merge!(elem)}.deep_symbolize_keys
+        end
+
+        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
@@ -127,6 +153,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/memoize.rb

@@ -26,6 +26,12 @@ module I18n
         super
       end
 
+      def eager_load!
+        memoized_lookup
+        available_locales
+        super
+      end
+
       protected
 
         def lookup(locale, key, scope = nil, options = EMPTY_HASH)

data/lib/i18n/backend/simple.rb

@@ -1,5 +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
@@ -17,6 +19,8 @@ module I18n
     #
     # I18n::Backend::Simple.include(I18n::Backend::Pluralization)
     class Simple
+      using I18n::HashRefinements
+
       (class << self; self; end).class_eval { public :include }
 
       module Implementation
@@ -59,6 +63,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 ||= {}
+        end
+
       protected
 
         def init_translations
@@ -66,10 +83,6 @@ 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
@@ -80,8 +93,11 @@ module I18n
           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

data/lib/i18n/config.rb

@@ -7,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.
@@ -145,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

data/lib/i18n/core_ext/hash.rb

@@ -1,29 +1,47 @@
-class Hash
-  def slice(*keep_keys)
-    h = {}
-    keep_keys.each { |key| h[key] = fetch(key) if has_key?(key) }
-    h
-  end unless Hash.method_defined?(:slice)
+module I18n
+  module HashRefinements
+    refine Hash do
+      using I18n::HashRefinements
+      def except(*keys)
+        dup.except!(*keys)
+      end
 
-  def except(*less_keys)
-    slice(*keys - less_keys)
-  end unless Hash.method_defined?(:except)
+      def except!(*keys)
+        keys.each { |key| delete(key) }
+        self
+      end
 
-  def deep_symbolize_keys
-    inject({}) { |result, (key, value)|
-      value = value.deep_symbolize_keys if value.is_a?(Hash)
-      result[(key.to_sym rescue key) || key] = value
-      result
-    }
-  end unless Hash.method_defined?(:deep_symbolize_keys)
+      def deep_symbolize_keys
+        each_with_object({}) do |(key, value), result|
+          result[symbolize_key(key)] = deep_symbolize_keys_in_object(value)
+          result
+        end
+      end
 
-  # deep_merge_hash! by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
-  MERGER = proc do |key, v1, v2|
-    Hash === v1 && Hash === v2 ? v1.merge(v2, &MERGER) : v2
+      # deep_merge_hash! by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+      def deep_merge!(data)
+        merger = lambda do |_key, v1, v2|
+          Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
+        end
+        merge!(data, &merger)
+      end
+
+      def symbolize_key(key)
+        key.respond_to?(:to_sym) ? key.to_sym : key
+      end
+
+      private
+
+      def deep_symbolize_keys_in_object(value)
+        case value
+        when Hash
+          value.deep_symbolize_keys
+        when Array
+          value.map { |e| deep_symbolize_keys_in_object(e) }
+        else
+          value
+        end
+      end
+    end
   end
-  
-  def deep_merge!(data)
-    merge!(data, &MERGER)
-  end unless Hash.method_defined?(:deep_merge!)
 end
-

data/lib/i18n/exceptions.rb

@@ -3,27 +3,32 @@
 require 'cgi'
 
 module I18n
-  # Handles exceptions raised in the backend. All exceptions except for
-  # MissingTranslationData exceptions are re-thrown. When a MissingTranslationData
-  # was caught the handler returns an error message string containing the key/scope.
-  # Note that the exception handler is not called when the option :throw was given.
   class ExceptionHandler
-    include Module.new {
-      def call(exception, locale, key, options)
-        case exception
-        when MissingTranslation
-          exception.message
-        when Exception
-          raise exception
-        else
-          throw :exception, exception
-        end
+    def call(exception, _locale, _key, _options)
+      if exception.is_a?(MissingTranslation)
+        exception.message
+      else
+        raise exception
       end
-    }
+    end
   end
 
   class ArgumentError < ::ArgumentError; end
 
+  class Disabled < ArgumentError
+    def initialize(method)
+      super(<<~MESSAGE)
+        I18n.#{method} is currently disabled, likely because your application is still in its loading phase.
+
+        This method is meant to display text in the user locale, so calling it before the user locale has
+        been set is likely to display text from the wrong locale to some users.
+
+        If you have a legitimate reason to access i18n data outside of the user flow, you can do so by passing
+        the desired locale explictly with the `locale` argument, e.g. `I18n.#{method}(..., locale: :en)`
+      MESSAGE
+    end
+  end
+
   class InvalidLocale < ArgumentError
     attr_reader :locale
     def initialize(locale)

data/lib/i18n/interpolate/ruby.rb

@@ -2,11 +2,13 @@
 # http://github.com/mutoh/gettext/blob/f6566738b981fe0952548c421042ad1e0cdfb31e/lib/gettext/core_ext/string.rb
 
 module I18n
-  INTERPOLATION_PATTERN = Regexp.union(
+  DEFAULT_INTERPOLATION_PATTERNS = [
     /%%/,
     /%\{(\w+)\}/,                               # matches placeholders like "%{foo}"
     /%<(\w+)>(.*?\d*\.?\d*[bBdiouxXeEfgGcps])/  # matches placeholders like "%<foo>.d"
-  )
+  ].freeze
+  INTERPOLATION_PATTERN = Regexp.union(DEFAULT_INTERPOLATION_PATTERNS)
+  deprecate_constant :INTERPOLATION_PATTERN if method_defined? :INTERPOLATION_PATTERN
 
   class << self
     # Return String or raises MissingInterpolationArgument exception.
@@ -18,7 +20,7 @@ module I18n
     end
 
     def interpolate_hash(string, values)
-      string.gsub(INTERPOLATION_PATTERN) do |match|
+      string.gsub(Regexp.union(config.interpolation_patterns)) do |match|
         if match == '%%'
           '%'
         else

data/lib/i18n/locale/fallbacks.rb

@@ -56,7 +56,7 @@ module I18n
       def initialize(*mappings)
         @map = {}
         map(mappings.pop) if mappings.last.is_a?(Hash)
-        self.defaults = mappings.empty? ? [I18n.default_locale.to_sym] : mappings
+        self.defaults = mappings.empty? ? [] : mappings
       end
 
       def defaults=(defaults)

data/lib/i18n/tests/interpolation.rb

@@ -43,7 +43,7 @@ module I18n
       end
 
       test "interpolation: it does not raise I18n::MissingInterpolationArgument for escaped variables" do
-        assert_nothing_raised(I18n::MissingInterpolationArgument) do
+        assert_nothing_raised do
           assert_equal 'Barr %{foo}', interpolate(:default => '%{bar} %%{foo}', :bar => 'Barr')
         end
       end

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

@@ -11,8 +11,7 @@ module I18n
         end
 
         test "localize Date: given the short format it uses it" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal '01. Mar', I18n.l(@date, :format => :short, :locale => :de)
+          assert_equal '01. Mär', I18n.l(@date, :format => :short, :locale => :de)
         end
 
         test "localize Date: given the long format it uses it" do
@@ -27,17 +26,40 @@ module I18n
           assert_equal 'Samstag', I18n.l(@date, :format => '%A', :locale => :de)
         end
 
+        test "localize Date: given a uppercased day name format it returns the correct day name in upcase" do
+          assert_equal 'samstag'.upcase, I18n.l(@date, :format => '%^A', :locale => :de)
+        end
+
         test "localize Date: given an abbreviated day name format it returns the correct abbreviated day name" do
           assert_equal 'Sa', I18n.l(@date, :format => '%a', :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
+
         test "localize Date: given a month name format it returns the correct month name" do
           assert_equal 'März', I18n.l(@date, :format => '%B', :locale => :de)
         end
 
+        test "localize Date: given a uppercased month name format it returns the correct month name in upcase" do
+          assert_equal 'märz'.upcase, I18n.l(@date, :format => '%^B', :locale => :de)
+        end
+
         test "localize Date: given an abbreviated month name format it returns the correct abbreviated month name" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal 'Mar', I18n.l(@date, :format => '%b', :locale => :de)
+          assert_equal 'Mär', I18n.l(@date, :format => '%b', :locale => :de)
+        end
+
+        test "localize Date: given an abbreviated and uppercased month name format it returns the correct abbreviated month name in upcase" do
+          assert_equal 'mär'.upcase, I18n.l(@date, :format => '%^b', :locale => :de)
+        end
+
+        test "localize Date: given a date format with the month name upcased it returns the correct value" do
+          assert_equal '1. FEBRUAR 2008', I18n.l(::Date.new(2008, 2, 1), :format => "%-d. %^B %Y", :locale => :de)
+        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)
         end
 
         test "localize Date: given an unknown format it does not fail" do
@@ -46,7 +68,7 @@ module I18n
 
         test "localize Date: does not modify the options hash" do
           options = { :format => '%b', :locale => :de }
-          assert_equal 'Mar', I18n.l(@date, options)
+          assert_equal 'Mär', I18n.l(@date, options)
           assert_equal({ :format => '%b', :locale => :de }, options)
           assert_nothing_raised { I18n.l(@date, options.freeze) }
         end
@@ -85,7 +107,7 @@ module I18n
                 :day_names => %w(Sonntag Montag Dienstag Mittwoch Donnerstag Freitag Samstag),
                 :abbr_day_names => %w(So Mo Di Mi Do Fr  Sa),
                 :month_names => %w(Januar Februar März April Mai Juni Juli August September Oktober November Dezember).unshift(nil),
-                :abbr_month_names => %w(Jan Feb Mar Apr Mai Jun Jul Aug Sep Okt Nov Dez).unshift(nil)
+                :abbr_month_names => %w(Jan Feb Mär Apr Mai Jun Jul Aug Sep Okt Nov Dez).unshift(nil)
               }
             }
           end

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

@@ -12,8 +12,7 @@ module I18n
         end
 
         test "localize DateTime: given the short format it uses it" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal '01. Mar 06:00', I18n.l(@datetime, :format => :short, :locale => :de)
+          assert_equal '01. Mär 06:00', I18n.l(@datetime, :format => :short, :locale => :de)
         end
 
         test "localize DateTime: given the long format it uses it" do
@@ -21,25 +20,47 @@ module I18n
         end
 
         test "localize DateTime: given the default format it uses it" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal 'Sa, 01. Mar 2008 06:00:00 +0000', I18n.l(@datetime, :format => :default, :locale => :de)
+          assert_equal 'Sa, 01. Mär 2008 06:00:00 +0000', I18n.l(@datetime, :format => :default, :locale => :de)
         end
 
         test "localize DateTime: given a day name format it returns the correct day name" do
           assert_equal 'Samstag', I18n.l(@datetime, :format => '%A', :locale => :de)
         end
 
+        test "localize DateTime: given a uppercased day name format it returns the correct day name in upcase" do
+          assert_equal 'samstag'.upcase, I18n.l(@datetime, :format => '%^A', :locale => :de)
+        end
+
         test "localize DateTime: given an abbreviated day name format it returns the correct abbreviated day name" do
           assert_equal 'Sa', I18n.l(@datetime, :format => '%a', :locale => :de)
         end
 
+        test "localize DateTime: given an abbreviated and uppercased day name format it returns the correct abbreviated day name in upcase" do
+          assert_equal 'sa'.upcase, I18n.l(@datetime, :format => '%^a', :locale => :de)
+        end
+
         test "localize DateTime: given a month name format it returns the correct month name" do
           assert_equal 'März', I18n.l(@datetime, :format => '%B', :locale => :de)
         end
 
+        test "localize DateTime: given a uppercased month name format it returns the correct month name in upcase" do
+          assert_equal 'märz'.upcase, I18n.l(@datetime, :format => '%^B', :locale => :de)
+        end
+
         test "localize DateTime: given an abbreviated month name format it returns the correct abbreviated month name" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal 'Mar', I18n.l(@datetime, :format => '%b', :locale => :de)
+          assert_equal 'Mär', I18n.l(@datetime, :format => '%b', :locale => :de)
+        end
+
+        test "localize DateTime: given an abbreviated and uppercased month name format it returns the correct abbreviated month name in upcase" do
+          assert_equal 'mär'.upcase, I18n.l(@datetime, :format => '%^b', :locale => :de)
+        end
+
+        test "localize DateTime: given a date format with the month name upcased it returns the correct value" do
+          assert_equal '1. FEBRUAR 2008', I18n.l(::DateTime.new(2008, 2, 1, 6), :format => "%-d. %^B %Y", :locale => :de)
+        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)
         end
 
         test "localize DateTime: given a meridian indicator format it returns the correct meridian indicator" do