i18n 1.0.1 → 1.6.0

data/test/api/memoize_test.rb

@@ -1,56 +0,0 @@
-require 'test_helper'
-
-class I18nMemoizeBackendWithSimpleApiTest < I18n::TestCase
-  include I18n::Tests::Basics
-  include I18n::Tests::Defaults
-  include I18n::Tests::Interpolation
-  include I18n::Tests::Link
-  include I18n::Tests::Lookup
-  include I18n::Tests::Pluralization
-  include I18n::Tests::Procs
-  include I18n::Tests::Localization::Date
-  include I18n::Tests::Localization::DateTime
-  include I18n::Tests::Localization::Time
-  include I18n::Tests::Localization::Procs
-
-  class MemoizeBackend < I18n::Backend::Simple
-    include I18n::Backend::Memoize
-  end
-
-  def setup
-    I18n.backend = MemoizeBackend.new
-    super
-  end
-
-  test "make sure we use the MemoizeBackend backend" do
-    assert_equal MemoizeBackend, I18n.backend.class
-  end
-end
-
-class I18nMemoizeBackendWithKeyValueApiTest < I18n::TestCase
-  include I18n::Tests::Basics
-  include I18n::Tests::Defaults
-  include I18n::Tests::Interpolation
-  include I18n::Tests::Link
-  include I18n::Tests::Lookup
-  include I18n::Tests::Pluralization
-  include I18n::Tests::Localization::Date
-  include I18n::Tests::Localization::DateTime
-  include I18n::Tests::Localization::Time
-
-  # include I18n::Tests::Procs
-  # include I18n::Tests::Localization::Procs
-
-  class MemoizeBackend < I18n::Backend::KeyValue
-    include I18n::Backend::Memoize
-  end
-
-  def setup
-    I18n.backend = MemoizeBackend.new({})
-    super
-  end
-
-  test "make sure we use the MemoizeBackend backend" do
-    assert_equal MemoizeBackend, I18n.backend.class
-  end
-end if I18n::TestCase.key_value?

data/test/api/override_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-class I18nOverrideTest < I18n::TestCase
-  module OverrideInverse
-    def translate(*args)
-      super(*args).reverse
-    end
-    alias :t :translate
-  end
-
-  module OverrideSignature
-    def translate(*args)
-      args.first + args[1]
-    end
-    alias :t :translate
-  end
-
-  def setup
-    super
-    @I18n = I18n.dup
-    @I18n.backend = I18n::Backend::Simple.new
-  end
-
-  test "make sure modules can overwrite I18n methods" do
-    @I18n.extend OverrideInverse
-    @I18n.backend.store_translations('en', :foo => 'bar')
-
-    assert_equal 'rab', @I18n.translate(:foo, :locale => 'en')
-    assert_equal 'rab', @I18n.t(:foo, :locale => 'en')
-    assert_equal 'rab', @I18n.translate!(:foo, :locale => 'en')
-    assert_equal 'rab', @I18n.t!(:foo, :locale => 'en')
-  end
-
-  test "make sure modules can overwrite I18n signature" do
-    exception = catch(:exception) do
-      @I18n.t('Hello', 'Welcome message on home page', :tokenize => true, :throw => true)
-    end
-    assert exception.message
-    @I18n.extend OverrideSignature
-    assert_equal 'HelloWelcome message on home page', @I18n.translate('Hello', 'Welcome message on home page', :tokenize => true) # tr8n example
-  end
-end

data/test/api/pluralization_test.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-class I18nPluralizationApiTest < I18n::TestCase
-  class Backend < I18n::Backend::Simple
-    include I18n::Backend::Pluralization
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    super
-  end
-
-  include I18n::Tests::Basics
-  include I18n::Tests::Defaults
-  include I18n::Tests::Interpolation
-  include I18n::Tests::Link
-  include I18n::Tests::Lookup
-  include I18n::Tests::Pluralization
-  include I18n::Tests::Procs
-  include I18n::Tests::Localization::Date
-  include I18n::Tests::Localization::DateTime
-  include I18n::Tests::Localization::Time
-  include I18n::Tests::Localization::Procs
-
-  test "make sure we use a backend with Pluralization included" do
-    assert_equal Backend, I18n.backend.class
-  end
-
-  # links: test that keys stored on one backend can link to keys stored on another backend
-end

data/test/api/simple_test.rb

@@ -1,28 +0,0 @@
-require 'test_helper'
-
-class I18nSimpleBackendApiTest < I18n::TestCase
-  class Backend < I18n::Backend::Simple
-    include I18n::Backend::Pluralization
-  end
-
-  def setup
-    I18n.backend = I18n::Backend::Simple.new
-    super
-  end
-
-  include I18n::Tests::Basics
-  include I18n::Tests::Defaults
-  include I18n::Tests::Interpolation
-  include I18n::Tests::Link
-  include I18n::Tests::Lookup
-  include I18n::Tests::Pluralization
-  include I18n::Tests::Procs
-  include I18n::Tests::Localization::Date
-  include I18n::Tests::Localization::DateTime
-  include I18n::Tests::Localization::Time
-  include I18n::Tests::Localization::Procs
-
-  test "make sure we use the Simple backend" do
-    assert_equal I18n::Backend::Simple, I18n.backend.class
-  end
-end

data/test/backend/cache_test.rb

