i18n 0.3.6 → 0.3.7

data/test/backend/exceptions_test.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-
-class I18nBackendExceptionsTest < Test::Unit::TestCase
-  def setup
-    I18n.backend = I18n::Backend::Simple.new
-  end
-
-  test "exceptions: MissingTranslationData message from #translate includes the given scope and full key" do
-    begin
-      I18n.t(:'baz.missing', :scope => :'foo.bar', :raise => true)
-    rescue I18n::MissingTranslationData => exception
-    end
-    assert_equal "translation missing: en, foo, bar, baz, missing", exception.message
-  end
-
-  test "exceptions: MissingTranslationData message from #localize includes the given scope and full key" do
-    begin
-      I18n.l(Time.now, :format => :foo)
-    rescue I18n::MissingTranslationData => exception
-    end
-    assert_equal "translation missing: en, time, formats, foo", exception.message
-  end
-end

data/test/backend/fallbacks_test.rb

@@ -1,107 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-
-class I18nBackendFallbacksTranslateTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Fallbacks
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    store_translations(:en, :foo => 'Foo in :en', :bar => 'Bar in :en', :buz => 'Buz in :en')
-    store_translations(:de, :bar => 'Bar in :de', :baz => 'Baz in :de')
-    store_translations(:'de-DE', :baz => 'Baz in :de-DE')
-  end
-
-  test "still returns an existing translation as usual" do
-    assert_equal 'Foo in :en', I18n.t(:foo, :locale => :en)
-    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :de)
-    assert_equal 'Baz in :de-DE', I18n.t(:baz, :locale => :'de-DE')
-  end
-
-  test "returns the :en translation for a missing :de translation" do
-    assert_equal 'Foo in :en', I18n.t(:foo, :locale => :de)
-  end
-
-  test "returns the :de translation for a missing :'de-DE' translation" do
-    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :'de-DE')
-  end
-
-  test "returns the :en translation for translation missing in both :de and :'de-De'" do
-    assert_equal 'Buz in :en', I18n.t(:buz, :locale => :'de-DE')
-  end
-
-  test "returns the :de translation for a missing :'de-DE' when :default is a String" do
-    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :'de-DE', :default => "Default Bar")
-    assert_equal "Default Bar", I18n.t(:missing_bar, :locale => :'de-DE', :default => "Default Bar")
-  end
-
-  test "returns the :'de-DE' default :baz translation for a missing :'de-DE' when defaults contains Symbol" do
-    assert_equal 'Baz in :de-DE', I18n.t(:missing_foo, :locale => :'de-DE', :default => [:baz, "Default Bar"])
-  end
-
-  test "returns the defaults translation for a missing :'de-DE' when defaults a contains String before Symbol" do
-    assert_equal "Default Bar", I18n.t(:missing_foo, :locale => :'de-DE', :default => [:missing_bar, "Default Bar", :baz])
-  end
-
-  test "returns the default translation for a missing :'de-DE' and existing :de when default is a Hash" do
-    assert_equal 'Default 6 Bars', I18n.t(:missing_foo, :locale => :'de-DE', :default => [:missing_bar, {:other => "Default {{count}} Bars"}, "Default Bar"], :count => 6)
-  end
-
-  test "raises I18n::MissingTranslationData exception when no translation was found" do
-    assert_raise(I18n::MissingTranslationData) { I18n.t(:faa, :locale => :en, :raise => true) }
-    assert_raise(I18n::MissingTranslationData) { I18n.t(:faa, :locale => :de, :raise => true) }
-  end
-end
-
-class I18nBackendFallbacksLocalizeTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Fallbacks
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    store_translations(:en, :date => { :formats => { :en => 'en' }, :day_names => %w(Sunday) })
-    store_translations(:de, :date => { :formats => { :de => 'de' } })
-  end
-
-  test "still uses an existing format as usual" do
-    assert_equal 'en', I18n.l(Date.today, :format => :en, :locale => :en)
-  end
-
-  test "looks up and uses a fallback locale's format for a key missing in the given locale (1)" do
-    assert_equal 'en', I18n.l(Date.today, :format => :en, :locale => :de)
-  end
-
-  test "looks up and uses a fallback locale's format for a key missing in the given locale (2)" do
-    assert_equal 'de', I18n.l(Date.today, :format => :de, :locale => :'de-DE')
-  end
-
-  test "still uses an existing day name translation as usual" do
-    assert_equal 'Sunday', I18n.l(Date.new(2010, 1, 3), :format => '%A', :locale => :en)
-  end
-
-  test "uses a fallback locale's translation for a key missing in the given locale" do
-    assert_equal 'Sunday', I18n.l(Date.new(2010, 1, 3), :format => '%A', :locale => :de)
-  end
-end
-
-class I18nBackendFallbacksWithChainTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Fallbacks
-  end
-
-  def setup
-    backend = Backend.new
-    backend.store_translations(:de, :foo => 'FOO')
-    I18n.backend = I18n::Backend::Chain.new(I18n::Backend::Simple.new, backend)
-  end
-
-  test "falls back from de-DE to de when there is no translation for de-DE available" do
-    assert_equal 'FOO', I18n.t(:foo, :locale => :'de-DE')
-  end
-end

