i18n 0.3.0 → 0.3.1

data/CHANGELOG.textile

@@ -4,6 +4,25 @@ h2. master
 
 * (no changes)
 
+h2. 0.3.1 (2009-12-11)
+
+* "Add PoParser to gemspec":http://github.com/svenfuchs/i18n/commit/d6b2763f39c932f66adb039b96882a472f883c51
+* "Enable custom separators for ActiveRecord backend":http://github.com/svenfuchs/i18n/commit/9341d3fcfc951cc31807ba672d2b5d90909ef3e5
+* "Pass interpolation values to interpolation procs":http://github.com/svenfuchs/i18n/commit/39c2ed8fbad645671cd5520ce7ad0aeefe2b0cca
+* "Fix that ngettext supports keys with dots":http://github.com/svenfuchs/i18n/commit/7362a43c34364d500de8899cfcca6bf1a5e6d1c8
+
+h2. 0.3.0 (2009-11-30)
+
+* "Gettext backend and helpers":http://github.com/svenfuchs/i18n/commit/35a1740d2f10b808548af352006950da4017e374
+* "Metadata module":http://github.com/svenfuchs/i18n/commit/2677208555179b36fcbe958c0e8bc642cf5bc020
+* "Basic ActiveRecord backend":http://github.com/svenfuchs/i18n/commit/786632d0b42de423ecf0969622efc87f1691e2a2
+* "Set encoding to UTF8 for all files":http://github.com/svenfuchs/i18n/commit/9be3d4a311b5bf583eec5d39986176cc40c112f2
+* "Chain backend":http://github.com/svenfuchs/i18n/commit/08259ffb88b3005403648d77bc1cbca0b92f3cf5
+* "Backend/cache implementation":http://github.com/svenfuchs/i18n/commit/e7bf15351cd2e27f5972eb40e65a5dd6f4a0feed
+* "Pluralization module":http://github.com/svenfuchs/i18n/commit/9ca4c9ed52d4706566a6abeb2d78722dcc5d4764
+* "add and adapt Globalize2 fallback implementation":http://github.com/svenfuchs/i18n/commit/1b37a303b27d6222b17162804b06323e5628768f
+* "move Simple backend implementation to a Base backend class and extend Simple from Base.":http://github.com/svenfuchs/i18n/commit/32ddc80a04e6aa247f6d6613bde7f78c73396cb4
+
 h2. 0.2.0 (2009-07-12)
 
 * "Allow using Ruby 1.9 syntax for string interpolation (API addition)":http://github.com/svenfuchs/i18n/commit/c6e0b06d512f2af57199a843a1d8a40241b32861

data/README.textile

@@ -14,31 +14,40 @@ Features:
 * custom exception handlers
 * extensible architecture with a swappable backend
 
-Experimental, pluggable features:
+Pluggable features:
 
-* lambda pluralizers stored as translation data
-* RFC4647 compliant locale fallbacks (with optional RFC4646 locale validation)
-* backend cache
+* Cache
+* Pluralization: lambda pluralizers stored as translation data
+* Locale fallbacks, RFC4647 compliant (optionally: RFC4646 locale validation)
+* Gettext support
+* Translation metadata
+
+Alternative backends:
+
+* Chain
+* ActiveRecord (optionally: ActiveRecordMissing)
 
 For more information and lots of resources see: "http://rails-i18n.org/wiki":http://rails-i18n.org/wiki
 
-h2. Install
+h2. Installation
 
 gem install i18n
 
-h3. Install on Rails 2.3.4 (deprecated)
+h3. Installation on Rails < 2.3.5 (deprecated)
 
-Rails 2.3.4 will not accept i18n gems > 0.1.3. There is an unpacked gem inside of active_support/lib/vendor which gets loaded unless gem 'i18n', '~> 0.1.3'. This requirement is relaxed in http://github.com/rails/rails/commit/6da036538334fd459156ab2789c9fae5512be5d2
+Up to version 2.3.4 Rails will not accept i18n gems > 0.1.3. There is an unpacked 
+gem inside of active_support/lib/vendor which gets loaded unless gem 'i18n', '~> 0.1.3'. 
+This requirement is relaxed in "6da03653":http://github.com/rails/rails/commit/6da03653
 
-The following is needed to get the new i18n gem inside vendor/plugins loaded properly.
+The new i18n gem can be loaded from vendor/plugins like this:
 
