This commit is contained in:
@@ -0,0 +1,58 @@
|
||||
module I18n
|
||||
module Tests
|
||||
module Basics
|
||||
def teardown
|
||||
I18n.available_locales = nil
|
||||
end
|
||||
|
||||
test "available_locales returns the available_locales produced by the backend, by default" do
|
||||
I18n.backend.store_translations('de', :foo => 'bar')
|
||||
I18n.backend.store_translations('en', :foo => 'foo')
|
||||
|
||||
assert_equal I18n.available_locales, I18n.backend.available_locales
|
||||
end
|
||||
|
||||
test "available_locales can be set to something else independently from the actual locale data" do
|
||||
I18n.backend.store_translations('de', :foo => 'bar')
|
||||
I18n.backend.store_translations('en', :foo => 'foo')
|
||||
|
||||
I18n.available_locales = :foo
|
||||
assert_equal [:foo], I18n.available_locales
|
||||
|
||||
I18n.available_locales = [:foo, 'bar']
|
||||
assert_equal [:foo, :bar], I18n.available_locales
|
||||
|
||||
I18n.available_locales = nil
|
||||
assert_equal I18n.available_locales, I18n.backend.available_locales
|
||||
end
|
||||
|
||||
test "available_locales memoizes when set explicitly" do
|
||||
I18n.backend.expects(:available_locales).never
|
||||
I18n.available_locales = [:foo]
|
||||
I18n.backend.store_translations('de', :bar => 'baz')
|
||||
I18n.reload!
|
||||
assert_equal [:foo], I18n.available_locales
|
||||
end
|
||||
|
||||
test "available_locales delegates to the backend when not set explicitly" do
|
||||
original_available_locales_value = I18n.backend.available_locales
|
||||
I18n.backend.expects(:available_locales).returns(original_available_locales_value).twice
|
||||
assert_equal I18n.backend.available_locales, I18n.available_locales
|
||||
end
|
||||
|
||||
test "exists? is implemented by the backend" do
|
||||
I18n.backend.store_translations(:foo, :bar => 'baz')
|
||||
assert I18n.exists?(:bar, :foo)
|
||||
end
|
||||
|
||||
test "storing a nil value as a translation removes it from the available locale data" do
|
||||
I18n.backend.store_translations(:en, :to_be_deleted => 'bar')
|
||||
assert_equal 'bar', I18n.t(:to_be_deleted, :default => 'baz')
|
||||
|
||||
I18n.cache_store.clear if I18n.respond_to?(:cache_store) && I18n.cache_store
|
||||
I18n.backend.store_translations(:en, :to_be_deleted => nil)
|
||||
assert_equal 'baz', I18n.t(:to_be_deleted, :default => 'baz')
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,59 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Defaults
|
||||
def setup
|
||||
super
|
||||
I18n.backend.store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
|
||||
end
|
||||
|
||||
test "defaults: given nil as a key it returns the given default" do
|
||||
assert_equal 'default', I18n.t(nil, :default => 'default')
|
||||
end
|
||||
|
||||
test "defaults: given a symbol as a default it translates the symbol" do
|
||||
assert_equal 'bar', I18n.t(nil, :default => :'foo.bar')
|
||||
end
|
||||
|
||||
test "defaults: given a symbol as a default and a scope it stays inside the scope when looking up the symbol" do
|
||||
assert_equal 'bar', I18n.t(:missing, :default => :bar, :scope => :foo)
|
||||
end
|
||||
|
||||
test "defaults: given an array as a default it returns the first match" do
|
||||
assert_equal 'bar', I18n.t(:does_not_exist, :default => [:does_not_exist_2, :'foo.bar'])
|
||||
end
|
||||
|
||||
test "defaults: given an array as a default with false it returns false" do
|
||||
assert_equal false, I18n.t(:does_not_exist, :default => [false])
|
||||
end
|
||||
|
||||
test "defaults: given false it returns false" do
|
||||
assert_equal false, I18n.t(:does_not_exist, :default => false)
|
||||
end
|
||||
|
||||
test "defaults: given nil it returns nil" do
|
||||
assert_nil I18n.t(:does_not_exist, :default => nil)
|
||||
end
|
||||
|
||||
test "defaults: given an array of missing keys it raises a MissingTranslationData exception" do
|
||||
assert_raises I18n::MissingTranslationData do
|
||||
I18n.t(:does_not_exist, :default => [:does_not_exist_2, :does_not_exist_3], :raise => true)
|
||||
end
|
||||
end
|
||||
|
||||
test "defaults: using a custom scope separator" do
|
||||
# data must have been stored using the custom separator when using the ActiveRecord backend
|
||||
I18n.backend.store_translations(:en, { :foo => { :bar => 'bar' } }, { :separator => '|' })
|
||||
assert_equal 'bar', I18n.t(nil, :default => :'foo|bar', :separator => '|')
|
||||
end
|
||||
|
||||
# Addresses issue: #599
|
||||
test "defaults: only interpolates once when resolving defaults" do
|
||||
I18n.backend.store_translations(:en, :greeting => 'hey %{name}')
|
||||
assert_equal 'hey %{dont_interpolate_me}',
|
||||
I18n.t(:does_not_exist, :name => '%{dont_interpolate_me}', default: [:greeting])
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,185 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Interpolation
|
||||
# If no interpolation parameter is not given, I18n should not alter the string.
|
||||
# This behavior is due to three reasons:
|
||||
#
|
||||
# * Checking interpolation keys in all strings hits performance, badly;
|
||||
#
|
||||
# * This allows us to retrieve untouched values through I18n. For example
|
||||
# I could have a middleware that returns I18n lookup results in JSON
|
||||
# to be processed through Javascript. Leaving the keys untouched allows
|
||||
# the interpolation to happen at the javascript level;
|
||||
#
|
||||
# * Security concerns: if I allow users to translate a web site, they can
|
||||
# insert %{} in messages causing the I18n lookup to fail in every request.
|
||||
#
|
||||
test "interpolation: given no values it does not alter the string" do
|
||||
assert_equal 'Hi %{name}!', interpolate(:default => 'Hi %{name}!')
|
||||
end
|
||||
|
||||
test "interpolation: given values it interpolates them into the string" do
|
||||
assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => 'David')
|
||||
end
|
||||
|
||||
test "interpolation: works with a pipe" do
|
||||
assert_equal 'Hi david!', interpolate(:default => 'Hi %{name|lowercase}!', :'name|lowercase' => 'david')
|
||||
end
|
||||
|
||||
test "interpolation: given a nil value it still interpolates it into the string" do
|
||||
assert_equal 'Hi !', interpolate(:default => 'Hi %{name}!', :name => nil)
|
||||
end
|
||||
|
||||
test "interpolation: given a lambda as a value it calls it if the string contains the key" do
|
||||
assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => lambda { |*args| 'David' })
|
||||
end
|
||||
|
||||
test "interpolation: given a lambda as a value it does not call it if the string does not contain the key" do
|
||||
assert_nothing_raised { interpolate(:default => 'Hi!', :name => lambda { |*args| raise 'fail' }) }
|
||||
end
|
||||
|
||||
test "interpolation: given values but missing a key it raises I18n::MissingInterpolationArgument" do
|
||||
assert_raises(I18n::MissingInterpolationArgument) do
|
||||
interpolate(:default => '%{foo}', :bar => 'bar')
|
||||
end
|
||||
end
|
||||
|
||||
test "interpolation: it does not raise I18n::MissingInterpolationArgument for escaped variables" do
|
||||
assert_nothing_raised do
|
||||
assert_equal 'Barr %{foo}', interpolate(:default => '%{bar} %%{foo}', :bar => 'Barr')
|
||||
end
|
||||
end
|
||||
|
||||
test "interpolation: it does not change the original, stored translation string" do
|
||||
I18n.backend.store_translations(:en, :interpolate => 'Hi %{name}!')
|
||||
assert_equal 'Hi David!', interpolate(:interpolate, :name => 'David')
|
||||
assert_equal 'Hi Yehuda!', interpolate(:interpolate, :name => 'Yehuda')
|
||||
end
|
||||
|
||||
test "interpolation: given an array interpolates each element" do
|
||||
I18n.backend.store_translations(:en, :array_interpolate => ['Hi', 'Mr. %{name}', 'or sir %{name}'])
|
||||
assert_equal ['Hi', 'Mr. Bartuz', 'or sir Bartuz'], interpolate(:array_interpolate, :name => 'Bartuz')
|
||||
end
|
||||
|
||||
test "interpolation: given the translation is in utf-8 it still works" do
|
||||
assert_equal 'Häi David!', interpolate(:default => 'Häi %{name}!', :name => 'David')
|
||||
end
|
||||
|
||||
test "interpolation: given the value is in utf-8 it still works" do
|
||||
assert_equal 'Hi ゆきひろ!', interpolate(:default => 'Hi %{name}!', :name => 'ゆきひろ')
|
||||
end
|
||||
|
||||
test "interpolation: given the translation and the value are in utf-8 it still works" do
|
||||
assert_equal 'こんにちは、ゆきひろさん!', interpolate(:default => 'こんにちは、%{name}さん!', :name => 'ゆきひろ')
|
||||
end
|
||||
|
||||
if Object.const_defined?(:Encoding)
|
||||
test "interpolation: given a euc-jp translation and a utf-8 value it raises Encoding::CompatibilityError" do
|
||||
assert_raises(Encoding::CompatibilityError) do
|
||||
interpolate(:default => euc_jp('こんにちは、%{name}さん!'), :name => 'ゆきひろ')
|
||||
end
|
||||
end
|
||||
|
||||
test "interpolation: given a utf-8 translation and a euc-jp value it raises Encoding::CompatibilityError" do
|
||||
assert_raises(Encoding::CompatibilityError) do
|
||||
interpolate(:default => 'こんにちは、%{name}さん!', :name => euc_jp('ゆきひろ'))
|
||||
end
|
||||
end
|
||||
|
||||
test "interpolation: ASCII strings in the backend should be encoded to UTF8 if interpolation options are in UTF8" do
|
||||
I18n.backend.store_translations 'en', 'encoding' => ('%{who} let me go'.dup.force_encoding(Encoding::US_ASCII))
|
||||
result = I18n.t 'encoding', :who => "måmmå miå"
|
||||
assert_equal Encoding::UTF_8, result.encoding
|
||||
end
|
||||
|
||||
test "interpolation: UTF8 strings in the backend are still returned as UTF8 with ASCII interpolation" do
|
||||
I18n.backend.store_translations 'en', 'encoding' => 'måmmå miå %{what}'
|
||||
result = I18n.t 'encoding', :what => 'let me go'.dup.force_encoding(Encoding::US_ASCII)
|
||||
assert_equal Encoding::UTF_8, result.encoding
|
||||
end
|
||||
|
||||
test "interpolation: UTF8 strings in the backend are still returned as UTF8 even with numbers interpolation" do
|
||||
I18n.backend.store_translations 'en', 'encoding' => '%{count} times: måmmå miå'
|
||||
result = I18n.t 'encoding', :count => 3
|
||||
assert_equal Encoding::UTF_8, result.encoding
|
||||
end
|
||||
end
|
||||
|
||||
test "interpolation: given a translations containing a reserved key it raises I18n::ReservedInterpolationKey" do
|
||||
assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{exception_handler}') }
|
||||
assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{default}') }
|
||||
assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{separator}') }
|
||||
assert_raises(I18n::ReservedInterpolationKey) { interpolate(:foo => :bar, :default => '%{scope}') }
|
||||
assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '%{scope}') }
|
||||
|
||||
I18n.backend.store_translations(:en, :interpolate => 'Hi %{scope}!')
|
||||
assert_raises(I18n::ReservedInterpolationKey) { interpolate(:interpolate) }
|
||||
end
|
||||
|
||||
test "interpolation: it does not raise I18n::ReservedInterpolationKey for escaped variables" do
|
||||
assert_nothing_raised do
|
||||
assert_equal '%{separator}', interpolate(:foo => :bar, :default => '%%{separator}')
|
||||
end
|
||||
|
||||
# Note: The two interpolations below do not remove the escape character (%) because
|
||||
# I18n should not alter the strings when no interpolation parameters are given,
|
||||
# see the comment at the top of this file.
|
||||
assert_nothing_raised do
|
||||
assert_equal '%%{scope}', interpolate(:default => '%%{scope}')
|
||||
end
|
||||
|
||||
I18n.backend.store_translations(:en, :interpolate => 'Hi %%{scope}!')
|
||||
assert_nothing_raised do
|
||||
assert_equal 'Hi %%{scope}!', interpolate(:interpolate)
|
||||
end
|
||||
end
|
||||
|
||||
test "interpolation: deep interpolation for default string" do
|
||||
assert_equal 'Hi %{name}!', interpolate(:default => 'Hi %{name}!', :deep_interpolation => true)
|
||||
end
|
||||
|
||||
test "interpolation: deep interpolation for interpolated string" do
|
||||
assert_equal 'Hi Ann!', interpolate(:default => 'Hi %{name}!', :name => 'Ann', :deep_interpolation => true)
|
||||
end
|
||||
|
||||
test "interpolation: deep interpolation for Hash" do
|
||||
people = { :people => { :ann => 'Ann is %{ann}', :john => 'John is %{john}' } }
|
||||
interpolated_people = { :people => { :ann => 'Ann is good', :john => 'John is big' } }
|
||||
assert_equal interpolated_people, interpolate(:default => people, :ann => 'good', :john => 'big', :deep_interpolation => true)
|
||||
end
|
||||
|
||||
test "interpolation: deep interpolation for Array" do
|
||||
people = { :people => ['Ann is %{ann}', 'John is %{john}'] }
|
||||
interpolated_people = { :people => ['Ann is good', 'John is big'] }
|
||||
assert_equal interpolated_people, interpolate(:default => people, :ann => 'good', :john => 'big', :deep_interpolation => true)
|
||||
end
|
||||
|
||||
protected
|
||||
|
||||
def capture(stream)
|
||||
begin
|
||||
stream = stream.to_s
|
||||
eval "$#{stream} = StringIO.new"
|
||||
yield
|
||||
result = eval("$#{stream}").string
|
||||
ensure
|
||||
eval("$#{stream} = #{stream.upcase}")
|
||||
end
|
||||
|
||||
result
|
||||
end
|
||||
|
||||
def euc_jp(string)
|
||||
string.encode(Encoding::EUC_JP)
|
||||
end
|
||||
|
||||
def interpolate(*args)
|
||||
options = args.last.is_a?(Hash) ? args.pop : {}
|
||||
key = args.pop
|
||||
I18n.backend.translate('en', key, options)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,66 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Link
|
||||
test "linked lookup: if a key resolves to a symbol it looks up the symbol" do
|
||||
I18n.backend.store_translations 'en', {
|
||||
:link => :linked,
|
||||
:linked => 'linked'
|
||||
}
|
||||
assert_equal 'linked', I18n.backend.translate('en', :link)
|
||||
end
|
||||
|
||||
test "linked lookup: if a key resolves to a dot-separated symbol it looks up the symbol" do
|
||||
I18n.backend.store_translations 'en', {
|
||||
:link => :"foo.linked",
|
||||
:foo => { :linked => 'linked' }
|
||||
}
|
||||
assert_equal('linked', I18n.backend.translate('en', :link))
|
||||
end
|
||||
|
||||
test "linked lookup: if a dot-separated key resolves to a symbol it looks up the symbol" do
|
||||
I18n.backend.store_translations 'en', {
|
||||
:foo => { :link => :linked },
|
||||
:linked => 'linked'
|
||||
}
|
||||
assert_equal('linked', I18n.backend.translate('en', :'foo.link'))
|
||||
end
|
||||
|
||||
test "linked lookup: if a dot-separated key resolves to a dot-separated symbol it looks up the symbol" do
|
||||
I18n.backend.store_translations 'en', {
|
||||
:foo => { :link => :"bar.linked" },
|
||||
:bar => { :linked => 'linked' }
|
||||
}
|
||||
assert_equal('linked', I18n.backend.translate('en', :'foo.link'))
|
||||
end
|
||||
|
||||
test "linked lookup: links always refer to the absolute key" do
|
||||
I18n.backend.store_translations 'en', {
|
||||
:foo => { :link => :linked, :linked => 'linked in foo' },
|
||||
:linked => 'linked absolutely'
|
||||
}
|
||||
assert_equal 'linked absolutely', I18n.backend.translate('en', :link, :scope => :foo)
|
||||
end
|
||||
|
||||
test "linked lookup: a link can resolve to a namespace in the middle of a dot-separated key" do
|
||||
I18n.backend.store_translations 'en', {
|
||||
:activemodel => { :errors => { :messages => { :blank => "can't be blank" } } },
|
||||
:activerecord => { :errors => { :messages => :"activemodel.errors.messages" } }
|
||||
}
|
||||
assert_equal "can't be blank", I18n.t(:"activerecord.errors.messages.blank")
|
||||
assert_equal "can't be blank", I18n.t(:"activerecord.errors.messages.blank")
|
||||
end
|
||||
|
||||
test "linked lookup: a link can resolve with option :count" do
|
||||
I18n.backend.store_translations 'en', {
|
||||
:counter => :counted,
|
||||
:counted => { :foo => { :one => "one", :other => "other" }, :bar => "bar" }
|
||||
}
|
||||
assert_equal "one", I18n.t(:'counter.foo', count: 1)
|
||||
assert_equal "other", I18n.t(:'counter.foo', count: 2)
|
||||
assert_equal "bar", I18n.t(:'counter.bar', count: 3)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,19 @@
|
||||
module I18n
|
||||
module Tests
|
||||
module Localization
|
||||
autoload :Date, 'i18n/tests/localization/date'
|
||||
autoload :DateTime, 'i18n/tests/localization/date_time'
|
||||
autoload :Time, 'i18n/tests/localization/time'
|
||||
autoload :Procs, 'i18n/tests/localization/procs'
|
||||
|
||||
def self.included(base)
|
||||
base.class_eval do
|
||||
include I18n::Tests::Localization::Date
|
||||
include I18n::Tests::Localization::DateTime
|
||||
include I18n::Tests::Localization::Procs
|
||||
include I18n::Tests::Localization::Time
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,122 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Localization
|
||||
module Date
|
||||
def setup
|
||||
super
|
||||
setup_date_translations
|
||||
@date = ::Date.new(2008, 3, 1)
|
||||
end
|
||||
|
||||
test "localize Date: given the short format it uses it" do
|
||||
assert_equal '01. Mär', I18n.l(@date, :format => :short, :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given the long format it uses it" do
|
||||
assert_equal '01. März 2008', I18n.l(@date, :format => :long, :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given the default format it uses it" do
|
||||
assert_equal '01.03.2008', I18n.l(@date, :format => :default, :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given a day name format it returns the correct day name" do
|
||||
assert_equal 'Samstag', I18n.l(@date, :format => '%A', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given a uppercased day name format it returns the correct day name in upcase" do
|
||||
assert_equal 'samstag'.upcase, I18n.l(@date, :format => '%^A', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given an abbreviated day name format it returns the correct abbreviated day name" do
|
||||
assert_equal 'Sa', I18n.l(@date, :format => '%a', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given an meridian indicator format it returns the correct meridian indicator" do
|
||||
assert_equal 'AM', I18n.l(@date, :format => '%p', :locale => :de)
|
||||
assert_equal 'am', I18n.l(@date, :format => '%P', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given an abbreviated and uppercased day name format it returns the correct abbreviated day name in upcase" do
|
||||
assert_equal 'sa'.upcase, I18n.l(@date, :format => '%^a', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given a month name format it returns the correct month name" do
|
||||
assert_equal 'März', I18n.l(@date, :format => '%B', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given a uppercased month name format it returns the correct month name in upcase" do
|
||||
assert_equal 'märz'.upcase, I18n.l(@date, :format => '%^B', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given an abbreviated month name format it returns the correct abbreviated month name" do
|
||||
assert_equal 'Mär', I18n.l(@date, :format => '%b', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given an abbreviated and uppercased month name format it returns the correct abbreviated month name in upcase" do
|
||||
assert_equal 'mär'.upcase, I18n.l(@date, :format => '%^b', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given a date format with the month name upcased it returns the correct value" do
|
||||
assert_equal '1. FEBRUAR 2008', I18n.l(::Date.new(2008, 2, 1), :format => "%-d. %^B %Y", :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Date: given missing translations it returns the correct error message" do
|
||||
assert_equal 'Translation missing: fr.date.abbr_month_names', I18n.l(@date, :format => '%b', :locale => :fr)
|
||||
end
|
||||
|
||||
test "localize Date: given an unknown format it does not fail" do
|
||||
assert_nothing_raised { I18n.l(@date, :format => '%x') }
|
||||
end
|
||||
|
||||
test "localize Date: does not modify the options hash" do
|
||||
options = { :format => '%b', :locale => :de }
|
||||
assert_equal 'Mär', I18n.l(@date, **options)
|
||||
assert_equal({ :format => '%b', :locale => :de }, options)
|
||||
assert_nothing_raised { I18n.l(@date, **options.freeze) }
|
||||
end
|
||||
|
||||
test "localize Date: given nil with default value it returns default" do
|
||||
assert_equal 'default', I18n.l(nil, :default => 'default')
|
||||
end
|
||||
|
||||
test "localize Date: given nil it raises I18n::ArgumentError" do
|
||||
assert_raises(I18n::ArgumentError) { I18n.l(nil) }
|
||||
end
|
||||
|
||||
test "localize Date: given a plain Object it raises I18n::ArgumentError" do
|
||||
assert_raises(I18n::ArgumentError) { I18n.l(Object.new) }
|
||||
end
|
||||
|
||||
test "localize Date: given a format is missing it raises I18n::MissingTranslationData" do
|
||||
assert_raises(I18n::MissingTranslationData) { I18n.l(@date, :format => :missing) }
|
||||
end
|
||||
|
||||
test "localize Date: it does not alter the format string" do
|
||||
assert_equal '01. Februar 2009', I18n.l(::Date.parse('2009-02-01'), :format => :long, :locale => :de)
|
||||
assert_equal '01. Oktober 2009', I18n.l(::Date.parse('2009-10-01'), :format => :long, :locale => :de)
|
||||
end
|
||||
|
||||
protected
|
||||
|
||||
def setup_date_translations
|
||||
I18n.backend.store_translations :de, {
|
||||
:date => {
|
||||
:formats => {
|
||||
:default => "%d.%m.%Y",
|
||||
:short => "%d. %b",
|
||||
:long => "%d. %B %Y",
|
||||
},
|
||||
:day_names => %w(Sonntag Montag Dienstag Mittwoch Donnerstag Freitag Samstag),
|
||||
:abbr_day_names => %w(So Mo Di Mi Do Fr Sa),
|
||||
:month_names => %w(Januar Februar März April Mai Juni Juli August September Oktober November Dezember).unshift(nil),
|
||||
:abbr_month_names => %w(Jan Feb Mär Apr Mai Jun Jul Aug Sep Okt Nov Dez).unshift(nil)
|
||||
}
|
||||
}
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,103 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Localization
|
||||
module DateTime
|
||||
def setup
|
||||
super
|
||||
setup_datetime_translations
|
||||
@datetime = ::DateTime.new(2008, 3, 1, 6)
|
||||
@other_datetime = ::DateTime.new(2008, 3, 1, 18)
|
||||
end
|
||||
|
||||
test "localize DateTime: given the short format it uses it" do
|
||||
assert_equal '01. Mär 06:00', I18n.l(@datetime, :format => :short, :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given the long format it uses it" do
|
||||
assert_equal '01. März 2008 06:00', I18n.l(@datetime, :format => :long, :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given the default format it uses it" do
|
||||
assert_equal 'Sa, 01. Mär 2008 06:00:00 +0000', I18n.l(@datetime, :format => :default, :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given a day name format it returns the correct day name" do
|
||||
assert_equal 'Samstag', I18n.l(@datetime, :format => '%A', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given a uppercased day name format it returns the correct day name in upcase" do
|
||||
assert_equal 'samstag'.upcase, I18n.l(@datetime, :format => '%^A', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given an abbreviated day name format it returns the correct abbreviated day name" do
|
||||
assert_equal 'Sa', I18n.l(@datetime, :format => '%a', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given an abbreviated and uppercased day name format it returns the correct abbreviated day name in upcase" do
|
||||
assert_equal 'sa'.upcase, I18n.l(@datetime, :format => '%^a', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given a month name format it returns the correct month name" do
|
||||
assert_equal 'März', I18n.l(@datetime, :format => '%B', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given a uppercased month name format it returns the correct month name in upcase" do
|
||||
assert_equal 'märz'.upcase, I18n.l(@datetime, :format => '%^B', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given an abbreviated month name format it returns the correct abbreviated month name" do
|
||||
assert_equal 'Mär', I18n.l(@datetime, :format => '%b', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given an abbreviated and uppercased month name format it returns the correct abbreviated month name in upcase" do
|
||||
assert_equal 'mär'.upcase, I18n.l(@datetime, :format => '%^b', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given a date format with the month name upcased it returns the correct value" do
|
||||
assert_equal '1. FEBRUAR 2008', I18n.l(::DateTime.new(2008, 2, 1, 6), :format => "%-d. %^B %Y", :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given missing translations it returns the correct error message" do
|
||||
assert_equal 'Translation missing: fr.date.abbr_month_names', I18n.l(@datetime, :format => '%b', :locale => :fr)
|
||||
end
|
||||
|
||||
test "localize DateTime: given a meridian indicator format it returns the correct meridian indicator" do
|
||||
assert_equal 'AM', I18n.l(@datetime, :format => '%p', :locale => :de)
|
||||
assert_equal 'PM', I18n.l(@other_datetime, :format => '%p', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given a meridian indicator format it returns the correct meridian indicator in downcase" do
|
||||
assert_equal 'am', I18n.l(@datetime, :format => '%P', :locale => :de)
|
||||
assert_equal 'pm', I18n.l(@other_datetime, :format => '%P', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize DateTime: given an unknown format it does not fail" do
|
||||
assert_nothing_raised { I18n.l(@datetime, :format => '%x') }
|
||||
end
|
||||
|
||||
test "localize DateTime: given a format is missing it raises I18n::MissingTranslationData" do
|
||||
assert_raises(I18n::MissingTranslationData) { I18n.l(@datetime, :format => :missing) }
|
||||
end
|
||||
|
||||
protected
|
||||
|
||||
def setup_datetime_translations
|
||||
# time translations might have been set up in Tests::Api::Localization::Time
|
||||
I18n.backend.store_translations :de, {
|
||||
:time => {
|
||||
:formats => {
|
||||
:default => "%a, %d. %b %Y %H:%M:%S %z",
|
||||
:short => "%d. %b %H:%M",
|
||||
:long => "%d. %B %Y %H:%M"
|
||||
},
|
||||
:am => 'am',
|
||||
:pm => 'pm'
|
||||
}
|
||||
}
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,118 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Localization
|
||||
module Procs
|
||||
test "localize: using day names from lambdas" do
|
||||
setup_time_proc_translations
|
||||
time = ::Time.utc(2008, 3, 1, 6, 0)
|
||||
assert_match(/Суббота/, I18n.l(time, :format => "%A, %d %B", :locale => :ru))
|
||||
assert_match(/суббота/, I18n.l(time, :format => "%d %B (%A)", :locale => :ru))
|
||||
end
|
||||
|
||||
test "localize: using month names from lambdas" do
|
||||
setup_time_proc_translations
|
||||
time = ::Time.utc(2008, 3, 1, 6, 0)
|
||||
assert_match(/марта/, I18n.l(time, :format => "%d %B %Y", :locale => :ru))
|
||||
assert_match(/Март /, I18n.l(time, :format => "%B %Y", :locale => :ru))
|
||||
end
|
||||
|
||||
test "localize: using abbreviated day names from lambdas" do
|
||||
setup_time_proc_translations
|
||||
time = ::Time.utc(2008, 3, 1, 6, 0)
|
||||
assert_match(/марта/, I18n.l(time, :format => "%d %b %Y", :locale => :ru))
|
||||
assert_match(/март /, I18n.l(time, :format => "%b %Y", :locale => :ru))
|
||||
end
|
||||
|
||||
test "localize Date: given a format that resolves to a Proc it calls the Proc with the object" do
|
||||
setup_time_proc_translations
|
||||
date = ::Date.new(2008, 3, 1)
|
||||
assert_equal '[Sat, 01 Mar 2008, {}]', I18n.l(date, :format => :proc, :locale => :ru)
|
||||
end
|
||||
|
||||
test "localize Date: given a format that resolves to a Proc it calls the Proc with the object and extra options" do
|
||||
setup_time_proc_translations
|
||||
date = ::Date.new(2008, 3, 1)
|
||||
assert_equal %|[Sat, 01 Mar 2008, #{{:foo=>"foo"}}]|, I18n.l(date, :format => :proc, :foo => 'foo', :locale => :ru)
|
||||
end
|
||||
|
||||
test "localize DateTime: given a format that resolves to a Proc it calls the Proc with the object" do
|
||||
setup_time_proc_translations
|
||||
datetime = ::DateTime.new(2008, 3, 1, 6)
|
||||
assert_equal '[Sat, 01 Mar 2008 06:00:00 +00:00, {}]', I18n.l(datetime, :format => :proc, :locale => :ru)
|
||||
end
|
||||
|
||||
test "localize DateTime: given a format that resolves to a Proc it calls the Proc with the object and extra options" do
|
||||
setup_time_proc_translations
|
||||
datetime = ::DateTime.new(2008, 3, 1, 6)
|
||||
assert_equal %|[Sat, 01 Mar 2008 06:00:00 +00:00, #{{:foo=>"foo"}}]|, I18n.l(datetime, :format => :proc, :foo => 'foo', :locale => :ru)
|
||||
end
|
||||
|
||||
test "localize Time: given a format that resolves to a Proc it calls the Proc with the object" do
|
||||
setup_time_proc_translations
|
||||
time = ::Time.utc(2008, 3, 1, 6, 0)
|
||||
assert_equal I18n::Tests::Localization::Procs.inspect_args([time], {}), I18n.l(time, :format => :proc, :locale => :ru)
|
||||
end
|
||||
|
||||
test "localize Time: given a format that resolves to a Proc it calls the Proc with the object and extra options" do
|
||||
setup_time_proc_translations
|
||||
time = ::Time.utc(2008, 3, 1, 6, 0)
|
||||
options = { :foo => 'foo' }
|
||||
assert_equal I18n::Tests::Localization::Procs.inspect_args([time], options), I18n.l(time, **options.merge(:format => :proc, :locale => :ru))
|
||||
end
|
||||
|
||||
protected
|
||||
|
||||
def self.inspect_args(args, kwargs)
|
||||
args << kwargs
|
||||
args = args.map do |arg|
|
||||
case arg
|
||||
when ::Time, ::DateTime
|
||||
arg.strftime('%a, %d %b %Y %H:%M:%S %Z').sub('+0000', '+00:00')
|
||||
when ::Date
|
||||
arg.strftime('%a, %d %b %Y')
|
||||
when Hash
|
||||
arg.delete(:fallback_in_progress)
|
||||
arg.delete(:fallback_original_locale)
|
||||
arg.inspect
|
||||
else
|
||||
arg.inspect
|
||||
end
|
||||
end
|
||||
"[#{args.join(', ')}]"
|
||||
end
|
||||
|
||||
def setup_time_proc_translations
|
||||
I18n.backend.store_translations :ru, {
|
||||
:time => {
|
||||
:formats => {
|
||||
:proc => lambda { |*args, **kwargs| I18n::Tests::Localization::Procs.inspect_args(args, kwargs) }
|
||||
}
|
||||
},
|
||||
:date => {
|
||||
:formats => {
|
||||
:proc => lambda { |*args, **kwargs| I18n::Tests::Localization::Procs.inspect_args(args, kwargs) }
|
||||
},
|
||||
:'day_names' => lambda { |key, options|
|
||||
(options[:format] =~ /^%A/) ?
|
||||
%w(Воскресенье Понедельник Вторник Среда Четверг Пятница Суббота) :
|
||||
%w(воскресенье понедельник вторник среда четверг пятница суббота)
|
||||
},
|
||||
:'month_names' => lambda { |key, options|
|
||||
(options[:format] =~ /(%d|%e)(\s*)?(%B)/) ?
|
||||
%w(января февраля марта апреля мая июня июля августа сентября октября ноября декабря).unshift(nil) :
|
||||
%w(Январь Февраль Март Апрель Май Июнь Июль Август Сентябрь Октябрь Ноябрь Декабрь).unshift(nil)
|
||||
},
|
||||
:'abbr_month_names' => lambda { |key, options|
|
||||
(options[:format] =~ /(%d|%e)(\s*)(%b)/) ?
|
||||
%w(янв. февр. марта апр. мая июня июля авг. сент. окт. нояб. дек.).unshift(nil) :
|
||||
%w(янв. февр. март апр. май июнь июль авг. сент. окт. нояб. дек.).unshift(nil)
|
||||
},
|
||||
}
|
||||
}
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,103 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Localization
|
||||
module Time
|
||||
def setup
|
||||
super
|
||||
setup_time_translations
|
||||
@time = ::Time.utc(2008, 3, 1, 6, 0)
|
||||
@other_time = ::Time.utc(2008, 3, 1, 18, 0)
|
||||
end
|
||||
|
||||
test "localize Time: given the short format it uses it" do
|
||||
assert_equal '01. Mär 06:00', I18n.l(@time, :format => :short, :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given the long format it uses it" do
|
||||
assert_equal '01. März 2008 06:00', I18n.l(@time, :format => :long, :locale => :de)
|
||||
end
|
||||
|
||||
# TODO Seems to break on Windows because ENV['TZ'] is ignored. What's a better way to do this?
|
||||
# def test_localize_given_the_default_format_it_uses_it
|
||||
# assert_equal 'Sa, 01. Mar 2008 06:00:00 +0000', I18n.l(@time, :format => :default, :locale => :de)
|
||||
# end
|
||||
|
||||
test "localize Time: given a day name format it returns the correct day name" do
|
||||
assert_equal 'Samstag', I18n.l(@time, :format => '%A', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given a uppercased day name format it returns the correct day name in upcase" do
|
||||
assert_equal 'samstag'.upcase, I18n.l(@time, :format => '%^A', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given an abbreviated day name format it returns the correct abbreviated day name" do
|
||||
assert_equal 'Sa', I18n.l(@time, :format => '%a', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given an abbreviated and uppercased day name format it returns the correct abbreviated day name in upcase" do
|
||||
assert_equal 'sa'.upcase, I18n.l(@time, :format => '%^a', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given a month name format it returns the correct month name" do
|
||||
assert_equal 'März', I18n.l(@time, :format => '%B', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given a uppercased month name format it returns the correct month name in upcase" do
|
||||
assert_equal 'märz'.upcase, I18n.l(@time, :format => '%^B', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given an abbreviated month name format it returns the correct abbreviated month name" do
|
||||
assert_equal 'Mär', I18n.l(@time, :format => '%b', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given an abbreviated and uppercased month name format it returns the correct abbreviated month name in upcase" do
|
||||
assert_equal 'mär'.upcase, I18n.l(@time, :format => '%^b', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given a date format with the month name upcased it returns the correct value" do
|
||||
assert_equal '1. FEBRUAR 2008', I18n.l(::Time.utc(2008, 2, 1, 6, 0), :format => "%-d. %^B %Y", :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given missing translations it returns the correct error message" do
|
||||
assert_equal 'Translation missing: fr.date.abbr_month_names', I18n.l(@time, :format => '%b', :locale => :fr)
|
||||
end
|
||||
|
||||
test "localize Time: given a meridian indicator format it returns the correct meridian indicator" do
|
||||
assert_equal 'AM', I18n.l(@time, :format => '%p', :locale => :de)
|
||||
assert_equal 'PM', I18n.l(@other_time, :format => '%p', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given a meridian indicator format it returns the correct meridian indicator in upcase" do
|
||||
assert_equal 'am', I18n.l(@time, :format => '%P', :locale => :de)
|
||||
assert_equal 'pm', I18n.l(@other_time, :format => '%P', :locale => :de)
|
||||
end
|
||||
|
||||
test "localize Time: given an unknown format it does not fail" do
|
||||
assert_nothing_raised { I18n.l(@time, :format => '%x') }
|
||||
end
|
||||
|
||||
test "localize Time: given a format is missing it raises I18n::MissingTranslationData" do
|
||||
assert_raises(I18n::MissingTranslationData) { I18n.l(@time, :format => :missing) }
|
||||
end
|
||||
|
||||
protected
|
||||
|
||||
def setup_time_translations
|
||||
I18n.backend.store_translations :de, {
|
||||
:time => {
|
||||
:formats => {
|
||||
:default => "%a, %d. %b %Y %H:%M:%S %z",
|
||||
:short => "%d. %b %H:%M",
|
||||
:long => "%d. %B %Y %H:%M",
|
||||
},
|
||||
:am => 'am',
|
||||
:pm => 'pm'
|
||||
}
|
||||
}
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,87 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Lookup
|
||||
def setup
|
||||
super
|
||||
I18n.backend.store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' }, :falsy => false, :truthy => true,
|
||||
:string => "a", :array => %w(a b c), :hash => { "a" => "b" })
|
||||
end
|
||||
|
||||
test "lookup: it returns a string" do
|
||||
assert_equal("a", I18n.t(:string))
|
||||
end
|
||||
|
||||
test "lookup: it returns hash" do
|
||||
assert_equal({ :a => "b" }, I18n.t(:hash))
|
||||
end
|
||||
|
||||
test "lookup: it returns an array" do
|
||||
assert_equal(%w(a b c), I18n.t(:array))
|
||||
end
|
||||
|
||||
test "lookup: it returns a native true" do
|
||||
assert I18n.t(:truthy) === true
|
||||
end
|
||||
|
||||
test "lookup: it returns a native false" do
|
||||
assert I18n.t(:falsy) === false
|
||||
end
|
||||
|
||||
test "lookup: given a missing key, no default and no raise option it returns an error message" do
|
||||
assert_equal "Translation missing: en.missing", I18n.t(:missing)
|
||||
end
|
||||
|
||||
test "lookup: given a missing key, no default and the raise option it raises MissingTranslationData" do
|
||||
assert_raises(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
|
||||
end
|
||||
|
||||
test "lookup: does not raise an exception if no translation data is present for the given locale" do
|
||||
assert_nothing_raised { I18n.t(:foo, :locale => :xx) }
|
||||
end
|
||||
|
||||
test "lookup: does not modify the options hash" do
|
||||
options = {}
|
||||
assert_equal "a", I18n.t(:string, **options)
|
||||
assert_equal({}, options)
|
||||
assert_nothing_raised { I18n.t(:string, **options.freeze) }
|
||||
end
|
||||
|
||||
test "lookup: given an array of keys it translates all of them" do
|
||||
assert_equal %w(bar baz), I18n.t([:bar, :baz], :scope => [:foo])
|
||||
end
|
||||
|
||||
test "lookup: using a custom scope separator" do
|
||||
# data must have been stored using the custom separator when using the ActiveRecord backend
|
||||
I18n.backend.store_translations(:en, { :foo => { :bar => 'bar' } }, { :separator => '|' })
|
||||
assert_equal 'bar', I18n.t('foo|bar', :separator => '|')
|
||||
end
|
||||
|
||||
# In fact it probably *should* fail but Rails currently relies on using the default locale instead.
|
||||
# So we'll stick to this for now until we get it fixed in Rails.
|
||||
test "lookup: given nil as a locale it does not raise but use the default locale" do
|
||||
# assert_raises(I18n::InvalidLocale) { I18n.t(:bar, :locale => nil) }
|
||||
assert_nothing_raised { I18n.t(:bar, :locale => nil) }
|
||||
end
|
||||
|
||||
test "lookup: a resulting String is not frozen" do
|
||||
assert !I18n.t(:string).frozen?
|
||||
end
|
||||
|
||||
test "lookup: a resulting Array is not frozen" do
|
||||
assert !I18n.t(:array).frozen?
|
||||
end
|
||||
|
||||
test "lookup: a resulting Hash is not frozen" do
|
||||
assert !I18n.t(:hash).frozen?
|
||||
end
|
||||
|
||||
# Addresses issue: #599
|
||||
test "lookup: only interpolates once when resolving symbols" do
|
||||
I18n.backend.store_translations(:en, foo: :bar, bar: '%{value}')
|
||||
assert_equal '%{dont_interpolate_me}', I18n.t(:foo, value: '%{dont_interpolate_me}')
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,35 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Pluralization
|
||||
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
|
||||
|
||||
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
|
||||
|
||||
test "pluralization: given 1 it returns the singular translation" do
|
||||
assert_equal 'bar', I18n.t(:default => { :one => 'bar' }, :count => 1)
|
||||
end
|
||||
|
||||
test "pluralization: given 2 it returns the :other translation" do
|
||||
assert_equal 'bars', I18n.t(:default => { :other => 'bars' }, :count => 2)
|
||||
end
|
||||
|
||||
test "pluralization: given 3 it returns the :other translation" do
|
||||
assert_equal 'bars', I18n.t(:default => { :other => 'bars' }, :count => 3)
|
||||
end
|
||||
|
||||
test "pluralization: given nil it returns the whole entry" do
|
||||
assert_equal({ :one => 'bar' }, I18n.t(:default => { :one => 'bar' }, :count => nil))
|
||||
end
|
||||
|
||||
test "pluralization: given incomplete pluralization data it raises I18n::InvalidPluralizationData" do
|
||||
assert_raises(I18n::InvalidPluralizationData) { I18n.t(:default => { :one => 'bar' }, :count => 2) }
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,71 @@
|
||||
# encoding: utf-8
|
||||
|
||||
module I18n
|
||||
module Tests
|
||||
module Procs
|
||||
test "lookup: given a translation is a proc it calls the proc with the key and interpolation values" do
|
||||
I18n.backend.store_translations(:en, :a_lambda => lambda { |*args| I18n::Tests::Procs.filter_args(*args) })
|
||||
assert_equal %|[:a_lambda, #{{:foo=>"foo"}}]|, I18n.t(:a_lambda, :foo => 'foo')
|
||||
end
|
||||
|
||||
test "lookup: given a translation is a proc it passes the interpolation values as keyword arguments" do
|
||||
I18n.backend.store_translations(:en, :a_lambda => lambda { |key, foo:, **| I18n::Tests::Procs.filter_args(key, foo: foo) })
|
||||
assert_equal %|[:a_lambda, #{{:foo=>"foo"}}]|, I18n.t(:a_lambda, :foo => 'foo')
|
||||
end
|
||||
|
||||
test "defaults: given a default is a Proc it calls it with the key and interpolation values" do
|
||||
proc = lambda { |*args| I18n::Tests::Procs.filter_args(*args) }
|
||||
assert_equal %|[nil, #{{:foo=>"foo"}}]|, I18n.t(nil, :default => proc, :foo => 'foo')
|
||||
end
|
||||
|
||||
test "defaults: given a default is a key that resolves to a Proc it calls it with the key and interpolation values" do
|
||||
the_lambda = lambda { |*args| I18n::Tests::Procs.filter_args(*args) }
|
||||
I18n.backend.store_translations(:en, :a_lambda => the_lambda)
|
||||
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
|
||||
|
||||
test "interpolation: given an interpolation value is a lambda it calls it with key and values before interpolating it" do
|
||||
proc = lambda { |*args| I18n::Tests::Procs.filter_args(*args) }
|
||||
if RUBY_VERSION < "3.4"
|
||||
assert_match %r(\[\{:foo=>#<Proc.*>\}\]), I18n.t(nil, :default => '%{foo}', :foo => proc)
|
||||
else
|
||||
assert_match %r(\[\{foo: #<Proc.*>\}\]), I18n.t(nil, :default => '%{foo}', :foo => proc)
|
||||
end
|
||||
end
|
||||
|
||||
test "interpolation: given a key resolves to a Proc that returns a string then interpolation still works" do
|
||||
proc = lambda { |*args| "%{foo}: " + I18n::Tests::Procs.filter_args(*args) }
|
||||
assert_equal %|foo: [nil, #{{:foo=>"foo"}}]|, I18n.t(nil, :default => proc, :foo => 'foo')
|
||||
end
|
||||
|
||||
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
|
||||
|
||||
test "lookup: given the option :resolve => false was passed it does not resolve proc translations" do
|
||||
I18n.backend.store_translations(:en, :a_lambda => lambda { |*args| I18n::Tests::Procs.filter_args(*args) })
|
||||
assert_equal Proc, I18n.t(:a_lambda, :resolve => false).class
|
||||
end
|
||||
|
||||
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| I18n::Tests::Procs.filter_args(*args) }, :resolve => false).class
|
||||
end
|
||||
|
||||
|
||||
def self.filter_args(*args)
|
||||
args.map do |arg|
|
||||
if arg.is_a?(Hash)
|
||||
arg.delete(:fallback_in_progress)
|
||||
arg.delete(:fallback_original_locale)
|
||||
arg.delete(:skip_interpolation)
|
||||
end
|
||||
arg
|
||||
end.inspect
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
Reference in New Issue
Block a user