i18n 0.3.6 → 0.3.7

data/test/api/tests/pluralization.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-module Tests
-  module Api
-    module Pluralization
-      define_method "test pluralization: given 0 it returns the :zero translation if it is defined" do
-        assert_equal 'zero', I18n.t(:default => { :zero => 'zero' }, :count => 0)
-      end
-
-      define_method "test pluralization: given 0 it returns the :other translation if :zero is not defined" do
-        assert_equal 'bars', I18n.t(:default => { :other => 'bars' }, :count => 0)
-      end
-
-      define_method "test pluralization: given 1 it returns the singular translation" do
-        assert_equal 'bar', I18n.t(:default => { :one => 'bar' }, :count => 1)
-      end
-
-      define_method "test pluralization: given 2 it returns the :other translation" do
-        assert_equal 'bars', I18n.t(:default => { :other => 'bars' }, :count => 2)
-      end
-
-      define_method "test pluralization: given 3 it returns the :other translation" do
-        assert_equal 'bars', I18n.t(:default => { :other => 'bars' }, :count => 3)
-      end
-
-      define_method "test pluralization: given nil it returns the whole entry" do
-        assert_equal({ :one => 'bar' }, I18n.t(:default => { :one => 'bar' }, :count => nil))
-      end
-
-      define_method "test pluralization: given incomplete pluralization data it raises I18n::InvalidPluralizationData" do
-        assert_raise(I18n::InvalidPluralizationData) { I18n.t(:default => { :one => 'bar' }, :count => 2) }
-      end
-    end
-  end
-end

data/test/api/tests/procs.rb

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-module Tests
-  module Api
-    module Procs
-      define_method "test lookup: given a translation is a proc it calls the proc with the key and interpolation values" do
-        if can_store_procs?
-          store_translations(:a_lambda => lambda { |*args| args.inspect })
-          assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(:a_lambda, :foo => 'foo')
-        end
-      end
-
-      define_method "test defaults: given a default is a Proc it calls it with the key and interpolation values" do
-        proc = lambda { |*args| args.inspect }
-        assert_equal '[nil, {:foo=>"foo"}]', I18n.t(nil, :default => proc, :foo => 'foo')
-      end
-
-      define_method "test defaults: given a default is a key that resolves to a Proc it calls it with the key and interpolation values" do
-        if can_store_procs?
-          store_translations(:a_lambda => lambda { |*args| args.inspect })
-          assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(nil, :default => :a_lambda, :foo => 'foo')
-          assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(nil, :default => [nil, :a_lambda], :foo => 'foo')
-        end
-      end
-
-      define_method "test interpolation: given an interpolation value is a lambda it calls it with key and values before interpolating it" do
-        proc = lambda { |*args| args.inspect }
-        assert_match %r(\[\{:foo=>#<Proc.*>\}\]), I18n.t(nil, :default => '{{foo}}', :foo => proc)
-      end
-
-      define_method "test interpolation: given a key resolves to a Proc that returns a string then interpolation still works" do
-        proc = lambda { |*args| "{{foo}}: " + args.inspect }
-        assert_equal 'foo: [nil, {:foo=>"foo"}]', I18n.t(nil, :default => proc, :foo => 'foo')
-      end
-
-      define_method "test pluralization: given a key resolves to a Proc that returns valid data then pluralization still works" do
-        proc = lambda { |*args| { :zero => 'zero', :one => 'one', :other => 'other' } }
-        assert_equal 'zero',  I18n.t(:default => proc, :count => 0)
-        assert_equal 'one',   I18n.t(:default => proc, :count => 1)
-        assert_equal 'other', I18n.t(:default => proc, :count => 2)
-      end
-
-      define_method "test lookup: given the option :resolve => false was passed it does not resolve proc translations" do
-        if can_store_procs?
-          store_translations(:a_lambda => lambda { |*args| args.inspect })
-          assert_equal Proc, I18n.t(:a_lambda, :resolve => false).class
-        end
-      end
-
-      define_method "test lookup: given the option :resolve => false was passed it does not resolve proc default" do
-        assert_equal Proc, I18n.t(nil, :default => lambda { |*args| args.inspect }, :resolve => false).class
-      end
-    end
-  end
-end

data/test/backend/active_record/missing_test.rb

@@ -1,51 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../../')); $:.uniq!
-require 'test_helper'
-
-require_active_record!
-
-class I18nActiveRecordMissingTest < Test::Unit::TestCase
-  def setup
-    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)
-    
-    I18n::Backend::ActiveRecord::Translation.delete_all
-  end
-  
-  test "can persist interpolations" do
-    translation = I18n::Backend::ActiveRecord::Translation.new(:key => 'foo', :value => 'bar', :locale => :en)
-    translation.interpolations = %w(count name)
-    translation.save
-    assert translation.valid?
-  end
-
-  test "lookup persists the key" do
-    I18n.t('foo.bar.baz')
-    assert_equal 1, I18n::Backend::ActiveRecord::Translation.count
-  end
-
-  test "lookup does not persist the key twice" do
-    2.times { I18n.t('foo.bar.baz') }
-    assert_equal 1, I18n::Backend::ActiveRecord::Translation.count
-  end
-  
-  test "lookup persists interpolation keys when looked up directly" do
-    I18n.t('foo.bar.baz', :cow => "lucy" )  # creates stub translation.
-    translation_stub = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo.bar.baz').first
-    assert translation_stub.interpolates?(:cow)
-  end
-
-  test "creates one stub per pluralization" do
-    I18n.t('foo', :count => 999)
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).find_all_by_key %w{ foo.zero foo.one foo.other }
-    assert_equal 3, translations.length
-  end
-
-  test "creates no stub for base key in pluralization" do
-    I18n.t('foo', :count => 999)
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key %w{ foo.zero foo.one foo.other }
-    assert !I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key("foo")
-  end
-end if defined?(ActiveRecord)

data/test/backend/active_record_test.rb

@@ -1,57 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-
-require_active_record!
-
-class I18nBackendActiveRecordTest < Test::Unit::TestCase
-  def setup
-    I18n.backend = I18n::Backend::ActiveRecord.new
-    store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
-  end
-
-  def teardown
-    I18n::Backend::ActiveRecord::Translation.destroy_all
-    super
-  end
-
-  test "store_translations does not allow ambiguous keys (1)" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, :foo => 'foo')
-    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
-    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
-
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo', '.').all
-    assert_equal %w(bar baz), translations.map(&:value)
-
-    assert_equal({ :bar => 'bar', :baz => 'baz' }, I18n.t(:foo))
-  end
-
-  test "store_translations does not allow ambiguous keys (2)" do
-    I18n::Backend::ActiveRecord::Translation.delete_all
-    I18n.backend.store_translations(:en, :foo => { :bar => 'bar' })
-    I18n.backend.store_translations(:en, :foo => { :baz => 'baz' })
-    I18n.backend.store_translations(:en, :foo => 'foo')
-
-    translations = I18n::Backend::ActiveRecord::Translation.locale(:en).lookup('foo', '.').all
-    assert_equal %w(foo), translations.map(&:value)
-
-    assert_equal 'foo', I18n.t(:foo)
-  end
-  
-  test "can store translations with keys that are translations containing special chars" do
-    I18n.backend.store_translations(:es, :"Pagina's" => "Pagina's" )
-    assert_equal "Pagina's", I18n.t(:"Pagina's", :locale => :es)
-  end
-
-  with_mocha do
-    test "missing translations table does not cause an error in #available_locales" do
-      I18n::Backend::ActiveRecord::Translation.expects(:available_locales).raises(::ActiveRecord::StatementInvalid)
-      assert_equal [], I18n.backend.available_locales
-    end
-  end
-
-  def test_expand_keys
-    assert_equal %w(foo foo.bar foo.bar.baz), I18n.backend.send(:expand_keys, :'foo.bar.baz')
-  end
-end if defined?(ActiveRecord)

