sayso-i18n 0.5.0.001

data/test/backend/cascade_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+class I18nBackendCascadeTest < Test::Unit::TestCase
+  class Backend < I18n::Backend::Simple
+    include I18n::Backend::Cascade
+  end
+
+  def setup
+    I18n.backend = Backend.new
+    store_translations(:en, :foo => 'foo', :bar => { :baz => 'baz' })
+    @cascade_options = { :step => 1, :offset => 1, :skip_root => false }
+  end
+
+  def lookup(key, options = {})
+    I18n.t(key, options.merge(:cascade => @cascade_options))
+  end
+
+  test "still returns an existing translation as usual" do
+    assert_equal 'foo', lookup(:foo)
+    assert_equal 'baz', lookup(:'bar.baz')
+  end
+
+  test "falls back by cutting keys off the end of the scope" do
+    assert_equal 'foo', lookup(:foo, :scope => :'missing')
+    assert_equal 'foo', lookup(:foo, :scope => :'missing.missing')
+    assert_equal 'baz', lookup(:baz, :scope => :'bar.missing')
+    assert_equal 'baz', lookup(:baz, :scope => :'bar.missing.missing')
+  end
+
+  test "raises I18n::MissingTranslationData exception when no translation was found" do
+    assert_raise(I18n::MissingTranslationData) { lookup(:'foo.missing', :raise => true) }
+    assert_raise(I18n::MissingTranslationData) { lookup(:'bar.baz.missing', :raise => true) }
+    assert_raise(I18n::MissingTranslationData) { lookup(:'missing.bar.baz', :raise => true) }
+  end
+
+  test "cascades before evaluating the default" do
+    assert_equal 'foo', lookup(:foo, :scope => :missing, :default => 'default')
+  end
+
+  test "cascades defaults, too" do
+    assert_equal 'foo', lookup(nil, :default => [:'missing.missing', :'missing.foo'])
+  end
+
+  test "works with :offset => 2 and a single key" do
+    @cascade_options[:offset] = 2
+    lookup(:foo)
+  end
+
+  test "assemble required fallbacks for ActiveRecord validation messages" do
+    store_translations(:en,
+      :errors => {
+        :odd => 'errors.odd',
+        :reply => { :title => { :blank => 'errors.reply.title.blank'   }, :taken  => 'errors.reply.taken'  },
+        :topic => { :title => { :format => 'errors.topic.title.format' }, :length => 'errors.topic.length' }
+      }
+    )
+    assert_equal 'errors.reply.title.blank',  lookup(:'errors.reply.title.blank',  :default => :'errors.topic.title.blank')
+    assert_equal 'errors.reply.taken',        lookup(:'errors.reply.title.taken',  :default => :'errors.topic.title.taken')
+    assert_equal 'errors.topic.title.format', lookup(:'errors.reply.title.format', :default => :'errors.topic.title.format')
+    assert_equal 'errors.topic.length',       lookup(:'errors.reply.title.length', :default => :'errors.topic.title.length')
+    assert_equal 'errors.odd',                lookup(:'errors.reply.title.odd',    :default => :'errors.topic.title.odd')
+  end
+
+  test "assemble action view translation helper lookup cascade" do
+    @cascade_options[:offset] = 2
+
+    store_translations(:en,
+      :menu => { :show => 'menu.show' },
+      :namespace => {
+        :menu => { :new => 'namespace.menu.new' },
+        :controller => {
+          :menu => { :edit => 'namespace.controller.menu.edit' },
+          :action => {
+            :menu => { :destroy => 'namespace.controller.action.menu.destroy' }
+          }
+        }
+      }
+    )
+
+    assert_equal 'menu.show',                                lookup(:'namespace.controller.action.menu.show')
+    assert_equal 'namespace.menu.new',                       lookup(:'namespace.controller.action.menu.new')
+    assert_equal 'namespace.controller.menu.edit',           lookup(:'namespace.controller.action.menu.edit')
+    assert_equal 'namespace.controller.action.menu.destroy', lookup(:'namespace.controller.action.menu.destroy')
+  end
+end