data/test/backend/fast_test.rb

@@ -1,50 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-require 'backend/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(:wind_keys, nested, nil, true)
-  end
-
-  test "hash flattening works" do
-    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
-
-  test "pluralization logic and lookup works" do
-    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
-
-  test "translation subtree retrieval" do
-    @backend.store_translations :en, :a => {:foo => 'bar'}
-    assert_equal({:foo => 'bar'}, @backend.translate(:en, :a))
-  end
-end

data/test/backend/helpers_test.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-
-class I18nBackendHelpersTest < Test::Unit::TestCase
-  def setup
-    @backend = I18n::Backend::Simple.new
-  end
-  
-  test "wind_keys" do
-    hash = { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, :"i.a" => "j", "g.a" => "h"}
-    expected = { :"a.b.c" => "d", :"a.b.e" => "f", :"a.g" => "h", :"i.a" => "j", :"g.a" => "h" }
-    assert_equal expected, @backend.wind_keys(hash)
-  end
-
-  test "unwind_keys" do
-    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
-
-  test "deep_symbolize_keys" do
-    result = @backend.deep_symbolize_keys('foo' => { 'bar' => { 'baz' => 'bar' } })
-    expected = {:foo => {:bar => {:baz => 'bar'}}}
-    assert_equal expected, result
-  end
-end

data/test/backend/interpolation_compiler_test.rb

@@ -1,108 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-require 'api'
-
-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/backend/metadata_test.rb

@@ -1,66 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-
-class I18nBackendMetadataTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Metadata
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    store_translations(:en, :foo => 'Hi {{name}}')
-  end
-
-  test "translation strings carry metadata" do
-    translation = I18n.t(:foo)
-    assert translation.respond_to?(:translation_metadata)
-    assert translation.translation_metadata.is_a?(Hash)
-  end
-
-  test "translate preserves metadata stored on original Strings" do
-    store_metadata(:foo, :bar, 'bar')
-    assert_equal 'bar', I18n.t(:foo).translation_metadata[:bar]
-  end
-
-  test "translate preserves metadata stored on original Strings (when interpolated)" do
-    store_metadata(:foo, :bar, 'bar')
-    assert_equal 'bar', I18n.t(:foo, :name => 'David').translation_metadata[:bar]
-  end
-
-  test "translate adds the locale to metadata on Strings" do
-    assert_equal :en, I18n.t(:foo, :locale => :en).translation_metadata[:locale]
-  end
-
-  test "translate adds the key to metadata on Strings" do
-    assert_equal :foo, I18n.t(:foo).translation_metadata[:key]
-  end
-
-  test "translate adds the default to metadata on Strings" do
-    assert_equal 'bar', I18n.t(:foo, :default => 'bar', :name => '').translation_metadata[:default]
-  end
-
-  test "translation adds the interpolation values to metadata on Strings" do
-    assert_equal({:name => 'David'}, I18n.t(:foo, :name => 'David').translation_metadata[:values])
-  end
-
-  test "interpolation adds the original string to metadata on Strings" do
-    assert_equal('Hi {{name}}', I18n.t(:foo, :name => 'David').translation_metadata[:original])
-  end
-
-  test "pluralizatoin adds the count to metadata on Strings" do
-    assert_equal(1, I18n.t(:missing, :count => 1, :default => { :one => 'foo' }).translation_metadata[:count])
-  end
-  
-  protected
-  
-    def translations
-      I18n.backend.instance_variable_get(:@translations)
-    end
-
-    def store_metadata(key, name, value)
-      translations[:en][key].translation_metadata[name] = value
-    end
-end
-