-      def reload_i18n!
-        raise "Move to i18n version 0.2.0 or greater" if Rails.version > "2.3.4"
-
-        $:.grep(/i18n/).each { |path| $:.delete(path) }
-        I18n::Backend.send :remove_const, "Simple"
-        $: << Rails.root.join('vendor', 'plugins', 'i18n', 'lib').to_s
-      end
+  def reload_i18n!
+    raise "Move to i18n version 0.2.0 or greater" if Rails.version > "2.3.4"
+  
+    $:.grep(/i18n/).each { |path| $:.delete(path) }
+    I18n::Backend.send :remove_const, "Simple"
+    $: << Rails.root.join('vendor', 'plugins', 'i18n', 'lib').to_s
+  end
 
 Then you can `reload_i18n!` inside an i18n initializer. 
 
@@ -50,6 +59,23 @@ h2. Authors
 * "Saimon Moore":http://saimonmoore.net
 * "Matt Aimonetti":http://railsontherun.com
 
+h2. Contributors
+
+* Akira Matsuda
+* Andrew Briening
+* Clemens Kofler
+* Frederick Cheung
+* Jeremy Kemper
+* José Valim
+* Lawrence Pit
+* Luca Guidi
+* M4SSIVE
+* Marko Seppae
+* Mathias Meyer
+* Michael Lang
+* Theo Cushion
+* Yaroslav Markin
+
 h2. License
 
 MIT License. See the included MIT-LICENCE file.

data/Rakefile

@@ -14,7 +14,7 @@ begin
     s.homepage = "http://rails-i18n.org"
     s.description = "Add Internationalization support to your Ruby application."
     s.authors = ['Sven Fuchs', 'Joshua Harvey', 'Matt Aimonetti', 'Stephan Soller', 'Saimon Moore']
-    s.files =  FileList["[A-Z]*", "{lib,test}/**/*"]
+    s.files =  FileList["[A-Z]*", "{lib,test,vendor}/**/*"]
   end
 rescue LoadError
   puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/lib/i18n.rb

@@ -203,7 +203,7 @@ module I18n
     def translate(*args)
       options = args.last.is_a?(Hash) ? args.pop : {}
       key     = args.shift
-      locale  = options.delete(:locale) || I18n.locale
+      locale  = options.key?(:locale) ? options.delete(:locale) : I18n.locale
       raises  = options.delete(:raise)
       backend.translate(locale, key, options)
     rescue I18n::ArgumentError => exception

data/lib/i18n/backend/active_record.rb

@@ -7,10 +7,11 @@ require 'i18n/backend/active_record/translation'
 #  as the following example shows:
 #
 #     I18n.backend = I18n::Backend::Chain.new(I18n::Backend::ActiveRecord.new, I18.backend, I18n::Backend::ActiveRecordMissing.new)
-#  
+#
 module I18n
   module Backend
     class ActiveRecord
+      autoload :Missing,     'i18n/backend/active_record/missing'
       autoload :StoreProcs,  'i18n/backend/active_record/store_procs'
       autoload :Translation, 'i18n/backend/active_record/translation'
 
@@ -19,9 +20,9 @@ module I18n
       def reload!
       end
 
-      def store_translations(locale, data)
-        separator = I18n.default_separator # TODO allow to pass as an option?
-        wind_keys(data).each do |key, v|
+      def store_translations(locale, data, options = {})
+        separator = options[:separator] || I18n.default_separator
+        wind_keys(data, separator).each do |key, v|
           Translation.locale(locale).lookup(expand_keys(key, separator), separator).delete_all
           Translation.create(:locale => locale.to_s, :key => key, :value => v)
         end
@@ -54,7 +55,7 @@ module I18n
               hash[r.key.slice(chop_range)] = r.value
               hash
             end
-            deep_symbolize_keys(unwind_keys(result))
+            deep_symbolize_keys(unwind_keys(result, separator))
           end
         end
 

data/lib/i18n/backend/active_record/missing.rb

