i18n 0.4.0 → 1.14.4

data/lib/i18n/locale/fallbacks.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 # Locale Fallbacks
 #
 # Extends the I18n module to hold a fallbacks instance which is set to an
@@ -17,22 +15,15 @@
 #   * all parent locales of a given locale (e.g. :es for :"es-MX") first,
 #   * the current default locales and all of their parents second
 #
-# The default locales are set to [I18n.default_locale] by default but can be
-# set to something else.
+# The default locales are set to [] by default but can be set to something else.
 #
 # One can additionally add any number of additional fallback locales manually.
 # These will be added before the default locales to the fallback chain. For
 # example:
 #
-#   # using the default locale as default fallback locale
-#
-#   I18n.default_locale = :"en-US"
-#   I18n.fallbacks = I18n::Fallbacks.new(:"de-AT" => :"de-DE")
-#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :"de-DE", :de, :"en-US", :en]
-#
 #   # using a custom locale as default fallback locale
 #
-#   I18n.fallbacks = I18n::Fallbacks.new(:"en-GB", :"de-AT" => :de, :"de-CH" => :de)
+#   I18n.fallbacks = I18n::Locale::Fallbacks.new(:"en-GB", :"de-AT" => :de, :"de-CH" => :de)
 #   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :de, :"en-GB", :en]
 #   I18n.fallbacks[:"de-CH"] # => [:"de-CH", :de, :"en-GB", :en]
 #
@@ -48,7 +39,7 @@
 #   fallbacks[:"ar-PS"] # => [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en]
 #   fallbacks[:"ar-EG"] # => [:"ar-EG", :ar, :"en-US", :en]
 #
-#   # people speaking Sami as spoken in Finnland also speak Swedish and Finnish as spoken in Finnland
+#   # people speaking Sami as spoken in Finland also speak Swedish and Finnish as spoken in Finland
 #   fallbacks.map(:sms => [:"se-FI", :"fi-FI"])
 #   fallbacks[:sms] # => [:sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en]
 
@@ -58,40 +49,56 @@ module I18n
       def initialize(*mappings)
         @map = {}
         map(mappings.pop) if mappings.last.is_a?(Hash)
-        self.defaults = mappings.empty? ? [I18n.default_locale.to_sym] : mappings
+        self.defaults = mappings.empty? ? [] : mappings
       end
 
       def defaults=(defaults)
-        @defaults = defaults.map { |default| compute(default, false) }.flatten
+        @defaults = defaults.flat_map { |default| compute(default, false) }
       end
       attr_reader :defaults
 
       def [](locale)
         raise InvalidLocale.new(locale) if locale.nil?
+        raise Disabled.new('fallback#[]') if locale == false
         locale = locale.to_sym
         super || store(locale, compute(locale))
       end
 
-      def map(mappings)
-        mappings.each do |from, to|
-          from, to = from.to_sym, Array(to)
-          to.each do |to|
-            @map[from] ||= []
-            @map[from] << to.to_sym
+      def map(*args, &block)
+        if args.count == 1 && !block_given?
+          mappings = args.first
+          mappings.each do |from, to|
+            from, to = from.to_sym, Array(to)
+            to.each do |_to|
+              @map[from] ||= []
+              @map[from] << _to.to_sym
+            end
           end
+        else
+          @map.map(*args, &block)
         end
       end
 
+      def empty?
+        @map.empty? && @defaults.empty?
+      end
+
+      def inspect
+       "#<#{self.class.name} @map=#{@map.inspect} @defaults=#{@defaults.inspect}>"
+      end
+
       protected
 
-      def compute(tags, include_defaults = true)
-        result = Array(tags).collect do |tag|
-          tags = I18n::Locale::Tag.tag(tag).self_and_parents.map! { |t| t.to_sym }
-          tags.each { |tag| tags += compute(@map[tag]) if @map[tag] }
+      def compute(tags, include_defaults = true, exclude = [])
+        result = Array(tags).flat_map do |tag|
+          tags = I18n::Locale::Tag.tag(tag).self_and_parents.map! { |t| t.to_sym } - exclude
+          tags.each { |_tag| tags += compute(@map[_tag], false, exclude + tags) if @map[_tag] }
           tags
-        end.flatten
+        end
         result.push(*defaults) if include_defaults
-        result.uniq
+        result.uniq!
+        result.compact!
+        result
       end
     end
   end

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

@@ -1,22 +1,22 @@
-# encoding: utf-8
-
 module I18n
   module Locale
     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/rfc4646.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 # RFC 4646/47 compliant Locale tag implementation that parses locale tags to
 # subtags such as language, script, region, variant etc.
 #

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

@@ -1,7 +1,5 @@
-# encoding: utf-8
-
 # 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
@@ -21,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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module I18n
+  class Middleware
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    ensure
+      Thread.current[:i18n_config] = I18n::Config.new
+    end
+
+  end
+end

data/lib/i18n/tests/basics.rb

@@ -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

data/lib/i18n/tests/defaults.rb

@@ -0,0 +1,52 @@
+# 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
+    end
+  end
+end

data/lib/i18n/tests/interpolation.rb

@@ -0,0 +1,167 @@
+# 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'.force_encoding("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'.force_encoding("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: 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

data/lib/i18n/tests/link.rb

@@ -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

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

@@ -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