@@ -1,109 +0,0 @@
-require 'test_helper'
-require 'digest/md5'
-
-begin
-  require 'active_support'
-rescue LoadError
-  $stderr.puts "Skipping cache tests using ActiveSupport"
-else
-
-class I18nBackendCacheTest < I18n::TestCase
-  class Backend < I18n::Backend::Simple
-    include I18n::Backend::Cache
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    super
-    I18n.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
-    I18n.cache_key_digest = nil
-  end
-
-  def teardown
-    super
-    I18n.cache_store = nil
-  end
-
-  test "it uses the cache" do
-    assert I18n.cache_store.is_a?(ActiveSupport::Cache::MemoryStore)
-  end
-
-  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 "translate returns a cached false response" do
-    I18n.backend.expects(:lookup).never
-    I18n.cache_store.expects(:read).returns(false)
-    assert_equal false, I18n.t(:foo)
-  end
-
-  test "still raises MissingTranslationData but also caches it" do
-    assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
-    assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
-    assert_equal 1, I18n.cache_store.instance_variable_get(:@data).size
-
-    # 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
-
-  test "uses 'i18n' as a cache key namespace by default" do
-    assert_equal 0, I18n.backend.send(:cache_key, :en, :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, :en, :foo, {}).index('i18n/bar/')
-    end
-  end
-
-  test "adds locale and hash of key and hash of options" do
-    options = { :bar=>1 }
-    options_hash = RUBY_VERSION <= "1.9" ? options.inspect.hash : options.hash
-    assert_equal "i18n//en/#{:foo.hash}/#{options_hash}", I18n.backend.send(:cache_key, :en, :foo, options)
-  end
-
-  test "cache_key uses configured digest method" do
-    md5 = Digest::MD5.new
-    options = { :bar=>1 }
-    options_hash = options.inspect
-    with_cache_key_digest(md5) do
-      assert_equal "i18n//en/#{md5.hexdigest(:foo.to_s)}/#{md5.hexdigest(options_hash)}", I18n.backend.send(:cache_key, :en, :foo, options)
-    end
-  end
-
-  test "keys should not be equal" do
-    interpolation_values1 = { :foo => 1, :bar => 2 }
-    interpolation_values2 = { :foo => 2, :bar => 1 }
-
-    key1 = I18n.backend.send(:cache_key, :en, :some_key, interpolation_values1)
-    key2 = I18n.backend.send(:cache_key, :en, :some_key, interpolation_values2)
-
-    assert key1 != key2
-  end
-
-  protected
-
-    def with_cache_namespace(namespace)
-      I18n.cache_namespace = namespace
-      yield
-      I18n.cache_namespace = nil
-    end
-
-    def with_cache_key_digest(digest)
-      I18n.cache_key_digest = digest
-      yield
-      I18n.cache_key_digest = nil
-    end
-end
-
-end # AS cache check

data/test/backend/cascade_test.rb

@@ -1,86 +0,0 @@
-require 'test_helper'
-
-class I18nBackendCascadeTest < I18n::TestCase
-  class Backend < I18n::Backend::Simple
-    include I18n::Backend::Cascade
-  end
-
-  def setup
-    super
-    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

@@ -1,122 +0,0 @@
-require 'test_helper'
-
-class I18nBackendChainTest < I18n::TestCase
-  def setup
-    super
-    @first  = backend(:en => {
-      :foo => 'Foo', :formats => {
-        :short => 'short',
-        :subformats => {:short => 'short'},
-      },
-      :plural_1 => { :one => '%{count}' },
-      :dates => {:a => "A"}
-    })
-    @second = backend(:en => {
-      :bar => 'Bar', :formats => {
-        :long => 'long',
-        :subformats => {:long => 'long'},
-      },
-      :plural_2 => { :one => 'one' },
-      :dates => {:a => "B", :b => "B"}
-    })
-    @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 and merges deep hashes" do
-    assert_equal({:long=>"long", :subformats=>{:long=>"long", :short=>"short"}, :short=>"short"}, I18n.t(:formats))
-  end
-
-  test "namespace lookup collects results from all backends and lets leftmost backend take priority" do
-    assert_equal({ :a => "A", :b => "B" }, I18n.t(:dates))
-  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 [{
-      :long=>"long",
-      :subformats=>{:long=>"long", :short=>"short"},
-      :short=>"short"}, {: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
-
-class I18nBackendChainWithKeyValueTest < I18n::TestCase
-  def setup_backend!(subtrees = true)
-    first = I18n::Backend::KeyValue.new({}, subtrees)
-    first.store_translations(:en, :plural_1 => { :one => '%{count}' })
-
-    second = I18n::Backend::Simple.new
-    second.store_translations(:en, :plural_2 => { :one => 'one' })
-    I18n.backend = I18n::Backend::Chain.new(first, second)
-  end
-
-  test "subtrees enabled: looks up pluralization translations from the first chained backend" do
-    setup_backend!
-    assert_equal '1', I18n.t(:plural_1, count: 1)
-  end
-
-  test "subtrees disabled: looks up pluralization translations from the first chained backend" do
-    setup_backend!(false)
-    assert_equal '1', I18n.t(:plural_1, count: 1)
-  end
-
-  test "subtrees enabled: looks up translations from the second chained backend" do
-    setup_backend!
-    assert_equal 'one', I18n.t(:plural_2, count: 1)
-  end
-
-  test "subtrees disabled: looks up translations from the second chained backend" do
-    setup_backend!(false)
-    assert_equal 'one', I18n.t(:plural_2, count: 1)
-  end
-end if I18n::TestCase.key_value?