i18n 1.0.0 → 1.14.7

data/lib/i18n/locale/tag/parents.rb

@@ -3,18 +3,20 @@ module I18n
     module Tag
       module Parents
         def parent
-          @parent ||= begin
-            segs = to_a.compact
-            segs.length > 1 ? self.class.tag(*segs[0..(segs.length-2)].join('-')) : nil
-          end
+          @parent ||=
+            begin
+              segs = to_a
+              segs.compact!
+              segs.length > 1 ? self.class.tag(*segs[0..(segs.length - 2)].join('-')) : nil
+            end
         end
 
         def self_and_parents
-          @self_and_parents ||= [self] + parents
+          @self_and_parents ||= [self].concat parents
         end
 
         def parents
-          @parents ||= ([parent] + (parent ? parent.parents : [])).compact
+          @parents ||= parent ? [parent].concat(parent.parents) : []
         end
       end
     end

data/lib/i18n/locale/tag/simple.rb

@@ -1,5 +1,5 @@
 # Simple Locale tag implementation that computes subtags by simply splitting
-# the locale tag at '-' occurences.
+# the locale tag at '-' occurrences.
 module I18n
   module Locale
     module Tag
@@ -19,7 +19,7 @@ module I18n
         end
 
         def subtags
-          @subtags = tag.to_s.split('-').map { |subtag| subtag.to_s }
+          @subtags = tag.to_s.split('-').map!(&:to_s)
         end
 
         def to_sym

data/lib/i18n/locale.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module I18n
   module Locale
   autoload :Fallbacks, 'i18n/locale/fallbacks'

data/lib/i18n/middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module I18n
   class Middleware
 

data/lib/i18n/tests/basics.rb

@@ -5,12 +5,11 @@ module I18n
         I18n.available_locales = nil
       end
 
-      test "available_locales returns the locales stored to the backend by default" do
+      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 I18n.available_locales.include?(:de)
-        assert I18n.available_locales.include?(:en)
+        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
@@ -24,11 +23,10 @@ module I18n
         assert_equal [:foo, :bar], I18n.available_locales
 
         I18n.available_locales = nil
-        assert I18n.available_locales.include?(:de)
-        assert I18n.available_locales.include?(:en)
+        assert_equal I18n.available_locales, I18n.backend.available_locales
       end
 
-      test "available_locales memoizes when set explicitely" do
+      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')
@@ -36,7 +34,7 @@ module I18n
         assert_equal [:foo], I18n.available_locales
       end
 
-      test "available_locales delegates to the backend when not set explicitely" do
+      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

data/lib/i18n/tests/defaults.rb

@@ -37,7 +37,7 @@ module I18n
       end
 
       test "defaults: given an array of missing keys it raises a MissingTranslationData exception" do
-        assert_raise I18n::MissingTranslationData do
+        assert_raises I18n::MissingTranslationData do
           I18n.t(:does_not_exist, :default => [:does_not_exist_2, :does_not_exist_3], :raise => true)
         end
       end
@@ -47,6 +47,13 @@ module I18n
         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

data/lib/i18n/tests/interpolation.rb

@@ -24,6 +24,10 @@ module I18n
         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
@@ -37,13 +41,13 @@ module I18n
       end
 
       test "interpolation: given values but missing a key it raises I18n::MissingInterpolationArgument" do
-        assert_raise(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(I18n::MissingInterpolationArgument) do
+        assert_nothing_raised do
           assert_equal 'Barr %{foo}', interpolate(:default => '%{bar} %%{foo}', :bar => 'Barr')
         end
       end
@@ -73,13 +77,13 @@ module I18n
 
       if Object.const_defined?(:Encoding)
         test "interpolation: given a euc-jp translation and a utf-8 value it raises Encoding::CompatibilityError" do
-          assert_raise(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_raise(Encoding::CompatibilityError) do
+          assert_raises(Encoding::CompatibilityError) do
             interpolate(:default => 'こんにちは、%{name}さん!', :name => euc_jp('ゆきひろ'))
           end
         end
@@ -104,9 +108,32 @@ module I18n
       end
 
       test "interpolation: given a translations containing a reserved key it raises I18n::ReservedInterpolationKey" do
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:default => '%{default}',   :foo => :bar) }
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:default => '%{scope}',     :foo => :bar) }
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:default => '%{separator}', :foo => :bar) }
+        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