data/test/backend/cache_test.rb

@@ -1,71 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-
-begin
-  require 'active_support'
-rescue LoadError
-  $stderr.puts "Skipping cache tests using ActiveSupport"
-else
-
-class I18nBackendCacheTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Cache
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    super
-    I18n.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
-  end
-
-  def teardown
-    I18n.cache_store = nil
-  end
-
-  test "it uses the cache" do
-    assert I18n.cache_store.is_a?(ActiveSupport::Cache::MemoryStore)
-  end
-
-  with_mocha do
-    test "translate hits the backend and caches the response" do
-      I18n.backend.expects(:lookup).returns('Foo')
-      assert_equal 'Foo', I18n.t(:foo)
-
-      I18n.backend.expects(:lookup).never
-      assert_equal 'Foo', I18n.t(:foo)
-
-      I18n.backend.expects(:lookup).returns('Bar')
-      assert_equal 'Bar', I18n.t(:bar)
-    end
-
-    test "still raises MissingTranslationData but also caches it" do
-      I18n.backend.expects(:lookup).returns(nil)
-      assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
-
-      I18n.backend.expects(:lookup).never
-      assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
-    end
-  end
-
-  test "uses 'i18n' as a cache key namespace by default" do
-    assert_equal 0, I18n.backend.send(:cache_key, :foo).index('i18n')
-  end
-
-  test "adds a custom cache key namespace" do
-    with_cache_namespace('bar') do
-      assert_equal 0, I18n.backend.send(:cache_key, :foo).index('i18n-bar')
-    end
-  end
-
-  protected
-
-    def with_cache_namespace(namespace)
-      I18n.cache_namespace = namespace
-      yield
-      I18n.cache_namespace = nil
-    end
-end
-
-end # AS cache check

data/test/backend/cascade_test.rb

@@ -1,73 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require '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
-
-  def lookup(key, options = {})
-    I18n.t(key, options.merge(:cascade => { :step => 1, :offset => 1, :skip_root => false }))
-  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 "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',  lookup(:'errors.reply.title.blank',  :default => :'errors.topic.title.blank')
-    assert_equal 'taken on reply',        lookup(:'errors.reply.title.taken',  :default => :'errors.topic.title.taken')
-    assert_equal 'format on topic title', lookup(:'errors.reply.title.format', :default => :'errors.topic.title.format')
-    assert_equal 'length on topic',       lookup(:'errors.reply.title.length', :default => :'errors.topic.title.length')
-    assert_equal 'odd on errors',         lookup(:'errors.reply.title.odd',    :default => :'errors.topic.title.odd')
-  end
-end