@@ -0,0 +1,64 @@
+#  This extension stores translation stub records for missing translations to
+#  the database.
+#
+#  This is useful if you have a web based translation tool. It will populate
+#  the database with untranslated keys as the application is being used. A
+#  translator can then go through these and add missing translations.
+#
+#  Example usage:
+#
+#     I18n::Backend::Chain.send(:include, I18n::Backend::ActiveRecord::Missing)
+#     I18n.backend = I18nChainBackend.new(I18n::Backend::ActiveRecord.new, I18n::Backend::Simple.new)
+#
+#  Stub records for pluralizations will also be created for each key defined
+#  in i18n.plural_keys.
+#
+#  For example:
+#
+#    # en.yml
+#    en:
+#      i18n:
+#        plural_keys: [:zero, :one, :other]
+#
+#    # pl.yml
+#    pl:
+#      i18n:
+#        plural_keys: [:zero, :one, :few, :other]
+#
+#  It will also persist interpolation keys in Translation#interpolations so
+#  translators will be able to review and use them.
+module I18n
+  module Backend
+    class ActiveRecord
+      module Missing
+        def store_default_translations(locale, key, options = {})
+          count, scope, default, separator = options.values_at(:count, *Base::RESERVED_KEYS)
+          separator ||= I18n.default_separator
+          keys = I18n.send(:normalize_translation_keys, locale, key, scope, separator)[1..-1]
+          key = keys.join(separator || I18n.default_separator)
+
+          unless ActiveRecord::Translation.locale(locale).lookup(key, separator).exists?
+            interpolations = options.reject { |name, value| Base::RESERVED_KEYS.include?(name) }.keys
+            keys = count ? I18n.t('i18n.plural_keys', :locale => locale).map { |k| [key, k].join(separator) } : [key]
+            keys.each { |key| store_default_translation(locale, key, interpolations) } 
+          end
+        end
+
+        def store_default_translation(locale, key, interpolations)
+          translation = ActiveRecord::Translation.new :locale => locale.to_s, :key => key
+          translation.interpolations = interpolations
+          translation.save
+        end
+      
+        def translate(locale, key, options = {})
+          super
+
+          rescue I18n::MissingTranslationData => e
+            self.store_default_translations(locale, key, options)
+
+            raise e
+        end
+      end
+    end
+  end
+end

data/lib/i18n/backend/active_record/translation.rb

@@ -57,12 +57,12 @@ module I18n
 
         named_scope :lookup, lambda { |keys, *separator|
           keys = Array(keys).map! { |key| key.to_s }
-          separator ||= I18n.default_separator
+          separator = separator.first || I18n.default_separator
           { :conditions => ["`key` IN (?) OR `key` LIKE '#{keys.last}#{separator}%'", keys] }
         }
 
         def self.available_locales
-          Translation.find(:all, :select => 'DISTINCT locale').map { |t| t.locale }
+          Translation.find(:all, :select => 'DISTINCT locale').map { |t| t.locale.to_sym }
         end
         
         def interpolates?(key)

data/lib/i18n/backend/base.rb

@@ -21,7 +21,7 @@ module I18n
       # This uses a deep merge for the translations hash, so existing
       # translations will be overwritten by new ones only at the deepest
       # level of the hash.
-      def store_translations(locale, data)
+      def store_translations(locale, data, options = {})
         merge_translations(locale, data)
       end
 
@@ -183,7 +183,7 @@ module I18n
               "%{#{key}}"
             end
           end
-          values.each { |key, value| values[key] = value.call if interpolate_lambda?(value, s, key) }
+          values.each { |key, value| values[key] = value.call(values) if interpolate_lambda?(value, s, key) }
           s % values
 
         rescue KeyError => e

data/lib/i18n/backend/chain.rb

@@ -27,8 +27,8 @@ module I18n
         backends.each { |backend| backend.reload! }
       end
 
-      def store_translations(locale, data)
-        backends.first.store_translations(locale, data)
+      def store_translations(locale, data, options = {})
+        backends.first.store_translations(locale, data, options = {})
       end
 
       def available_locales
@@ -62,7 +62,7 @@ module I18n
             result = backend.localize(locale, object, format, options) and return result
           rescue MissingTranslationData
           end
-        end or nil
+        end and nil
       end
 
       protected

data/lib/i18n/helpers/gettext.rb

@@ -40,7 +40,7 @@ module I18n
 
         scope, msgid = I18n::Gettext.extract_scope(msgid, separator)
         default = { :one => msgid, :other => msgid_plural }
-        I18n.t(msgid, :default => default, :count => n, :scope => scope)
+        I18n.t(msgid, :default => default, :count => n, :scope => scope, :separator => separator)
       end
       alias ns_ nsgettext
 

data/test/all.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
-base = File.dirname(__FILE__)
-$LOAD_PATH.unshift base
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(dir)
 