data/lib/i18n/tests/link.rb

@@ -26,7 +26,7 @@ module I18n
         }
         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" },
@@ -51,6 +51,16 @@ module I18n
         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

data/lib/i18n/tests/localization/date.rb

@@ -11,8 +11,7 @@ module I18n
         end
 
         test "localize Date: given the short format it uses it" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal '01. Mar', I18n.l(@date, :format => :short, :locale => :de)
+          assert_equal '01. Mär', I18n.l(@date, :format => :short, :locale => :de)
         end
 
         test "localize Date: given the long format it uses it" do
@@ -27,17 +26,45 @@ module I18n
           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
-          # TODO should be Mrz, shouldn't it?
-          assert_equal 'Mar', I18n.l(@date, :format => '%b', :locale => :de)
+          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
@@ -46,9 +73,9 @@ module I18n
 
         test "localize Date: does not modify the options hash" do
           options = { :format => '%b', :locale => :de }
-          assert_equal 'Mar', I18n.l(@date, options)
+          assert_equal 'Mär', I18n.l(@date, **options)
           assert_equal({ :format => '%b', :locale => :de }, options)
-          assert_nothing_raised { I18n.l(@date, options.freeze) }
+          assert_nothing_raised { I18n.l(@date, **options.freeze) }
         end
 
         test "localize Date: given nil with default value it returns default" do
@@ -56,15 +83,15 @@ module I18n
         end
 
         test "localize Date: given nil it raises I18n::ArgumentError" do
-          assert_raise(I18n::ArgumentError) { I18n.l(nil) }
+          assert_raises(I18n::ArgumentError) { I18n.l(nil) }
         end
 
         test "localize Date: given a plain Object it raises I18n::ArgumentError" do
-          assert_raise(I18n::ArgumentError) { I18n.l(Object.new) }
+          assert_raises(I18n::ArgumentError) { I18n.l(Object.new) }
         end
 
         test "localize Date: given a format is missing it raises I18n::MissingTranslationData" do
-          assert_raise(I18n::MissingTranslationData) { I18n.l(@date, :format => :missing) }
+          assert_raises(I18n::MissingTranslationData) { I18n.l(@date, :format => :missing) }
         end
 
         test "localize Date: it does not alter the format string" do
@@ -85,7 +112,7 @@ module I18n
                 :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 Mar Apr Mai Jun Jul Aug Sep Okt Nov Dez).unshift(nil)
+                :abbr_month_names => %w(Jan Feb Mär Apr Mai Jun Jul Aug Sep Okt Nov Dez).unshift(nil)
               }
             }
           end

data/lib/i18n/tests/localization/date_time.rb

@@ -12,8 +12,7 @@ module I18n
         end
 
         test "localize DateTime: given the short format it uses it" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal '01. Mar 06:00', I18n.l(@datetime, :format => :short, :locale => :de)
+          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
@@ -21,25 +20,47 @@ module I18n
         end
 
         test "localize DateTime: given the default format it uses it" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal 'Sa, 01. Mar 2008 06:00:00 +0000', I18n.l(@datetime, :format => :default, :locale => :de)
+          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
-          # TODO should be Mrz, shouldn't it?
-          assert_equal 'Mar', I18n.l(@datetime, :format => '%b', :locale => :de)
+          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
@@ -57,7 +78,7 @@ module I18n
         end
 
         test "localize DateTime: given a format is missing it raises I18n::MissingTranslationData" do
-          assert_raise(I18n::MissingTranslationData) { I18n.l(@datetime, :format => :missing) }
+          assert_raises(I18n::MissingTranslationData) { I18n.l(@datetime, :format => :missing) }
         end
 
         protected

data/lib/i18n/tests/localization/procs.rb

@@ -34,7 +34,7 @@ module I18n
         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)
+          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
@@ -46,25 +46,26 @@ module I18n
         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)
+          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)
+          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))
+          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)
+          def self.inspect_args(args, kwargs)
+            args << kwargs
             args = args.map do |arg|
               case arg
               when ::Time, ::DateTime