data/test/backend/chain_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+class I18nBackendChainTest < 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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  test 'default is returned if translation is missing' do
+    assert_equal({}, I18n.t(:'i18n.transliterate.rule', :locale => 'en', :default => {}))
+  end
+
+  test "namespace lookup collects results from all backends" do
+    assert_equal({ :short => 'short', :long => 'long' }, I18n.t(:formats))
+  end
+
+  test "namespace lookup with only the first backend returning a result" do
+    assert_equal({ :one => '%{count}' }, I18n.t(:plural_1))
+  end
+
+  test "pluralization still works" do
+    assert_equal '1',   I18n.t(:plural_1, :count => 1)
+    assert_equal 'one', I18n.t(:plural_2, :count => 1)
+  end
+
+  test "bulk lookup collects results from all backends" do
+    assert_equal ['Foo', 'Bar'], I18n.t([:foo, :bar])
+    assert_equal ['Foo', 'Bar', 'Bah'], I18n.t([:foo, :bar, :bah], :default => 'Bah')
+    assert_equal [{ :short => 'short', :long => 'long' }, { :one => 'one' }, 'Bah'], I18n.t([:formats, :plural_2, :bah], :default => 'Bah')
+  end
+
+  test "store_translations options are not dropped while transfering to backend" do
+    @first.expects(:store_translations).with(:foo, {:bar => :baz}, {:option => 'persists'})
+    I18n.backend.store_translations :foo, {:bar => :baz}, {:option => 'persists'}
+  end
+
+  protected
+
+    def backend(translations)
+      backend = I18n::Backend::Simple.new
+      translations.each { |locale, data| backend.store_translations(locale, data) }
+      backend
+    end
+end

data/test/backend/exceptions_test.rb

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,120 @@
+require 'test_helper'
+
+class I18nBackendFallbacksTranslateTest < Test::Unit::TestCase
+  class Backend < I18n::Backend::Simple
+    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 translation for a missing :'de-DE' when defaults is a Symbol (which exists in :en)" do
+    assert_equal "Bar in :de", I18n.t(:bar, :locale => :'de-DE', :default => [:buz])
+  end
+
+  test "returns the :'de-DE' default :baz translation for a missing :'de-DE' (which exists in :de)" do
+    assert_equal "Baz in :de-DE", I18n.t(:bar, :locale => :'de-DE', :default => [:baz])
+  end
+
+  test "returns the :de translation for a missing :'de-DE' when :default is a Proc" do
+    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :'de-DE', :default => Proc.new { "Default Bar" })
+    assert_equal "Default Bar", I18n.t(:missing_bar, :locale => :'de-DE', :default => Proc.new { "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 contains a String or Proc before Symbol" do
+    assert_equal "Default Bar", I18n.t(:missing_foo, :locale => :'de-DE', :default => [:missing_bar, "Default Bar", :baz])
+    assert_equal "Default Bar", I18n.t(:missing_foo, :locale => :'de-DE', :default => [:missing_bar, Proc.new { "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
+
+  test "should ensure that default is not splitted on new line char" do
+    assert_equal "Default \n Bar", I18n.t(:missing_bar, :default => "Default \n Bar")
+  end
+end
+
+class I18nBackendFallbacksLocalizeTest < Test::Unit::TestCase
+  class Backend < I18n::Backend::Simple
+    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 < I18n::Backend::Simple
+    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/flatten_yml_test.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
+require 'test_helper'
+require 'backend/simple_test'
+
+class I18nBackendFlattenYmlTest < I18nBackendSimpleTest
+  class FlattenYmlBackend
+    include I18n::Backend::Base
+    include I18n::Backend::FlattenYml
+  end
+  
+  def setup
+    super
+    I18n.backend = FlattenYmlBackend.new
+  end
+end
+
+class I18nBackendFlattenYmlSpecificTest < Test::Unit::TestCase
+  class FlattenYmlBackend
+    include I18n::Backend::Base
+    include I18n::Backend::FlattenYml
+  end
+  
+  def setup
+    @backend = FlattenYmlBackend.new
+  end
+
+  def assert_unified(expected, flattened)
+    assert_equal expected, @backend.send(:unify_hash, flattened)
+  end
+
+  test "unify_hash works" do
+    assert_unified(
+      {:a=>'a', :b=>{:c=>'c', :f=>{:x=>'x', :y=>'y', :z=>'z'}}, :c=>{:d=>{:e=>'e'}}},
+      {:a=>'a', :b=>{:c=>'c', :f=>{:x=>'x'}}, :"b.f.y" => "y", :"b.f.z" => "z", :"c.d.e"=>"e"}
+    )
+  end
+
+  test "translate" do
+    @backend.store_translations :en,  {:"a.b.c" => "foo", :x => {:y => {:z => "bar"}}}
+
+    assert_equal({:c=>"foo"}, @backend.translate(:en, :"a.b"))
+    assert_equal("foo", @backend.translate(:en, :"a.b.c"))
+
+    assert_equal({:z=>"bar"}, @backend.translate(:en, :"x.y"))
+    assert_equal("bar", @backend.translate(:en, :"x.y.z"))
+  end
+
+end

data/test/backend/interpolation_compiler_test.rb

@@ -0,0 +1,102 @@
+require '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_weird_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 < I18n::Backend::Simple
+    include I18n::Backend::InterpolationCompiler
+  end
+  
+  include I18n::Tests::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
+
+end