-Dir["#{base}/**/*_test.rb"].sort.each do |file|
-  require file.sub(/^#{base}\/(.*)\.rb$/, '\1')
+Dir["#{dir}/**/*_test.rb"].sort.each do |file|
+  require file.sub(/^#{dir}\/(.*)\.rb$/, '\1')
 end

data/test/api/basics.rb

@@ -1,14 +1,14 @@
 # encoding: utf-8
 
 module Tests
-  module Backend
-    module Api
-      module Basics
-        def test_available_locales
-          backend_store_translations 'de', :foo => 'bar'
-          backend_store_translations 'en', :foo => 'foo'
-          assert_equal ['de', 'en'], I18n.backend.available_locales.map{|locale| locale.to_s }.sort
-        end
+  module Api
+    module Basics
+      def test_available_locales
+        store_translations('de', :foo => 'bar')
+        store_translations('en', :foo => 'foo')
+
+        assert I18n.available_locales.include?(:de)
+        assert I18n.available_locales.include?(:en)
       end
     end
   end

data/test/api/defaults.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Tests
+  module Api
+    module Defaults
+      def setup
+        super
+        store_translations(:foo => { :bar => 'bar', :baz => 'baz' })
+      end
+      
+      define_method "test defaults: given nil as a key it returns the given default" do
+        assert_equal 'default', I18n.t(nil, :default => 'default')
+      end
+      
+      define_method "test defaults: given a symbol as a default it translates the symbol" do
+        assert_equal 'bar', I18n.t(nil, :default => :'foo.bar')
+      end
+
+      define_method "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
+
+      define_method "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
+
+      define_method "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
+
+      define_method "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/test/api/interpolation.rb

@@ -1,93 +1,91 @@
 # encoding: utf-8
 
 module Tests
-  module Backend
-    module Api
-      module Interpolation
-        def interpolate(*args)
-          options = args.last.is_a?(Hash) ? args.pop : {}
-          key = args.pop
-          I18n.backend.translate('en', key, options)
-        end
+  module Api
+    module Interpolation
+      def interpolate(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        key = args.pop
+        I18n.backend.translate('en', key, options)
+      end
 
-        def test_interpolation_given_no_interpolation_values_it_does_not_alter_the_string
-          assert_equal 'Hi {{name}}!', interpolate(:default => 'Hi {{name}}!')
-        end
+      define_method "test interpolation: given no values it does not alter the string" do
+        assert_equal 'Hi {{name}}!', interpolate(:default => 'Hi {{name}}!')
+      end
 
-        def test_interpolation_given_interpolation_values_it_interpolates_the_values_to_the_string
-          assert_equal 'Hi David!', interpolate(:default => 'Hi {{name}}!', :name => 'David')
-        end
+      define_method "test interpolation: given values it interpolates them into the string" do
+        assert_equal 'Hi David!', interpolate(:default => 'Hi {{name}}!', :name => 'David')
+      end
 
-        def test_interpolation_given_interpolation_values_with_nil_values_it_interpolates_the_values_to_the_string
-          assert_equal 'Hi !', interpolate(:default => 'Hi {{name}}!', :name => nil)
-        end
+      define_method "test interpolation: given a nil value it still interpolates it into the string" do
+        assert_equal 'Hi !', interpolate(:default => 'Hi {{name}}!', :name => nil)
+      end
 
-        def test_interpolation_given_a_lambda_as_a_value_it_calls_it_when_the_string_contains_the_key
-          assert_equal 'Hi David!', interpolate(:default => 'Hi {{name}}!', :name => lambda { 'David' })
-        end
+      define_method "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 { 'David' })
+      end
 
-        def test_interpolation_given_a_lambda_as_a_value_it_does_not_call_it_when_the_string_does_not_contain_the_key
-          assert_nothing_raised { interpolate(:default => 'Hi!', :name => lambda { raise 'fail' }) }
-        end
+      define_method "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 { raise 'fail' }) }
+      end
 
-        def test_interpolation_given_interpolation_values_but_missing_a_key_it_raises_a_missing_interpolation_argument_exception
-          assert_raises(I18n::MissingInterpolationArgument) do
-            interpolate(:default => '{{foo}}', :bar => 'bar')
-          end
+      define_method "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
 
-        def test_interpolation_does_not_raise_missing_interpolation_argument_exceptions_for_escaped_variables
-          assert_nothing_raised(I18n::MissingInterpolationArgument) do
-            assert_equal 'Barr {{foo}}', interpolate(:default => '{{bar}} \{{foo}}', :bar => 'Barr')
-          end
+      define_method "test interpolation: it does not raise I18n::MissingInterpolationArgument for escaped variables" do
+        assert_nothing_raised(I18n::MissingInterpolationArgument) do
+          assert_equal 'Barr {{foo}}', interpolate(:default => '{{bar}} \{{foo}}', :bar => 'Barr')
         end
+      end
 
-        def test_interpolation_does_not_change_the_original_stored_translation_string_and_allows_reinterpolation
-          I18n.backend.store_translations(:en, :interpolate => 'Hi {{name}}!')
-          assert_equal 'Hi David!', interpolate(:interpolate, :name => 'David')
-          assert_equal 'Hi Yehuda!', interpolate(:interpolate, :name => 'Yehuda')
-          # assert_equal 'Hi {{name}}!', I18n.backend.instance_variable_get(:@translations)[:en][:interpolate]
-        end
+      define_method "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
 
-        def test_interpolate_with_ruby_1_9_syntax
-          assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => 'David')
-        end
+      define_method "test interpolation: works with Ruby 1.9 syntax" do
+        assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => 'David')
+      end
 
-        def test_interpolate_given_a_value_hash_interpolates_into_unicode_string
-          assert_equal 'Häi David!', interpolate(:default => 'Häi {{name}}!', :name => 'David')
-        end
+      define_method "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
 
-        def test_interpolate_given_a_unicode_value_hash_interpolates_to_the_string
-          assert_equal 'Hi ゆきひろ!', interpolate(:default => 'Hi {{name}}!', :name => 'ゆきひろ')
-        end
+      define_method "test interpolation: given the value is in utf-8 it still works" do
+        assert_equal 'Hi ゆきひろ!', interpolate(:default => 'Hi {{name}}!', :name => 'ゆきひろ')
+      end
 
-        def test_interpolate_given_a_unicode_value_hash_interpolates_into_unicode_string
-          assert_equal 'こんにちは、ゆきひろさん!', interpolate(:default => 'こんにちは、{{name}}さん!', :name => 'ゆきひろ')
-        end
+      define_method "test interpolation: given the translation and the value are in utf-8 it still works" do
+        assert_equal 'こんにちは、ゆきひろさん!', interpolate(:default => 'こんにちは、{{name}}さん!', :name => 'ゆきひろ')
+      end
 
-        if Kernel.const_defined?(:Encoding)
-          def test_interpolate_given_a_non_unicode_multibyte_value_hash_interpolates_into_a_string_with_the_same_encoding
-            assert_equal euc_jp('Hi ゆきひろ!'), interpolate(:default => 'Hi {{name}}!', :name => euc_jp('ゆきひろ'))
-          end
+      if Kernel.const_defined?(:Encoding)
+        define_method "test interpolation: given a utf-8 translation and a euc-jp value it returns a translation in euc-jp" do
+          assert_equal euc_jp('Hi ゆきひろ!'), interpolate(:default => 'Hi {{name}}!', :name => euc_jp('ゆきひろ'))
+        end
 
-          def test_interpolate_given_a_unicode_value_hash_into_a_non_unicode_multibyte_string_raises_encoding_compatibility_error
-            assert_raises(Encoding::CompatibilityError) do
-              interpolate(:default => euc_jp('こんにちは、{{name}}さん!'), :name => 'ゆきひろ')
-            end
+        define_method "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
-
-          def test_interpolate_given_a_non_unicode_multibyte_value_hash_into_an_unicode_string_raises_encoding_compatibility_error
-            assert_raises(Encoding::CompatibilityError) do
-              interpolate(:default => 'こんにちは、{{name}}さん!', :name => euc_jp('ゆきひろ'))
-            end
+        end
+        
+        # TODO should better explain how this relates to the test above with the simpler utf-8 default string
+        define_method "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
+      end
 
-        def test_interpolate_given_a_string_containing_a_reserved_key_raises_reserved_interpolation_key
-          assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '{{default}}',   :foo => :bar) }
-          assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '{{scope}}',     :foo => :bar) }
-          assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '{{separator}}', :foo => :bar) }
-        end
+      define_method "test interpolation: given a translations containing a reserved key it raises I18n::ReservedInterpolationKey" do
+        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '{{default}}',   :foo => :bar) }
+        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '{{scope}}',     :foo => :bar) }
+        assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '{{separator}}', :foo => :bar) }
       end
     end
   end