@@ -73,6 +74,7 @@ module I18n
                 arg.strftime('%a, %d %b %Y')
               when Hash
                 arg.delete(:fallback_in_progress)
+                arg.delete(:fallback_original_locale)
                 arg.inspect
               else
                 arg.inspect
@@ -85,12 +87,12 @@ module I18n
             I18n.backend.store_translations :ru, {
               :time => {
                 :formats => {
-                  :proc => lambda { |*args| I18n::Tests::Localization::Procs.inspect_args(args) }
+                  :proc => lambda { |*args, **kwargs| I18n::Tests::Localization::Procs.inspect_args(args, kwargs) }
                 }
               },
               :date => {
                 :formats => {
-                  :proc => lambda { |*args| I18n::Tests::Localization::Procs.inspect_args(args) }
+                  :proc => lambda { |*args, **kwargs| I18n::Tests::Localization::Procs.inspect_args(args, kwargs) }
                 },
                 :'day_names' => lambda { |key, options|
                   (options[:format] =~ /^%A/) ?

data/lib/i18n/tests/localization/time.rb

@@ -12,8 +12,7 @@ module I18n
         end
 
         test "localize Time: given the short format it uses it" do
-          # TODO should be Mrz, shouldn't it?
-          assert_equal '01. Mar 06:00', I18n.l(@time, :format => :short, :locale => :de)
+          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
@@ -29,17 +28,40 @@ module I18n
           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
-          # TODO should be Mrz, shouldn't it?
-          assert_equal 'Mar', I18n.l(@time, :format => '%b', :locale => :de)
+          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
@@ -57,7 +79,7 @@ module I18n
         end
 
         test "localize Time: given a format is missing it raises I18n::MissingTranslationData" do
-          assert_raise(I18n::MissingTranslationData) { I18n.l(@time, :format => :missing) }
+          assert_raises(I18n::MissingTranslationData) { I18n.l(@time, :format => :missing) }
         end
 
         protected

data/lib/i18n/tests/lookup.rb

@@ -30,11 +30,11 @@ module I18n
       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)
+        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_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+        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
@@ -43,9 +43,9 @@ module I18n
 
       test "lookup: does not modify the options hash" do
         options = {}
-        assert_equal "a", I18n.t(:string, options)
+        assert_equal "a", I18n.t(:string, **options)
         assert_equal({}, options)
-        assert_nothing_raised { I18n.t(:string, options.freeze) }
+        assert_nothing_raised { I18n.t(:string, **options.freeze) }
       end
 
       test "lookup: given an array of keys it translates all of them" do
@@ -61,7 +61,7 @@ module I18n
       # 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_raise(I18n::InvalidLocale) { I18n.t(:bar, :locale => nil) }
+        # assert_raises(I18n::InvalidLocale) { I18n.t(:bar, :locale => nil) }
         assert_nothing_raised { I18n.t(:bar, :locale => nil) }
       end
 
@@ -76,6 +76,12 @@ module I18n
       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

data/lib/i18n/tests/pluralization.rb

@@ -28,7 +28,7 @@ module I18n
       end
 
       test "pluralization: given incomplete pluralization data it raises I18n::InvalidPluralizationData" do
-        assert_raise(I18n::InvalidPluralizationData) { I18n.t(:default => { :one => 'bar' }, :count => 2) }
+        assert_raises(I18n::InvalidPluralizationData) { I18n.t(:default => { :one => 'bar' }, :count => 2) }
       end
     end
   end

data/lib/i18n/tests/procs.rb

@@ -5,29 +5,38 @@ module I18n
     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')
+        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')
+        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')
+        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) }
-        assert_match %r(\[\{:foo=>#<Proc.*>\}\]), I18n.t(nil, :default => '%{foo}', :foo => proc)
+        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')
+        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
@@ -48,7 +57,14 @@ module I18n
 
 
       def self.filter_args(*args)
-        args.map {|arg| arg.delete(:fallback_in_progress) if arg.is_a?(Hash) ; arg }.inspect
+        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

data/lib/i18n/tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module I18n
   module Tests
     autoload :Basics,        'i18n/tests/basics'