i18n 0.3.2 → 0.3.3

data/Rakefile

@@ -4,10 +4,13 @@ task :test do
   ruby "test/all.rb"
 end
 
+require File.expand_path("lib/i18n/version", File.dirname(__FILE__))
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |s|
     s.name = "i18n"
+    s.version = I18n::VERSION
     s.rubyforge_project = "i18n"
     s.summary = "New wave Internationalization support for Ruby"
     s.email = "rails-i18n@googlegroups.com"

data/lib/i18n.rb

@@ -201,11 +201,11 @@ module I18n
     # always return the same translations/values per unique combination of argument
     # values.
     def translate(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
+      options = args.pop if args.last.is_a?(Hash)
       key     = args.shift
-      locale  = options.delete(:locale) || I18n.locale
-      raises  = options.delete(:raise)
-      backend.translate(locale, key, options)
+      locale  = options && options.delete(:locale) || I18n.locale
+      raises  = options && options.delete(:raise)
+      backend.translate(locale, key, options || {})
     rescue I18n::ArgumentError => exception
       raise exception if raises
       handle_exception(exception, locale, key, options)
@@ -270,7 +270,8 @@ module I18n
     def normalize_translation_keys(locale, key, scope, separator = nil)
       keys = [locale] + Array(scope) + Array(key)
       keys = keys.map { |k| k.to_s.split(separator || I18n.default_separator) }
-      keys.flatten.map { |k| k.to_sym }
+      keys = keys.flatten - ['']
+      keys.map { |k| k.to_sym }
     end
   end
 end

data/lib/i18n/backend.rb

@@ -1,15 +1,17 @@
 module I18n
   module Backend
-    autoload :ActiveRecord,  'i18n/backend/active_record'
-    autoload :Base,          'i18n/backend/base'
-    autoload :Cache,         'i18n/backend/cache'
-    autoload :Cascade,       'i18n/backend/cascade'
-    autoload :Chain,         'i18n/backend/chain'
-    autoload :Fallbacks,     'i18n/backend/fallbacks'
-    autoload :Gettext,       'i18n/backend/gettext'
-    autoload :Helpers,       'i18n/backend/helpers'
-    autoload :Metadata,      'i18n/backend/metadata'
-    autoload :Pluralization, 'i18n/backend/pluralization'
-    autoload :Simple,        'i18n/backend/simple'
+    autoload :ActiveRecord,          'i18n/backend/active_record'
+    autoload :Base,                  'i18n/backend/base'
+    autoload :Cache,                 'i18n/backend/cache'
+    autoload :Cascade,               'i18n/backend/cascade'
+    autoload :Chain,                 'i18n/backend/chain'
+    autoload :Fallbacks,             'i18n/backend/fallbacks'
+    autoload :Fast,                  'i18n/backend/fast'
+    autoload :Gettext,               'i18n/backend/gettext'
+    autoload :Helpers,               'i18n/backend/helpers'
+    autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
+    autoload :Metadata,              'i18n/backend/metadata'
+    autoload :Pluralization,         'i18n/backend/pluralization'
+    autoload :Simple,                'i18n/backend/simple'
   end
 end

data/lib/i18n/backend/active_record.rb

@@ -24,7 +24,7 @@ module I18n
         separator = options[:separator] || I18n.default_separator
         wind_keys(data, separator).each do |key, v|
           Translation.locale(locale).lookup(expand_keys(key, separator), separator).delete_all
-          Translation.create(:locale => locale.to_s, :key => key, :value => v)
+          Translation.create(:locale => locale.to_s, :key => key.to_s, :value => v)
         end
       end
 

data/lib/i18n/backend/active_record/missing.rb

@@ -11,19 +11,21 @@
 #     I18n.backend = I18nChainBackend.new(I18n::Backend::ActiveRecord.new, I18n::Backend::Simple.new)
 #
 #  Stub records for pluralizations will also be created for each key defined
-#  in i18n.plural_keys.
+#  in i18n.plural.keys.
 #
 #  For example:
 #
 #    # en.yml
 #    en:
 #      i18n:
-#        plural_keys: [:zero, :one, :other]
+#        plural:
+#          keys: [:zero, :one, :other]
 #
 #    # pl.yml
 #    pl:
 #      i18n:
-#        plural_keys: [:zero, :one, :few, :other]
+#        plural:
+#          keys: [:zero, :one, :few, :other]
 #
 #  It will also persist interpolation keys in Translation#interpolations so
 #  translators will be able to review and use them.
@@ -34,13 +36,14 @@ module I18n
         def store_default_translations(locale, key, options = {})
           count, scope, default, separator = options.values_at(:count, *Base::RESERVED_KEYS)
           separator ||= I18n.default_separator
+
           keys = I18n.send(:normalize_translation_keys, locale, key, scope, separator)[1..-1]
           key = keys.join(separator || I18n.default_separator)
 
           unless ActiveRecord::Translation.locale(locale).lookup(key, separator).exists?
             interpolations = options.reject { |name, value| Base::RESERVED_KEYS.include?(name) }.keys
-            keys = count ? I18n.t('i18n.plural_keys', :locale => locale).map { |k| [key, k].join(separator) } : [key]
-            keys.each { |key| store_default_translation(locale, key, interpolations) } 
+            keys = count ? I18n.t('i18n.plural.keys', :locale => locale).map { |k| [key, k].join(separator) } : [key]
+            keys.each { |key| store_default_translation(locale, key, interpolations) }
           end
         end
 
@@ -49,7 +52,7 @@ module I18n
           translation.interpolations = interpolations
           translation.save
         end
-      
+
         def translate(locale, key, options = {})
           super
 

data/lib/i18n/backend/active_record/translation.rb

@@ -73,7 +73,8 @@ module I18n
           if is_proc
             Kernel.eval read_attribute(:value)
           else
-            read_attribute(:value)
+            value = read_attribute(:value)
+            value == 'f' ? false : value
           end
         end
       end

data/lib/i18n/backend/base.rb

@@ -26,18 +26,24 @@ module I18n
       end
 
       def translate(locale, key, options = {})
-        raise InvalidLocale.new(locale) if locale.nil?
+        raise InvalidLocale.new(locale) unless locale
         return key.map { |k| translate(locale, k, options) } if key.is_a?(Array)
 
-        count, scope, default, separator = options.values_at(:count, *RESERVED_KEYS)
-        values = options.reject { |name, value| RESERVED_KEYS.include?(name) }
+        if options.empty?
+          entry = resolve(locale, key, lookup(locale, key), options)
+          raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
+        else
+          count, scope, default, separator = options.values_at(:count, :scope, :default, :separator)
+          values = options.reject { |name, value| RESERVED_KEYS.include?(name) }
 
-        entry = lookup(locale, key, scope, separator)
-        entry = entry.nil? ? default(locale, key, default, options) : resolve(locale, key, entry, options)
+          entry = lookup(locale, key, scope, separator)
+          entry = entry.nil? && default ? default(locale, key, default, options) : resolve(locale, key, entry, options)
+          raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
+
+          entry = pluralize(locale, entry, count)    if count
+          entry = interpolate(locale, entry, values) if values
+        end
 
-        raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
-        entry = pluralize(locale, entry, count)
-        entry = interpolate(locale, entry, values)
         entry
       end
 
@@ -108,11 +114,10 @@ module I18n
           keys = I18n.send(:normalize_translation_keys, locale, key, scope, separator)
           keys.inject(translations) do |result, key|
             key = key.to_sym
-            if result.respond_to?(:has_key?) and result.has_key?(key)
-              result[key]
-            else
-              return nil
-            end
+            return nil unless result.is_a?(Hash) && result.has_key?(key)
+            result = result[key]
+            result = resolve(locale, key, result, :separator => separator) if result.is_a?(Symbol)
+            result
           end
         end
 
@@ -124,8 +129,8 @@ module I18n
           options = options.dup.reject { |key, value| key == :default }
           case subject
           when Array
-            subject.each do |subject|
-              result = resolve(locale, object, subject, options) and return result
+            subject.each do |item|
+              result = resolve(locale, object, item, options) and return result
             end and nil
           else
             resolve(locale, object, subject, options)
@@ -136,10 +141,10 @@ module I18n
         # If the given subject is a Symbol, it will be translated with the
         # given options. If it is a Proc then it will be evaluated. All other
         # subjects will be returned directly.
-        def resolve(locale, object, subject, options = {})
+        def resolve(locale, object, subject, options = nil)
           case subject
           when Symbol
-            I18n.translate(subject, options.merge(:locale => locale, :raise => true))
+            I18n.translate(subject, (options || {}).merge(:locale => locale, :raise => true))
           when Proc
             resolve(locale, object, subject.call(object, options), options = {})
           else

data/lib/i18n/backend/chain.rb

@@ -46,7 +46,7 @@ module I18n
             translation = backend.translate(locale, key, options)
             if namespace_lookup?(translation, options)
               namespace.update(translation)
-            elsif translation
+            elsif !translation.nil?
               return translation
             end
           rescue MissingTranslationData

data/lib/i18n/backend/fallbacks.rb

@@ -40,7 +40,8 @@ module I18n
       def translate(locale, key, options = {})
         I18n.fallbacks[locale].each do |fallback|
           begin
-            result = super(fallback, key, options) and return result
+            result = super(fallback, key, options)
+            return result unless result.nil?
           rescue I18n::MissingTranslationData
           end
         end

data/lib/i18n/backend/fast.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+# The Fast module contains optimizations that can tremendously speed up the
+# lookup process on the Simple backend. It works by flattening the nested
+# translation hash to a flat hash (e.g. { :a => { :b => 'c' } } becomes
+# { :'a.b' => 'c' }).
+#
+# To enable these optimizations you can simply include the Fast module to
+# the Simple backend:
+#
+#   I18n::Backend::Simple.send(:include, I18n::Backend::Fast)
+module I18n
+  module Backend
+    module Fast
+      SEPARATOR_ESCAPE_CHAR = "\001"
+
+      def reset_flattened_translations!
+        @flattened_translations = nil
+      end
+
+      def flattened_translations
+        @flattened_translations ||= flatten_translations(translations)
+      end
+
+      def merge_translations(locale, data)
+        super
+        reset_flattened_translations!
+      end
+
+      def init_translations
+        super
+        reset_flattened_translations!
+      end
+
+      protected
+        # flatten_hash({:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}})
+        # # => {:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}, :"b.f" => {:x=>"x"}, :"b.c"=>"c", :"b.f.x"=>"x", :"b.d"=>"d"}
+        def flatten_hash(h, nested_stack = [], flattened_h = {}, orig_h=h)
+          wind_keys(h, nil, true)
+        end
+
+        def flatten_translations(translations)
+          # don't flatten locale roots
+          translations.inject({}) do |flattened_h, (locale_name, locale_translations)|
+            flattened_h[locale_name] = flatten_hash(locale_translations)
+            flattened_h
+          end
+        end
+
+        def lookup(locale, key, scope = nil, separator = nil)
+          return unless key
+          init_translations unless initialized?
+
+          if separator && I18n.default_separator != separator
+            key   = cleanup_non_standard_separator(key, separator)
+            scope = Array(scope).map{|k| cleanup_non_standard_separator(k, separator)} if scope
+          end
+
+          key = (Array(scope) + [key]).join(I18n.default_separator) if scope
+          flattened_translations[locale.to_sym][key.to_sym]
+        end
+
+        def cleanup_non_standard_separator(key, user_separator)
+          escape_default_separator(key).tr(user_separator, I18n.default_separator)
+        end
+    end
+  end
+end

data/lib/i18n/backend/helpers.rb

@@ -1,6 +1,8 @@
 module I18n
   module Backend
     module Helpers
+      SEPARATOR_ESCAPE_CHAR = "\001"
+
       # Return a new hash with all keys and nested keys converted to symbols.
       def deep_symbolize_keys(hash)
         hash.inject({}) { |result, (key, value)|
@@ -13,16 +15,41 @@ module I18n
       # Flatten keys for nested Hashes by chaining up keys using the separator
       #   >> { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}.wind
       #   => { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }
-      def wind_keys(hash, separator = ".", prev_key = nil, result = {})
-        hash.inject(result) do |result, pair|
-          key, value = *pair
-          curr_key = [prev_key, key].compact.join(separator)
+      def wind_keys(hash, separator = nil, subtree = false, prev_key = nil, result = {}, orig_hash=hash)
+        separator ||= I18n.default_separator
+
+        hash.each_pair do |key, value|
+          key = escape_default_separator(key, separator)
+          curr_key = [prev_key, key].compact.join(separator).to_sym
+
+          if value.is_a?(Symbol)
+            value = hash_lookup(orig_hash, value, separator) ||
+                    hash_lookup(hash, value, separator) || value
+          end
+
           if value.is_a?(Hash)
-            wind_keys(value, separator, curr_key, result)
+            result[curr_key] = value if subtree
+            wind_keys(value, separator, subtree, curr_key, result, orig_hash)
           else
             result[curr_key] = value
           end
-          result
+        end
+
+        result
+      end
+
+      def escape_default_separator(key, separator=nil)
+        key.to_s.tr(separator || I18n.default_separator, SEPARATOR_ESCAPE_CHAR)
+      end
+
+      def hash_lookup(hash, keys, separator = ".")
+        keys.to_s.split(separator).inject(hash) do |result, key|
+          key = key.to_sym
+          if result.respond_to?(:has_key?) and result.has_key?(key)
+            result[key]
+          else
+            return nil
+          end
         end
       end
 
@@ -32,7 +59,7 @@ module I18n
       def unwind_keys(hash, separator = ".")
         result = {}
         hash.each do |key, value|
-          keys = key.split(separator)
+          keys = key.to_s.split(separator)
           curr = result
           curr = curr[keys.shift] ||= {} while keys.size > 1
           curr[keys.shift] = value

data/lib/i18n/backend/interpolation_compiler.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+# The InterpolationCompiler module contains optimizations that can tremendously
+# speed up the interpolation process on the Simple backend.
+#
+# It works by defining a pre-compiled method on stored translation Strings that
+# already bring all the knowledge about contained interpolation variables etc.
+# so that the actual recurring interpolation will be very fast.
+#
+# To enable pre-compiled interpolations you can simply include the
+# InterpolationCompiler module to the Simple backend:
+#
+#   I18n::Backend::Simple.send(:include, I18n::Backend::InterpolationCompiler)
+module I18n
+  module Backend
+    module InterpolationCompiler
+      module Compiler
+        extend self
+
+        TOKENIZER                    = /(\\\{\{[^\}]+\}\}|\{\{[^\}]+\}\})/
+        INTERPOLATION_SYNTAX_PATTERN = /(\\)?(\{\{([^\}]+)\}\})/
+
+        def compile_if_an_interpolation(string)
+          if interpolated_str?(string)
+            string.instance_eval <<-RUBY_EVAL, __FILE__, __LINE__
+              def i18n_interpolate(v = {})
+                "#{compiled_interpolation_body(string)}"
+              end
+            RUBY_EVAL
+          end
+
+          string
+        end
+
+        def interpolated_str?(str)
+          str.kind_of?(String) && str =~ INTERPOLATION_SYNTAX_PATTERN
+        end
+
+        protected
+        # tokenize("foo {{bar}} baz \\{{buz}}") # => ["foo ", "{{bar}}", " baz ", "\\{{buz}}"]
+        def tokenize(str)
+          str.split(TOKENIZER)
+        end
+
+        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)
+          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)
+        end
+
+        def compile_interpolation_token(key)
+          "\#{#{interpolate_or_raise_missing(key)}}"
+        end
+
+        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)
+        end
+
+        def interpolate_key(key)
+          [direct_key(key), nil_key(key), missing_key(key)].join('||')
+        end
+
+        def direct_key(key)
+          "((t = v[#{key}]) && t.respond_to?(:call) ? t.call : t)"
+        end
+
+        def nil_key(key)
+          "(v.has_key?(#{key}) && '')"
+        end
+
+        def missing_key(key)
+          "raise(MissingInterpolationArgument.new(#{key}, self))"
+        end
+
+        def reserved_key(key)
+          "raise(ReservedInterpolationKey.new(#{key}, self))"
+        end
+
+        def escape_plain_str(str)
+          str.gsub(/"|\\|#/) {|x| "\\#{x}"}
+        end
+
+        def escape_key_sym(key)
+          # rely on Ruby to do all the hard work :)
+          key.to_sym.inspect
+        end
+      end
+
+      def interpolate(locale, string, values)
+        if string.respond_to?(:i18n_interpolate)
+          string.i18n_interpolate(values)
+        elsif values
+          super
+        else
+          string
+        end
+      end
+
+      def merge_translations(locale, data)
+        compile_all_strings_in(data)
+        super
+      end
+
+      protected
+      def compile_all_strings_in(data)
+        data.each_value do |value|
+          Compiler.compile_if_an_interpolation(value)
+          compile_all_strings_in(value) if value.kind_of?(Hash)
+        end
+      end
+    end
+  end
+end

data/lib/i18n/exceptions.rb

@@ -19,8 +19,8 @@ module I18n
 
   class MissingTranslationData < ArgumentError
     attr_reader :locale, :key, :options
-    def initialize(locale, key, options)
-      @key, @locale, @options = key, locale, options
+    def initialize(locale, key, opts = nil)
+      @key, @locale, @options = key, locale, opts || {}
       keys = I18n.send(:normalize_translation_keys, locale, key, options[:scope])
       keys << 'no key' if keys.size < 2
       super "translation missing: #{keys.join(', ')}"

data/lib/i18n/version.rb

@@ -0,0 +1,3 @@
+module I18n
+  VERSION = "0.3.3"
+end

data/test/api/link.rb

@@ -3,38 +3,53 @@
 module Tests
   module Api
     module Link
-      define_method "test linked lookup: given the key resolves to a symbol it looks up the symbol" do
-        setup_linked_translations
-        assert_equal 'foo', I18n.backend.translate('en', :link_to_foo)
+      define_method "test linked lookup: if a key resolves to a symbol it looks up the symbol" do
+        I18n.backend.store_translations 'en', {
+          :link  => :linked,
+          :linked => 'linked'
+        }
+        assert_equal 'linked', I18n.backend.translate('en', :link)
       end
 
-      define_method "test linked lookup: given the key resolves to a dot-separated symbol it looks up the dot-separated symbol (1)" do
-        setup_linked_translations
-        assert_equal('baz', I18n.backend.translate('en', :link_to_baz))
+      define_method "test linked lookup: if a key resolves to a dot-separated symbol it looks up the symbol" do
+        I18n.backend.store_translations 'en', {
+          :link => :"foo.linked",
+          :foo  => { :linked => 'linked' }
+        }
+        assert_equal('linked', I18n.backend.translate('en', :link))
       end
-      
-      define_method "test linked lookup: given the key resolves to a dot-separated symbol it looks up the dot-separated symbol (2)" do
-        setup_linked_translations
-        assert_equal('buz', I18n.backend.translate('en', :'bar.link_to_buz'))
+
+      define_method "test linked lookup: if a dot-separated key resolves to a symbol it looks up the symbol" do
+        I18n.backend.store_translations 'en', {
+          :foo    => { :link => :linked },
+          :linked => 'linked'
+        }
+        assert_equal('linked', I18n.backend.translate('en', :'foo.link'))
       end
       
-      define_method "test linked lookup: given a scope and the key resolves to a symbol it looks up the symbol within the scope" do
-        setup_linked_translations
-        assert_equal('baz', I18n.backend.translate('en', :link_to_baz, :scope => :bar))
+      define_method "test linked lookup: if a dot-separated key resolves to a dot-separated symbol it looks up the symbol" do
+        I18n.backend.store_translations 'en', {
+          :foo => { :link   => :"bar.linked" },
+          :bar => { :linked => 'linked' }
+        }
+        assert_equal('linked', I18n.backend.translate('en', :'foo.link'))
       end
       
-      protected
+      define_method "test linked lookup: links refer to absolute keys even if a scope was given" do
+        I18n.backend.store_translations 'en', {
+          :foo => { :link  => :linked, :linked => 'linked in foo' },
+          :linked => 'linked absolutely'
+        }
+        assert_equal 'linked absolutely', I18n.backend.translate('en', :link, :scope => :foo)
+      end
 
-        def setup_linked_translations
-          I18n.backend.store_translations 'en', {
-            :foo => 'foo',
-            :bar => { :baz => 'baz', :link_to_baz => :baz, :link_to_buz => :'boz.buz' },
-            :boz => { :buz => 'buz' },
-            :link_to_foo => :foo,
-            :link_to_bar => :bar,
-            :link_to_baz => :'bar.baz'
-          }
-        end
+      define_method "test linked lookup: a link can resolve to a namespace in the middle of a dot-separated key" do
+        I18n.backend.store_translations 'en', {
+          :activemodel  => { :errors => { :messages => { :blank => "can't be blank" } } },
+          :activerecord => { :errors => { :messages => :"activemodel.errors.messages" } }
+        }
+        assert_equal "can't be blank", I18n.t(:"activerecord.errors.messages.blank")
+      end
     end
   end
 end

data/test/api/lookup.rb

@@ -5,17 +5,21 @@ module Tests
     module Lookup
       def setup
         super
-        store_translations(:foo => { :bar => 'bar', :baz => 'baz' })
+        store_translations(:foo => { :bar => 'bar', :baz => 'baz' }, :bla => false)
       end
-      
+
       define_method "test lookup: given a nested key it looks up the nested hash value" do
         assert_equal 'bar', I18n.t(:'foo.bar')
       end
 
+      define_method "test make sure we can store a native false value as well" do
+        assert_equal false, I18n.t(:bla)
+      end
+
       define_method "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)
       end
-      
+
       define_method "test lookup: given a missing key, no default and the raise option it raises MissingTranslationData" do
         assert_raises(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
       end

data/test/cases/api/all_features_test.rb

@@ -7,8 +7,11 @@ class I18nAllFeaturesApiTest < Test::Unit::TestCase
     include I18n::Backend::Base
     include I18n::Backend::Cache
     include I18n::Backend::Metadata
+    include I18n::Backend::Cascade
     include I18n::Backend::Fallbacks
     include I18n::Backend::Pluralization
+    include I18n::Backend::Fast
+    include I18n::Backend::InterpolationCompiler
   end
 
   def setup

data/test/cases/api/cascade_test.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class I18nCascadeApiTest < Test::Unit::TestCase
+  class Backend
+    include I18n::Backend::Base
+    include I18n::Backend::Cascade
+  end
+
+  def setup
+    I18n.backend = Backend.new
+    super
+  end
+
+  include Tests::Api::Basics
+  include Tests::Api::Defaults
+  include Tests::Api::Interpolation
+  include Tests::Api::Link
+  include Tests::Api::Lookup
+  include Tests::Api::Pluralization
+  include Tests::Api::Procs
+  include Tests::Api::Localization::Date
+  include Tests::Api::Localization::DateTime
+  include Tests::Api::Localization::Time
+  include Tests::Api::Localization::Procs
+
+  define_method "test: make sure we use a backend with Cascade included" do
+    assert_equal Backend, I18n.backend.class
+  end
+end

data/test/cases/api/fast_test.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class I18nFastBackendApiTest < Test::Unit::TestCase
+  include Tests::Api::Basics
+  include Tests::Api::Defaults
+  include Tests::Api::Interpolation
+  include Tests::Api::Link
+  include Tests::Api::Lookup
+  include Tests::Api::Pluralization
+  include Tests::Api::Procs
+  include Tests::Api::Localization::Date
+  include Tests::Api::Localization::DateTime
+  include Tests::Api::Localization::Time
+  include Tests::Api::Localization::Procs
+  
+  class FastBackend
+    include I18n::Backend::Base
+    include I18n::Backend::Fast
+  end
+
+  def setup
+    I18n.backend = FastBackend.new
+    super
+  end
+  
+  define_method "test: make sure we use the FastBackend backend" do
+    assert_equal FastBackend, I18n.backend.class
+  end
+end

data/test/cases/backend/active_record/missing_test.rb

@@ -5,7 +5,7 @@ setup_active_record
 
 class I18nActiveRecordMissingTest < Test::Unit::TestCase
   def setup
-    store_translations(:en, :i18n => { :plural_keys => [:zero, :one, :other] })
+    store_translations(:en, :i18n => { :plural => { :keys => [:zero, :one, :other] } })
     
     I18n.backend = I18n::Backend::Chain.new(I18n.backend)
     I18n.backend.meta_class.send(:include, I18n::Backend::ActiveRecord::Missing)

data/test/cases/backend/fast_test.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/simple_test')
+
+class I18nBackendFastTest < I18nBackendSimpleTest
+  class FastBackend
+    include I18n::Backend::Base
+    include I18n::Backend::Fast
+  end
+  
+  def setup
+    super
+    I18n.backend = FastBackend.new
+  end
+end
+
+class I18nBackendFastSpecificTest < Test::Unit::TestCase
+  class FastBackend
+    include I18n::Backend::Base
+    include I18n::Backend::Fast
+  end
+  
+  def setup
+    @backend = FastBackend.new
+  end
+
+  def assert_flattens(expected, nested)
+    assert_equal expected, @backend.send(:flatten_hash, nested)
+  end
+
+  def test_hash_flattening_works
+    assert_flattens(
+      {:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}, :"b.f" => {:x=>"x"}, :"b.c"=>"c", :"b.f.x"=>"x", :"b.d"=>"d"},
+      {:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}}
+    )
+    assert_flattens({:a=>{:b =>['a', 'b']}, :"a.b"=>['a', 'b']}, {:a=>{:b =>['a', 'b']}})
+  end
+
+  def test_pluralization_logic_and_lookup_works
+    counts_hash = {:zero => 'zero', :one => 'one', :other => 'other'}
+    @backend.store_translations :en, {:a => counts_hash}
+    assert_equal 'one', @backend.translate(:en, :a, :count => 1)
+  end
+
+  def test_translation_subtree_retrieval
+    @backend.store_translations :en, :a => {:foo => 'bar'}
+    assert_equal({:foo => 'bar'}, @backend.translate(:en, :a))
+  end
+end