data/test/backend/pluralization_test.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-
-class I18nBackendPluralizationTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Pluralization
-    include I18n::Backend::Fallbacks
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    @rule = lambda { |n| n == 1 ? :one : n == 0 || (2..10).include?(n % 100) ? :few : (11..19).include?(n % 100) ? :many : :other }
-    store_translations(:xx, :i18n => { :plural => { :rule => @rule } })
-    @entry = { :zero => 'zero', :one => 'one', :few => 'few', :many => 'many', :other => 'other' }
-  end
-
-  test "pluralization picks a pluralizer from :'i18n.pluralize'" do
-    assert_equal @rule, I18n.backend.send(:pluralizer, :xx)
-  end
-
-  test "pluralization picks :one for 1" do
-    assert_equal 'one', I18n.t(:count => 1, :default => @entry, :locale => :xx)
-  end
-
-  test "pluralization picks :few for 2" do
-    assert_equal 'few', I18n.t(:count => 2, :default => @entry, :locale => :xx)
-  end
-
-  test "pluralization picks :many for 11" do
-    assert_equal 'many', I18n.t(:count => 11, :default => @entry, :locale => :xx)
-  end
-
-  test "pluralization picks zero for 0 if the key is contained in the data" do
-    assert_equal 'zero', I18n.t(:count => 0, :default => @entry, :locale => :xx)
-  end
-
-  test "pluralization picks few for 0 if the key is not contained in the data" do
-    @entry.delete(:zero)
-    assert_equal 'few', I18n.t(:count => 0, :default => @entry, :locale => :xx)
-  end
-
-  test "Fallbacks can pick up rules from fallback locales, too" do
-    assert_equal @rule, I18n.backend.send(:pluralizer, :'xx-XX')
-  end
-end

data/test/backend/simple_test.rb

@@ -1,77 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-
-class I18nBackendSimpleTest < Test::Unit::TestCase
-  def setup
-    I18n.backend = I18n::Backend::Simple.new
-    I18n.load_path = [locales_dir + '/en.yml']
-  end
-
-  # useful because this way we can use the backend with no key for interpolation/pluralization
-  test "simple backend lookup: given nil as a key it returns nil" do
-    assert_nil I18n.backend.send(:lookup, :en, nil)
-  end
-  
-  # loading translations
-      
-  test "simple load_translations: given an unknown file type it raises I18n::UnknownFileType" do
-    assert_raise(I18n::UnknownFileType) { I18n.backend.load_translations("#{locales_dir}/en.xml") }
-  end
-  
-  test "simple load_translations: given a Ruby file name it does not raise anything" do
-    assert_nothing_raised { I18n.backend.load_translations("#{locales_dir}/en.rb") }
-  end
-  
-  test "simple load_rb: loads data from a Ruby file" do
-    data = I18n.backend.send(:load_rb, "#{locales_dir}/en.rb")
-    assert_equal({ :en => { :fuh => { :bah => 'bas' } } }, data)
-  end
-
-  test "simple load_yml: loads data from a YAML file" do
-    data = I18n.backend.send(:load_yml, "#{locales_dir}/en.yml")
-    assert_equal({ 'en' => { 'foo' => { 'bar' => 'baz' } } }, data)
-  end
-
-  test "simple load_translations: loads data from known file formats" do
-    I18n.backend = I18n::Backend::Simple.new
-    I18n.backend.load_translations("#{locales_dir}/en.rb", "#{locales_dir}/en.yml")
-    expected = { :en => { :fuh => { :bah => "bas" }, :foo => { :bar => "baz" } } }
-    assert_equal expected, translations
-  end
-  
-  # storing translations
-
-  test "simple store_translations: stores translations, ... no, really :-)" do
-    I18n.backend.store_translations :'en', :foo => 'bar'
-    assert_equal Hash[:'en', {:foo => 'bar'}], translations
-  end
-
-  test "simple store_translations: deep_merges with existing translations" do
-    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'}}], translations
-  end
-
-  test "simple store_translations: converts the given locale to a Symbol" do
-    I18n.backend.store_translations 'en', :foo => 'bar'
-    assert_equal Hash[:'en', {:foo => 'bar'}], translations
-  end
-
-  test "simple store_translations: converts keys to Symbols" do
-    I18n.backend.store_translations 'en', 'foo' => {'bar' => 'bar', 'baz' => 'baz'}
-    assert_equal Hash[:'en', {:foo => {:bar => 'bar', :baz => 'baz'}}], translations
-  end
-  
-  # reloading translations
-
-  test "simple reload_translations: unloads translations" do
-    I18n.backend.reload!
-    assert_nil translations
-  end
-
-  test "simple reload_translations: uninitializes the backend" do
-    I18n.backend.reload!
-    assert_equal I18n.backend.initialized?, false
-  end
-end