thedarkone-i18n 0.1.4 → 0.2.0

data/test/backend/chain/chain_test.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/chain'
+
+class I18nChainBackendTest < Test::Unit::TestCase
+  def setup
+    @first  = backend(:en => { 
+      :foo => 'Foo', :formats => { :short => 'short' }, :plural_1 => { :one => '{{count}}' }
+    })
+    @second = backend(:en => { 
+      :bar => 'Bar', :formats => { :long => 'long' }, :plural_2 => { :one => 'one' }
+    })
+    @chain  = I18n.backend = I18n::Backend::Chain.new(@first, @second)
+  end
+
+  define_method "test: looks up translations from the first chained backend" do
+    assert_equal 'Foo', @first.send(:translations)[:en][:foo]
+    assert_equal 'Foo', I18n.t(:foo)
+  end
+  
+  define_method "test: looks up translations from the second chained backend" do
+    assert_equal 'Bar', @second.send(:translations)[:en][:bar]
+    assert_equal 'Bar', I18n.t(:bar)
+  end
+  
+  define_method "test: defaults only apply to lookups on the last backend in the chain" do
+    assert_equal 'Foo', I18n.t(:foo, :default => 'Bah')
+    assert_equal 'Bar', I18n.t(:bar, :default => 'Bah')
+    assert_equal 'Bah', I18n.t(:bah, :default => 'Bah') # default kicks in only here
+  end
+  
+  define_method "test: default" do
+    assert_equal 'Fuh',  I18n.t(:default => 'Fuh')
+    assert_equal 'Zero', I18n.t(:default => { :zero => 'Zero' }, :count => 0)
+    assert_equal({ :zero => 'Zero' }, I18n.t(:default => { :zero => 'Zero' }))
+    assert_equal 'Foo', I18n.t(:default => :foo)
+  end
+  
+  define_method "test: namespace lookup collects results from all backends" do
+    assert_equal({ :short => 'short', :long => 'long' }, I18n.t(:formats))
+  end
+  
+  define_method "test: namespace lookup with only the first backend returning a result" do
+    assert_equal({ :one => '{{count}}' }, I18n.t(:plural_1))
+  end
+  
+  define_method "test: pluralization still works" do
+    assert_equal '1',   I18n.t(:plural_1, :count => 1)
+    assert_equal 'one', I18n.t(:plural_2, :count => 1)
+  end
+  
+  define_method "test: bulk lookup collects results from all backends" do
+    assert_equal ['Foo', 'Bar'], I18n.t([:foo, :bar])
+  end
+
+  protected
+
+    def backend(translations)
+      backend = I18n::Backend::Simple.new
+      translations.each { |locale, translations| backend.store_translations(locale, translations) }
+      backend
+    end
+end

data/test/backend/fallbacks/api_test.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/fallbacks'
+
+module FallbacksSetup
+  def setup
+    super
+    I18n.backend.meta_class.send(:include, I18n::Backend::Fallbacks)
+  end
+
+  def test_uses_fallbacks
+    assert I18n.backend.meta_class.included_modules.include?(I18n::Backend::Fallbacks)
+  end
+end
+
+class I18nFallbacksBackendApiBasicsTest < Test::Unit::TestCase
+  include FallbacksSetup
+  include Tests::Backend::Api::Basics
+end
+
+class I18nFallbacksBackendApiTranslateTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Translation
+end
+
+class I18nFallbacksBackendApiInterpolateTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Interpolation
+end
+
+class I18nFallbacksBackendApiLambdaTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Lambda
+end
+
+class I18nFallbacksBackendApiTranslateLinkedTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Link
+end
+
+class I18nFallbacksBackendApiPluralizationTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Pluralization
+end
+
+class I18nFallbacksBackendApiLocalizeDateTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include Tests::Backend::Simple::Setup::Localization
+  include FallbacksSetup
+  include Tests::Backend::Api::Localization::Date
+end
+
+class I18nFallbacksBackendApiLocalizeDateTimeTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include Tests::Backend::Simple::Setup::Localization
+  include FallbacksSetup
+  include Tests::Backend::Api::Localization::DateTime
+end
+
+class I18nFallbacksBackendApiLocalizeTimeTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include Tests::Backend::Simple::Setup::Localization
+  include FallbacksSetup
+  include Tests::Backend::Api::Localization::Time
+end
+
+class I18nFallbacksBackendApiLocalizeLambdaTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include Tests::Backend::Simple::Setup::Localization
+  include FallbacksSetup
+  include Tests::Backend::Api::Localization::Lambda
+end
+