data/test/cases/backend/helpers_test.rb

@@ -8,12 +8,12 @@ class I18nBackendHelpersTest < Test::Unit::TestCase
   
   def test_wind_keys
     hash = { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}
-    expected = { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }
+    expected = { :"a.b.c" => "d", :"a.b.e" => "f", :"a.g" => "h", :"i" => "j" }
     assert_equal expected, @backend.wind_keys(hash)
   end
 
   def test_unwind_keys
-    hash = { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }
+    hash = { "a.b.c" => "d", :"a.b.e" => "f", :"a.g" => "h", "i" => "j" }
     expected = { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}
     assert_equal expected, @backend.unwind_keys(hash)
   end

data/test/cases/backend/interpolation_compiler_test.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class InterpolationCompilerTest < Test::Unit::TestCase
+  Compiler = I18n::Backend::InterpolationCompiler::Compiler
+
+  def compile_and_interpolate(str, values = {})
+    Compiler.compile_if_an_interpolation(str).i18n_interpolate(values)
+  end
+
+  def assert_escapes_interpolation_key(expected, malicious_str)
+    assert_equal(expected, Compiler.send(:escape_key_sym, malicious_str))
+  end
+
+  def test_escape_key_properly_escapes
+    assert_escapes_interpolation_key ':"\""',       '"'
+    assert_escapes_interpolation_key ':"\\\\"',     '\\'
+    assert_escapes_interpolation_key ':"\\\\\""',   '\\"'
+    assert_escapes_interpolation_key ':"\#{}"',     '#{}'
+    assert_escapes_interpolation_key ':"\\\\\#{}"', '\#{}'
+  end
+
+  def assert_escapes_plain_string(expected, plain_str)
+    assert_equal expected, Compiler.send(:escape_plain_str, plain_str)
+  end
+
+  def test_escape_plain_string_properly_escapes
+    assert_escapes_plain_string '\\"',    '"'
+    assert_escapes_plain_string '\'',     '\''
+    assert_escapes_plain_string '\\#',    '#'
+    assert_escapes_plain_string '\\#{}',  '#{}'
+    assert_escapes_plain_string '\\\\\\"','\\"'
+  end
+
+  def test_non_interpolated_strings_or_arrays_dont_get_compiled
+    ['abc', '\\{a}}', '{a}}', []].each do |obj|
+      Compiler.compile_if_an_interpolation(obj)
+      assert_equal false, obj.respond_to?(:i18n_interpolate)
+    end
+  end
+
+  def test_interpolated_string_gets_compiled
+    assert_equal '-A-', compile_and_interpolate('-{{a}}-', :a => 'A')
+  end
+
+  def assert_handles_key(str, key)
+    assert_equal 'A', compile_and_interpolate(str, key => 'A')
+  end
+
+  def test_compiles_fancy_keys
+    assert_handles_key('{{\}}',      :'\\'    )
+    assert_handles_key('{{#}}',      :'#'     )
+    assert_handles_key('{{#{}}',     :'#{'    )
+    assert_handles_key('{{#$SAFE}}', :'#$SAFE')
+    assert_handles_key('{{\000}}',   :'\000'  )
+    assert_handles_key('{{\'}}',     :'\''    )
+    assert_handles_key('{{\'\'}}',   :'\'\''  )
+    assert_handles_key('{{a.b}}',    :'a.b'   )
+    assert_handles_key('{{ }}',      :' '     )
+    assert_handles_key('{{:}}',      :':'     )
+    assert_handles_key("{{:''}}",    :":''"   )
+    assert_handles_key('{{:"}}',     :':"'    )
+  end
+
+  def test_str_containing_only_escaped_interpolation_is_handled_correctly
+    assert_equal 'abc {{x}}', compile_and_interpolate('abc \\{{x}}')
+  end
+
+  def test_handles_weired_strings
+    assert_equal '#{} a',         compile_and_interpolate('#{} {{a}}',        :a    => 'a')
+    assert_equal '"#{abc}"',      compile_and_interpolate('"#{ab{{a}}c}"',    :a    => '' )
+    assert_equal 'a}',            compile_and_interpolate('{{{a}}}',          :'{a' => 'a')
+    assert_equal '"',             compile_and_interpolate('"{{a}}',           :a    => '' )
+    assert_equal 'a{{a}}',        compile_and_interpolate('{{a}}\\{{a}}',     :a    => 'a')
+    assert_equal '\\{{a}}',       compile_and_interpolate('\\\\{{a}}')
+    assert_equal '\";eval("a")',  compile_and_interpolate('\";eval("{{a}}")', :a    => 'a')
+    assert_equal '\";eval("a")',  compile_and_interpolate('\";eval("a"){{a}}',:a    => '' )
+    assert_equal "\na",           compile_and_interpolate("\n{{a}}",          :a    => 'a')
+  end
+end
+
+class I18nBackendInterpolationCompilerTest < Test::Unit::TestCase
+  class Backend
+    include I18n::Backend::Base
+    include I18n::Backend::InterpolationCompiler
+  end
+  
+  include Tests::Api::Interpolation
+
+  def setup
+    I18n.backend = Backend.new
+    super
+  end
+  
+  # pre-compile default strings to make sure we are testing I18n::Backend::InterpolationCompiler
+  def interpolate(*args)
+    options = args.last.kind_of?(Hash) ? args.last : {}
+    if default_str = options[:default]
+      I18n::Backend::InterpolationCompiler::Compiler.compile_if_an_interpolation(default_str)
+    end
+    super
+  end
+  
+  # I kinda don't think this really is a correct behavior
+  undef :'test interpolation: given no values it does not alter the string'
+end

