activesupport 2.3.5 → 2.3.6.pre

data/lib/active_support/vendor/i18n-0.3.3/test/cases/backend/cascade_test.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class I18nBackendCascadeTest < Test::Unit::TestCase
+  class Backend
+    include I18n::Backend::Base
+    include I18n::Backend::Cascade
+  end
+
+  def setup
+    I18n.backend = Backend.new
+    store_translations(:en,
+      :foo => 'foo',
+      :bar => { :baz => 'baz' }
+    )
+  end
+
+  define_method "test: still returns an existing translation as usual" do
+    assert_equal 'foo', I18n.t(:foo)
+    assert_equal 'baz', I18n.t(:'bar.baz')
+  end
+
+  define_method "test: falls back by cutting keys off the end of the scope" do
+    assert_equal 'foo', I18n.t(:'does_not_exist.foo')
+    assert_equal 'foo', I18n.t(:'does_not_exist.does_not_exist.foo')
+
+    assert_equal 'baz', I18n.t(:'bar.does_not_exist.baz')
+    assert_equal 'baz', I18n.t(:'bar.does_not_exist.does_not_exist.baz')
+  end
+
+  define_method "test: raises I18n::MissingTranslationData exception when no translation was found" do
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:'foo.does_not_exist', :raise => true) }
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:'bar.baz.does_not_exist', :raise => true) }
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:'does_not_exist.bar.baz', :raise => true) }
+  end
+
+  define_method "test: cascades before evaluating the default" do
+    assert_equal 'foo', I18n.t(:foo, :scope => :does_not_exist, :default => 'default')
+  end
+
+  define_method "test: let's us assemble required fallbacks for ActiveRecord validation messages" do
+    store_translations(:en,
+      :errors => {
+        :reply => {
+          :title => {
+            :blank => 'blank on reply title'
+          },
+          :taken => 'taken on reply'
+        },
+        :topic => {
+          :title => {
+            :format => 'format on topic title'
+          },
+          :length => 'length on topic'
+        },
+        :odd => 'odd on errors'
+      }
+    )
+    assert_equal 'blank on reply title',  I18n.t(:'errors.reply.title.blank',  :default => :'errors.topic.title.blank')
+    assert_equal 'taken on reply',        I18n.t(:'errors.reply.title.taken',  :default => :'errors.topic.title.taken')
+    assert_equal 'format on topic title', I18n.t(:'errors.reply.title.format', :default => :'errors.topic.title.format')
+    assert_equal 'length on topic',       I18n.t(:'errors.reply.title.length', :default => :'errors.topic.title.length')
+    assert_equal 'odd on errors',         I18n.t(:'errors.reply.title.odd',    :default => :'errors.topic.title.odd')
+  end
+end

data/lib/active_support/vendor/i18n-0.3.3/test/cases/backend/chain_test.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/chain'
+
+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
+
+  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/lib/active_support/vendor/i18n-0.3.3/test/cases/backend/fallbacks_test.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class I18nBackendFallbacksTest < 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
+
+  define_method "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
+
+  define_method "test: returns the :en translation for a missing :de translation" do
+    assert_equal 'Foo in :en', I18n.t(:foo, :locale => :de)
+  end
+
+  define_method "test: returns the :de translation for a missing :'de-DE' translation" do
+    assert_equal 'Bar in :de', I18n.t(:bar, :locale => :'de-DE')
+  end
+
+  define_method "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
+
+  define_method "test: raises I18n::MissingTranslationData exception when no translation was found" do
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:faa, :locale => :en, :raise => true) }
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:faa, :locale => :de, :raise => true) }
+  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
+
+  define_method "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/lib/active_support/vendor/i18n-0.3.3/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/lib/active_support/vendor/i18n-0.3.3/test/cases/backend/helpers_test.rb

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

data/lib/active_support/vendor/i18n-0.3.3/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/lib/active_support/vendor/i18n-0.3.3/test/cases/backend/metadata_test.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/metadata'
+
+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
+
+  define_method "test: translation strings carry metadata" do
+    translation = I18n.t(:foo)
+    assert translation.respond_to?(:translation_metadata)
+    assert translation.translation_metadata.is_a?(Hash)
+  end
+
+  define_method "test: translate preserves metadata stored on original Strings" do
+    store_metadata(:foo, :bar, 'bar')
+    assert_equal 'bar', I18n.t(:foo).translation_metadata[:bar]
+  end
+
+  define_method "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
+
+  define_method "test: translate adds the locale to metadata on Strings" do
+    assert_equal :en, I18n.t(:foo, :locale => :en).translation_metadata[:locale]
+  end
+
+  define_method "test: translate adds the key to metadata on Strings" do
+    assert_equal :foo, I18n.t(:foo).translation_metadata[:key]
+  end
+
+  define_method "test: translate adds the default to metadata on Strings" do
+    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
+    assert_equal({:name => 'David'}, I18n.t(:foo, :name => 'David').translation_metadata[:values])
+  end
+
+  define_method "test: interpolation adds the original string to metadata on Strings" do
+    assert_equal('Hi {{name}}', I18n.t(:foo, :name => 'David').translation_metadata[:original])
+  end
+
+  define_method "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/lib/active_support/vendor/i18n-0.3.3/test/cases/backend/pluralization_test.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/pluralization'
+
+class I18nBackendPluralizationTest < Test::Unit::TestCase
+  class Backend
+    include I18n::Backend::Base
+    include I18n::Backend::Pluralization
+  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(:foo, :i18n => { :plural => { :rule => @rule } })
+    @entry = { :zero => 'zero', :one => 'one', :few => 'few', :many => 'many', :other => 'other' }
+  end
+
+  define_method "test: pluralization picks a pluralizer from :'i18n.pluralize'" do
+    assert_equal @rule, I18n.backend.send(:pluralizer, :foo)
+  end
+
+  define_method "test: pluralization picks :one for 1" do
+    assert_equal 'one', I18n.t(:count => 1, :default => @entry, :locale => :foo)
+  end
+
+  define_method "test: pluralization picks :few for 2" do
+    assert_equal 'few', I18n.t(:count => 2, :default => @entry, :locale => :foo)
+  end
+
+  define_method "test: pluralization picks :many for 11" do
+    assert_equal 'many', I18n.t(:count => 11, :default => @entry, :locale => :foo)
+  end
+
+  define_method "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 => :foo)
+  end
+
+  define_method "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 => :foo)
+  end
+end