data/test/backend/fallbacks/fallbacks_test.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/fallbacks'
+
+class I18nFallbacksBackendTest < Test::Unit::TestCase
+  def setup
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend.meta_class.send(:include, I18n::Backend::Fallbacks)
+    backend_store_translations(:en, :foo => 'Foo')
+  end
+
+  define_method "test: fallbacks for :de are [:de, :en]" do
+    assert_equal [:de, :en], I18n.fallbacks[:de]
+  end
+  
+  define_method "test: still returns the English translation as usual" do
+    assert_equal 'Foo', I18n.t(:foo, :locale => :en)
+  end
+  
+  define_method "test: returns the English translation for a missing German translation" do
+    assert_equal 'Foo', I18n.t(:foo, :locale => :de)
+  end
+  
+  define_method "test: raises I18n::MissingTranslationData exception when no translation was found" do
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:bar, :locale => :en, :raise => true) }
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:bar, :locale => :de, :raise => true) }
+  end
+end

data/test/backend/fast/all.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+Dir[File.dirname(__FILE__) + '/*_test.rb'].each do |file|
+  require file
+end

data/test/backend/fast/api_test.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class I18nFastBackendApiBasicsTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+  include Tests::Backend::Api::Basics
+
+  def test_uses_fast_backend
+    assert_equal I18n::Backend::Fast, I18n.backend.class
+  end
+end
+
+class I18nFastBackendApiTranslateTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+  include Tests::Backend::Api::Translation
+
+  # implementation specific tests
+  
+  def test_translate_calls_lookup_with_locale_given
+    I18n.backend.expects(:lookup).with('de', :bar, [:foo], nil).returns 'bar'
+    I18n.backend.translate 'de', :bar, :scope => [:foo]
+  end
+
+  def test_translate_calls_pluralize
+    I18n.backend.expects(:pluralize).with('en', 'bar', 1).returns('bar')
+    I18n.backend.translate 'en', :bar, :scope => [:foo], :count => 1
+  end
+end
+
+class I18nFastBackendApiInterpolateTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+  include Tests::Backend::Api::Interpolation
+  
+  # pre-compile default strings to make sure we are testing I18n::Fast::InterpolationCompiler
+  def interpolate(options)
+    if default_str = options[:default]
+      I18n::Backend::Fast::InterpolationCompiler.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_interpolation_values_it_does_not_alter_the_string
+
+  # implementation specific tests
+  
+  def test_interpolate_given_nil_as_a_string_returns_nil
+    assert_nil I18n.backend.send(:interpolate, nil, nil, :name => 'David')
+  end
+
+  def test_interpolate_given_an_non_string_as_a_string_returns_nil
+    assert_equal [], I18n.backend.send(:interpolate, nil, [], :name => 'David')
+  end
+end
+
+class I18nFastBackendApiLambdaTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+  include Tests::Backend::Api::Lambda
+end
+
+class I18nFastBackendApiTranslateLinkedTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+  include Tests::Backend::Api::Link
+end
+
+class I18nFastBackendApiPluralizationTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+  include Tests::Backend::Api::Pluralization
+end
+
+class I18nFastBackendApiLocalizeDateTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Localization
+  include Tests::Backend::Api::Localization::Date
+end
+
+class I18nFastBackendApiLocalizeDateTimeTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Localization
+  include Tests::Backend::Api::Localization::DateTime
+end
+
+class I18nFastBackendApiLocalizeTimeTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Localization
+  include Tests::Backend::Api::Localization::Time
+end
+
+class I18nFastBackendApiLocalizeLambdaTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Localization
+  include Tests::Backend::Api::Localization::Lambda
+end
+

data/test/backend/fast/interpolation_compiler_test.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+$:.unshift "lib"
+
+require 'rubygems'
+require 'test/unit'
+require 'i18n'
+
+InterpolationCompiler = I18n::Backend::Fast::InterpolationCompiler
+
+class InterpolationCompilerTest < Test::Unit::TestCase
+  def compile_and_interpolate(str, values = {})
+    InterpolationCompiler.compile_if_an_interpolation(str).i18n_interpolate(values)
+  end
+
+  def assert_escapes_interpolation_key(expected, malicious_str)
+    assert_equal(expected, InterpolationCompiler.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, InterpolationCompiler.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|
+      InterpolationCompiler.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    => '' )
+  end
+
+end