data/test/cases/backend/metadata_test.rb

@@ -39,7 +39,7 @@ class I18nBackendMetadataTest < Test::Unit::TestCase
   end
 
   define_method "test: translate adds the default to metadata on Strings" do
-    assert_equal 'bar', I18n.t(:foo, :default => 'bar').translation_metadata[:default]
+    assert_equal 'bar', I18n.t(:foo, :default => 'bar', :name => '').translation_metadata[:default]
   end
 
   define_method "test: translation adds the interpolation values to metadata on Strings" do

data/test/cases/i18n_test.rb

@@ -62,6 +62,11 @@ class I18nTest < Test::Unit::TestCase
     assert_equal [:en, :foo, :bar, :baz, :buz], I18n.send(:normalize_translation_keys, :en, [:baz, :buz], [:foo, :bar])
   end
 
+  def test_normalize_keys_should_not_attempt_to_sym_on_empty_string
+    assert_equal [:en, :foo, :bar, :baz, :buz], I18n.send(:normalize_translation_keys, :en, :'baz.buz', :'foo..bar')
+    assert_equal [:en, :foo, :bar, :baz, :buz], I18n.send(:normalize_translation_keys, :en, :'baz.buz', :'foo......bar')
+  end
+
   def test_uses_passed_separator_to_normalize_keys
     assert_equal [:en, :foo, :bar, :baz, :buz], I18n.send(:normalize_translation_keys, :en, :'baz|buz', :'foo|bar', '|')
   end