data/test/backend/chain_test.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-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 "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])
-  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/cldr_test.rb

@@ -1,151 +0,0 @@
-# encoding: utf-8
-
-begin
-  require 'cldr'
-rescue LoadError
-  puts "Skipping tests for I18n::Backend::Cldr because the ruby-cldr gem is not installed."
-end
-
-if defined?(Cldr)
-  $:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-  require 'test_helper'
-  require 'i18n/backend/cldr'
-  require 'date'
-
-  class I18nBackendCldrTest < Test::Unit::TestCase
-    class Backend
-      include I18n::Backend::Base
-      include I18n::Backend::Cldr
-    end
-
-    def setup
-      I18n.backend = Backend.new
-      I18n.locale = :de
-      I18n.load_path += Dir[locales_dir + '/cldr/**/*.{yml,rb}']
-      super
-    end
-
-    # NUMBER
-
-    test "format_number" do
-      assert_equal '123.456,78', I18n.l(123456.78)
-    end
-
-    # CURRENCY
-
-    test "format_currency" do
-      assert_equal '123.456,78 EUR', I18n.l(123456.78, :currency => 'EUR')
-    end
-
-    # hu? does this actually make any sense?
-    test "format_currency translating currency names" do
-      assert_equal '1,00 Irisches Pfund', I18n.l(1, :currency => :IEP)
-      assert_equal '2,00 Irische Pfund',  I18n.l(2, :currency => :IEP)
-    end
-
-    # PERCENT
-
-    # this is odd but the cldr percent format does not include a fraction
-    test "format_percent" do
-      assert_equal '123.457 %', I18n.l(123456.78, :as => :percent)
-    end
-
-    # so we can pass a precision manually
-    test "format_percent w/ precision" do
-      assert_equal '123.456,70 %', I18n.l(123456.7, :as => :percent, :precision => 2)
-    end
-
-    # DATE
-
-    def date
-      Date.new(2010, 1, 1)
-    end
-
-    test "format_date :full" do
-      assert_equal 'Freitag, 1. Januar 2010', I18n.l(date, :format => :full)
-    end
-
-    test "format_date :long" do
-      assert_equal '1. Januar 2010', I18n.l(date, :format => :long)
-    end
-
-    test "format_date :medium" do
-      assert_equal '01.01.2010', I18n.l(date)
-    end
-
-    test "format_date :short" do
-      assert_equal '01.01.10', I18n.l(date, :format => :short)
-    end
-
-    # TIME
-
-    def time
-      Time.utc(2010, 1, 1, 13, 15, 17)
-    end
-
-    # TODO cldr export lacks localized timezone data
-    # test "format_time :full" do
-    #   assert_equal 'Freitag, 1. Januar 2010', I18n.l(time, :format => :full)
-    # end
-
-    test "format_time :long" do
-      assert_equal '13:15:17 UTC', I18n.l(time, :format => :long)
-    end
-
-    test "format_time :medium" do
-      assert_equal '13:15:17', I18n.l(time)
-    end
-
-    test "format_time :short" do
-      assert_equal '13:15', I18n.l(time, :format => :short)
-    end
-
-    # DATETIME
-
-    def datetime
-      DateTime.new(2010, 11, 12, 13, 14, 15)
-    end
-
-    # TODO cldr export lacks localized timezone data
-    # test "format_datetime :full" do
-    #   assert_equal 'Thursday, 12. November 2010 13:14:15', I18n.l(datetime, :format => :full)
-    # end
-
-    test "format_datetime :long" do
-      assert_equal '12. November 2010 13:14:15 +00:00', I18n.l(datetime, :format => :long)
-    end
-
-    test "format_datetime :medium" do
-      assert_equal '12.11.2010 13:14:15', I18n.l(datetime)
-    end
-
-    test "format_datetime :short" do
-      assert_equal '12.11.10 13:14', I18n.l(datetime, :format => :short)
-    end
-
-    test "format_datetime mixed :long + :short" do
-      assert_equal '12. November 2010 13:14', I18n.l(datetime, :date_format => :long, :time_format => :short)
-    end
-
-    test "format_datetime mixed :short + :long" do
-      assert_equal '12.11.10 13:14:15 +00:00', I18n.l(datetime, :date_format => :short, :time_format => :long)
-    end
-
-    # CUSTOM FORMATS
-
-    test "can deal with customized formats data" do
-      store_translations :de, :numbers => {
-        :formats => {
-          :decimal => {
-            :patterns => {
-              :default => "#,##0.###",
-              :stupid  => "#"
-            }
-          }
-        }
-      }
-      assert_equal '123.456,78', I18n.l(123456.78)
-      assert_equal '123457',     I18n.l(123456.78, :format => :stupid)
-    end
-  end
-end