data/test/backend/fast/lookup_test.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class I18nFastBackendLookupTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+
+  # useful because this way we can use the backend with no key for interpolation/pluralization
+  def test_lookup_given_nil_as_a_key_returns_nil
+    assert_nil I18n.backend.send(:lookup, :en, nil)
+  end
+
+  def test_lookup_given_nested_keys_looks_up_a_nested_hash_value
+    assert_equal 'bar', I18n.backend.send(:lookup, :en, :bar, [:foo])
+  end
+
+  def test_lookup_using_a_custom_separator
+    assert_equal 'bar', I18n.backend.send(:lookup, :en, 'foo|bar', [], '|')
+  end
+
+  def test_default_using_a_custom_separator
+    assert_equal 'bar', I18n.backend.send(:default, :en, :'does_not_exist', :'foo|bar', :separator => '|')
+  end
+end

data/test/backend/fast/setup.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Tests
+  module Backend
+    module Fast
+      module Setup
+        module Base
+          include Tests::Backend::Simple::Setup::Base
+          
+          def new_backend
+            I18n::Backend::Fast.new
+          end
+        end
+
+        module Localization
+          include Base
+          include Tests::Backend::Simple::Setup::Localization
+        end
+      end
+    end
+  end
+end

data/test/backend/fast/translations_test.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class I18nFastBackendLoadTranslationsTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+
+  def test_load_translations_with_unknown_file_type_raises_exception
+    assert_raises(I18n::UnknownFileType) { I18n.backend.load_translations "#{locales_dir}/en.xml" }
+  end
+
+  def test_load_translations_with_ruby_file_type_does_not_raise_exception
+    assert_nothing_raised { I18n.backend.load_translations "#{locales_dir}/en.rb" }
+  end
+
+  def test_load_rb_loads_data_from_ruby_file
+    data = I18n.backend.send :load_rb, "#{locales_dir}/en.rb"
+    assert_equal({ :en => { :fuh => { :bah => 'bas' } } }, data)
+  end
+
+  def test_load_rb_loads_data_from_yaml_file
+    data = I18n.backend.send :load_yml, "#{locales_dir}/en.yml"
+    assert_equal({ 'en' => { 'foo' => { 'bar' => 'baz' } } }, data)
+  end
+
+  def test_load_translations_loads_from_different_file_formats
+    I18n.backend = I18n::Backend::Fast.new
+    I18n.backend.load_translations "#{locales_dir}/en.rb", "#{locales_dir}/en.yml"
+    expected = { :en => { :fuh => { :bah => "bas" }, :foo => { :bar => "baz" } } }
+    assert_equal expected, backend_get_translations
+  end
+end
+
+class I18nFastBackendStoreTranslationsTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+
+  def test_store_translations_adds_translations # no, really :-)
+    I18n.backend.store_translations :'en', :foo => 'bar'
+    assert_equal Hash[:'en', {:foo => 'bar'}], backend_get_translations
+  end
+
+  def test_store_translations_deep_merges_translations
+    I18n.backend.store_translations :'en', :foo => {:bar => 'bar'}
+    I18n.backend.store_translations :'en', :foo => {:baz => 'baz'}
+    assert_equal Hash[:'en', {:foo => {:bar => 'bar', :baz => 'baz'}}], backend_get_translations
+  end
+
+  def test_store_translations_forces_locale_to_sym
+    I18n.backend.store_translations 'en', :foo => 'bar'
+    assert_equal Hash[:'en', {:foo => 'bar'}], backend_get_translations
+  end
+
+  def test_store_translations_converts_keys_to_symbols
+    # backend_reset_translations!
+    I18n.backend.store_translations 'en', 'foo' => {'bar' => 'bar', 'baz' => 'baz'}
+    assert_equal Hash[:'en', {:foo => {:bar => 'bar', :baz => 'baz'}}], backend_get_translations
+  end
+
+  def test_deep_symbolize_keys_works
+    result = I18n.backend.send :deep_symbolize_keys, 'foo' => {'bar' => {'baz' => 'bar'}}
+    expected = {:foo => {:bar => {:baz => 'bar'}}}
+    assert_equal expected, result
+  end
+end
+
+class I18nFastBackendReloadTranslationsTest < Test::Unit::TestCase
+  include Tests::Backend::Fast::Setup::Base
+
+  def setup
+    I18n.backend = I18n::Backend::Fast.new
+    I18n.load_path = [locales_dir + '/en.yml']
+    assert_nil backend_get_translations
+    I18n.backend.send :init_translations
+  end
+
+  def test_setup
+    assert_not_nil backend_get_translations
+  end
+
+  def test_reload_translations_unloads_translations
+    I18n.backend.reload!
+    assert_nil backend_get_translations
+  end
+
+  def test_reload_translations_uninitializes_translations
+    I18n.backend.reload!
+    assert_equal I18n.backend.initialized?, false
+  end
+end