data/test/test_helper.rb

@@ -1,12 +1,13 @@
 # encoding: utf-8
 
-$: << "lib"
-$: << File.expand_path(File.dirname(__FILE__))
+$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
+$:.unshift File.expand_path(File.dirname(__FILE__))
 
-require 'rubygems'
-require 'test/unit'
 require 'i18n'
 require 'i18n/core_ext/object/meta_class'
+
+require 'rubygems'
+require 'test/unit'
 require 'time'
 require 'yaml'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: i18n
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-12 00:00:00 +01:00
+date: 2009-12-29 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -30,7 +30,6 @@ files:
 - MIT-LICENSE
 - README.textile
 - Rakefile
-- VERSION
 - lib/i18n.rb
 - lib/i18n/backend.rb
 - lib/i18n/backend/active_record.rb
@@ -42,8 +41,10 @@ files:
 - lib/i18n/backend/cascade.rb
 - lib/i18n/backend/chain.rb
 - lib/i18n/backend/fallbacks.rb
+- lib/i18n/backend/fast.rb
 - lib/i18n/backend/gettext.rb
 - lib/i18n/backend/helpers.rb
+- lib/i18n/backend/interpolation_compiler.rb
 - lib/i18n/backend/metadata.rb
 - lib/i18n/backend/pluralization.rb
 - lib/i18n/backend/simple.rb
@@ -59,6 +60,7 @@ files:
 - lib/i18n/locale/tag/parents.rb
 - lib/i18n/locale/tag/rfc4646.rb
 - lib/i18n/locale/tag/simple.rb
+- lib/i18n/version.rb
 - test/all.rb
 - test/api/basics.rb
 - test/api/defaults.rb
@@ -73,8 +75,10 @@ files:
 - test/api/procs.rb
 - test/cases/api/active_record_test.rb
 - test/cases/api/all_features_test.rb
+- test/cases/api/cascade_test.rb
 - test/cases/api/chain_test.rb
 - test/cases/api/fallbacks_test.rb
+- test/cases/api/fast_test.rb
 - test/cases/api/pluralization_test.rb
 - test/cases/api/simple_test.rb
 - test/cases/backend/active_record/missing_test.rb
@@ -83,7 +87,9 @@ files:
 - test/cases/backend/cascade_test.rb
 - test/cases/backend/chain_test.rb
 - test/cases/backend/fallbacks_test.rb
+- test/cases/backend/fast_test.rb
 - test/cases/backend/helpers_test.rb
+- test/cases/backend/interpolation_compiler_test.rb
 - test/cases/backend/metadata_test.rb
 - test/cases/backend/pluralization_test.rb
 - test/cases/backend/simple_test.rb
@@ -145,8 +151,10 @@ test_files:
 - test/api/procs.rb
 - test/cases/api/active_record_test.rb
 - test/cases/api/all_features_test.rb
+- test/cases/api/cascade_test.rb
 - test/cases/api/chain_test.rb
 - test/cases/api/fallbacks_test.rb
+- test/cases/api/fast_test.rb
 - test/cases/api/pluralization_test.rb
 - test/cases/api/simple_test.rb
 - test/cases/backend/active_record/missing_test.rb
@@ -155,7 +163,9 @@ test_files:
 - test/cases/backend/cascade_test.rb
 - test/cases/backend/chain_test.rb
 - test/cases/backend/fallbacks_test.rb
+- test/cases/backend/fast_test.rb
 - test/cases/backend/helpers_test.rb
+- test/cases/backend/interpolation_compiler_test.rb
 - test/cases/backend/metadata_test.rb
 - test/cases/backend/pluralization_test.rb
 - test/cases/backend/simple_test.rb

data/VERSION

@@ -1 +0,0 @@
-0.3.2