i18n 0.4.0.beta → 0.4.0.beta1

data/CHANGELOG.textile

@@ -4,6 +4,14 @@ h2. master
 
 *
 
+h2. 0.4.0.beta1 (2010-05-03)
+
+* "Renamed Fast backend to Memoize backend":http://github.com/svenfuchs/i18n/commit/f7f7dc12c00a19d3876223771e14f8671ff313cd
+
+* "Deprecate {{}} as interpolation syntax":http://github.com/svenfuchs/i18n/commit/8894ee521ef5788c415b625a6daf522af4c416e0
+
+* "Allow nil translation to be stored again":http://github.com/svenfuchs/i18n/commit/f2074f1e82d10c2e9a801c8cc2f2a0c7c30703ba
+
 h2. 0.4.0.beta (2010-04-30)
 
 * "Added a KeyValue backend":http://github.com/svenfuchs/i18n/commit/28ca5f53ade7f545f8c0804e93564d4686b416a4

data/lib/i18n.rb

@@ -12,94 +12,11 @@ require 'i18n/core_ext/string/interpolate'
 
 module I18n
   autoload :Backend, 'i18n/backend'
-  autoload :Helpers, 'i18n/helpers'
+  autoload :Config,  'i18n/config'
+  autoload :Gettext, 'i18n/gettext'
   autoload :Locale,  'i18n/locale'
 
-  class Config
-    # The only configuration value that is not global and scoped to thread is :locale.
-    # It defaults to the default_locale.
-    def locale
-      @locale ||= default_locale
-    end
-
-    # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
-    def locale=(locale)
-      @locale = locale.to_sym rescue nil
-    end
-
-    # Returns the current backend. Defaults to +Backend::Simple+.
-    def backend
-      @@backend ||= Backend::Simple.new
-    end
-
-    # Sets the current backend. Used to set a custom backend.
-    def backend=(backend)
-      @@backend = backend
-    end
-
-    # Returns the current default locale. Defaults to :'en'
-    def default_locale
-      @@default_locale ||= :en
-    end
-
-    # Sets the current default locale. Used to set a custom default locale.
-    def default_locale=(locale)
-      @@default_locale = locale.to_sym rescue nil
-    end
-
-    # Returns an array of locales for which translations are available.
-    # Unless you explicitely set the these through I18n.available_locales=
-    # the call will be delegated to the backend and memoized on the I18n module.
-    def available_locales
-      @@available_locales ||= backend.available_locales
-    end
-
-    # Sets the available locales.
-    def available_locales=(locales)
-      @@available_locales = locales
-    end
-
-    # Returns the current default scope separator. Defaults to '.'
-    def default_separator
-      @@default_separator ||= '.'
-    end
-
-    # Sets the current default scope separator.
-    def default_separator=(separator)
-      @@default_separator = separator
-    end
-
-    # Return the current exception handler. Defaults to :default_exception_handler.
-    def exception_handler
-      @@exception_handler ||= :default_exception_handler
-    end
-
-    # Sets the exception handler.
-    def exception_handler=(exception_handler)
-      @@exception_handler = exception_handler
-    end
-
-    # Allow clients to register paths providing translation data sources. The
-    # backend defines acceptable sources.
-    #
-    # E.g. the provided SimpleBackend accepts a list of paths to translation
-    # files which are either named *.rb and contain plain Ruby Hashes or are
-    # named *.yml and contain YAML data. So for the SimpleBackend clients may
-    # register translation files like this:
-    #   I18n.load_path << 'path/to/locale/en.yml'
-    def load_path
-      @@load_path ||= []
-    end
-
-    # Sets the load path instance. Custom implementations are expected to
-    # behave like a Ruby Array.
-    def load_path=(load_path)
-      @@load_path = load_path
-    end
-  end
-
   class << self
-
     # Gets I18n configuration object.
     def config
       Thread.current[:i18n_config] ||= I18n::Config.new
@@ -163,7 +80,7 @@ module I18n
     # values passed to #translate as part of the options hash, with the keys matching
     # the interpolation variable names.
     #
-    # <em>E.g.</em>, with a translation <tt>:foo => "foo {{bar}}"</tt> the option
+    # <em>E.g.</em>, with a translation <tt>:foo => "foo %{bar}"</tt> the option
     # value for the key +bar+ will be interpolated into the translation:
     #   I18n.t :foo, :bar => 'baz' # => 'foo baz'
     #
@@ -184,7 +101,7 @@ module I18n
     #
     # The <tt>:count</tt> option can be used both for pluralization and interpolation.
     # <em>E.g.</em>, with the translation
-    # <tt>:foo => ['{{count}} foo', '{{count}} foos']</tt>, count will
+    # <tt>:foo => ['%{count} foo', '%{count} foos']</tt>, count will
     # be interpolated to the pluralized translation:
     #   I18n.t :foo, :count => 1 # => '1 foo'
     #
@@ -218,7 +135,7 @@ module I18n
     # called and passed the key and options.
     #
     # E.g. assuming the key <tt>:salutation</tt> resolves to:
-    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. {{options[:name]}}" : "Mrs. {{options[:name]}}" }
+    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. %{options[:name]}" : "Mrs. %{options[:name]}" }
     #
     # Then <tt>I18n.t(:salutation, :gender => 'w', :name => 'Smith') will result in "Mrs. Smith".
     #

data/lib/i18n/backend.rb

@@ -2,17 +2,16 @@ module I18n
   module Backend
     autoload :ActiveRecord,          'i18n/backend/active_record'
     autoload :Base,                  'i18n/backend/base'
+    autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
     autoload :Cache,                 'i18n/backend/cache'
     autoload :Cascade,               'i18n/backend/cascade'
     autoload :Chain,                 'i18n/backend/chain'
     autoload :Cldr,                  'i18n/backend/cldr'
     autoload :Fallbacks,             'i18n/backend/fallbacks'
-    autoload :Fast,                  'i18n/backend/fast'
     autoload :Flatten,               'i18n/backend/flatten'
     autoload :Gettext,               'i18n/backend/gettext'
-    autoload :Helpers,               'i18n/backend/helpers'
-    autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
     autoload :KeyValue,              'i18n/backend/key_value'
+    autoload :Memoize,               'i18n/backend/memoize'
     autoload :Metadata,              'i18n/backend/metadata'
     autoload :Pluralization,         'i18n/backend/pluralization'
     autoload :Simple,                'i18n/backend/simple'

data/lib/i18n/backend/active_record.rb

@@ -8,23 +8,33 @@ module I18n
       autoload :StoreProcs,  'i18n/backend/active_record/store_procs'
       autoload :Translation, 'i18n/backend/active_record/translation'
 
-      include Base, Flatten
+      module Implementation
+        include Base, Flatten
 
-      def reload!
-      end
+        def reload!
+        end
+
+        def available_locales
+          init_translations unless initialized?
 
-      def available_locales
-        begin
-          Translation.available_locales
-        rescue ::ActiveRecord::StatementInvalid
-          []
+          begin
+            Translation.available_locales
+          rescue ::ActiveRecord::StatementInvalid
+            []
+          end
+        end
+
+        def store_translations(locale, data, options = {})
+          flatten_translations(locale, data).each do |key, value|
+            Translation.locale(locale).lookup(expand_keys(key)).delete_all
+            Translation.create(:locale => locale.to_s, :key => key.to_s, :value => value)
+          end
         end
-      end
 
       protected
 
         def lookup(locale, key, scope = [], options = {})
-          key = normalize_keys(locale, key, scope, options[:separator])
+          key = normalize_flat_keys(locale, key, scope, options[:separator])
           result = Translation.locale(locale).lookup(key).all
 
           if result.empty?
@@ -37,14 +47,7 @@ module I18n
               hash[r.key.slice(chop_range)] = r.value
               hash
             end
-            deep_symbolize_keys(result)
-          end
-        end
-
-        def merge_translations(locale, data, options = {})
-          flatten_translations(locale, data).each do |key, value|
-            Translation.locale(locale).lookup(expand_keys(key)).delete_all
-            Translation.create(:locale => locale.to_s, :key => key.to_s, :value => value)
+            result.deep_symbolize_keys
           end
         end
 
@@ -54,6 +57,9 @@ module I18n
             keys << [keys.last, key].compact.join(FLATTEN_SEPARATOR)
           end
         end
+      end
+
+      include Implementation
     end
   end
 end

data/lib/i18n/backend/base.rb

@@ -1,14 +1,15 @@
 # encoding: utf-8
 
 require 'yaml'
-require 'i18n/core_ext/hash/except'
+require 'i18n/core_ext/hash'
 
 module I18n
   module Backend
     module Base
-      include I18n::Backend::Helpers
+      include I18n::Backend::Transliterator
 
       RESERVED_KEYS = [:scope, :default, :separator, :resolve]
+      RESERVED_KEYS_PATTERN = /%?%\{(#{RESERVED_KEYS.join("|")})\}/
       INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
 
       # Accepts a list of paths to translation files. Loads translations from
@@ -23,7 +24,11 @@ module I18n
       # translations will be overwritten by new ones only at the deepest
       # level of the hash.
       def store_translations(locale, data, options = {})
-        merge_translations(locale, data, options)
+        locale = locale.to_sym
+        translations[locale] ||= {}
+
+        data = data.deep_symbolize_keys
+        translations[locale].deep_merge!(data)
       end
 
       def translate(locale, key, options = {})
@@ -34,28 +39,19 @@ module I18n
 
         if options.empty?
           entry = resolve(locale, key, entry, options)
-          raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
         else
           count, default = options.values_at(:count, :default)
-          values = options.reject { |name, value| RESERVED_KEYS.include?(name) }
-
-          entry = entry.nil? && default ? default(locale, key, default, options) : resolve(locale, key, entry, options)
-          raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
-
-          entry = pluralize(locale, entry, count) if count
-          entry = interpolate(locale, entry, values)
+          values = options.except(*RESERVED_KEYS)
+          entry = entry.nil? && default ?
+            default(locale, key, default, options) : resolve(locale, key, entry, options)
         end
 
-        entry
-      end
+        raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
+        entry = entry.dup if entry.is_a?(String)
 
-      # Given a locale and a UTF-8 string, return the locale's ASCII
-      # approximation for the string.
-      def transliterate(locale, string, replacement = nil)
-        @transliterators ||= {}
-        @transliterators[locale] ||= Transliterator.get I18n.t(:'i18n.transliterate.rule',
-          :locale => locale, :resolve => false, :default => {})
-        @transliterators[locale].transliterate(string, replacement)
+        entry = pluralize(locale, entry, count) if count
+        entry = interpolate(locale, entry, values) if values
+        entry
       end
 
       # Acts the same as +strftime+, but uses a localized version of the
@@ -101,9 +97,11 @@ module I18n
       def reload!
         @initialized = false
         @translations = nil
+        @skip_syntax_deprecation = false
       end
 
       protected
+
         def init_translations
           load_translations(*I18n.load_path.flatten)
           @initialized = true
@@ -134,7 +132,7 @@ module I18n
             return nil unless result.is_a?(Hash) && result.has_key?(key)
             result = result[key]
             result = resolve(locale, key, result, options.merge(:scope => nil)) if result.is_a?(Symbol)
-            String === result ? result.dup : result
+            result
           end
         end
 
@@ -187,8 +185,8 @@ module I18n
 
         # Interpolates values into a given string.
         #
-        #   interpolate "file {{file}} opened by \\{{user}}", :file => 'test.txt', :user => 'Mr. X'
-        #   # => "file test.txt opened by {{user}}"
+        #   interpolate "file %{file} opened by %%{user}", :file => 'test.txt', :user => 'Mr. X'
+        #   # => "file test.txt opened by %{user}"
         #
         # Note that you have to double escape the <tt>\\</tt> when you want to escape
         # the <tt>{{...}}</tt> key in a string (once for the string and once for the
@@ -197,28 +195,30 @@ module I18n
           return string unless string.is_a?(::String) && !values.empty?
 
           preserve_encoding(string) do
-            s = string.gsub(INTERPOLATION_SYNTAX_PATTERN) do
+            string = string.gsub(INTERPOLATION_SYNTAX_PATTERN) do
               escaped, key = $1, $2.to_sym
               if escaped
                 "{{#{key}}}"
-              elsif RESERVED_KEYS.include?(key)
-                raise ReservedInterpolationKey.new(key, string)
               else
+                warn_syntax_deprecation!
                 "%{#{key}}"
               end
             end
 
             values.each do |key, value|
-              value = value.call(values) if interpolate_lambda?(value, s, key)
+              value = value.call(values) if interpolate_lambda?(value, string, key)
               value = value.to_s unless value.is_a?(::String)
               values[key] = value
             end
 
-            s % values
+            string % values
           end
-
         rescue KeyError => e
-          raise MissingInterpolationArgument.new(values, string)
+          if string =~ RESERVED_KEYS_PATTERN
+            raise ReservedInterpolationKey.new($1.to_sym, string)
+          else
+            raise MissingInterpolationArgument.new(values, string)
+          end
         end
 
         def preserve_encoding(string)
@@ -246,7 +246,7 @@ module I18n
           type = File.extname(filename).tr('.', '').downcase
           raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}")
           data = send(:"load_#{type}", filename) # TODO raise a meaningful exception if this does not yield a Hash
-          data.each { |locale, d| merge_translations(locale, d) }
+          data.each { |locale, d| store_translations(locale, d) }
         end
 
         # Loads a plain Ruby translations file. eval'ing the file must yield
@@ -261,14 +261,10 @@ module I18n
           YAML::load(IO.read(filename))
         end
 
-        # Deep merges the given translations hash with the existing translations
-        # for the given locale
-        def merge_translations(locale, data, options = {})
-          locale = locale.to_sym
-          translations[locale] ||= {}
-
-          data = deep_symbolize_keys(data)
-          deep_merge_hash!(translations[locale], data)
+        def warn_syntax_deprecation! #:nodoc:
+          return if @skip_syntax_deprecation
+          warn "The {{key}} interpolation syntax in I18n messages is deprecated. Please use %{key} instead.\n#{caller.join("\n")}"
+          @skip_syntax_deprecation = true
         end
     end
   end

data/lib/i18n/backend/cache.rb

@@ -45,6 +45,7 @@ module I18n
   end
 
   module Backend
+    # TODO Should the cache be cleared if new translations are stored?
     module Cache
       def translate(*args)
         I18n.perform_caching? ? fetch(*args) { super } : super

data/lib/i18n/backend/chain.rb

@@ -16,7 +16,9 @@ module I18n
     #
     # The implementation assumes that all backends added to the Chain implement
     # a lookup method with the same API as Simple backend does.
-    class Chain < Simple
+    class Chain
+      include Base
+
       attr_accessor :backends
 
       def initialize(*backends)

data/lib/i18n/backend/flatten.rb

@@ -12,6 +12,35 @@ module I18n
       SEPARATOR_ESCAPE_CHAR = "\001"
       FLATTEN_SEPARATOR = "."
 
+      # normalize_keys the flatten way. This method is significantly faster
+      # and creates way less objects than the one at I18n.normalize_keys.
+      # It also handles escaping the translation keys.
+      def self.normalize_flat_keys(locale, key, scope, separator)
+        keys = [scope, key].flatten.compact
+        separator ||= I18n.default_separator
+
+        if separator != FLATTEN_SEPARATOR
+          keys.map! do |k|
+            k.to_s.tr("#{FLATTEN_SEPARATOR}#{separator}",
+              "#{SEPARATOR_ESCAPE_CHAR}#{FLATTEN_SEPARATOR}")
+          end
+        end
+
+        keys.join(".")
+      end
+
+      # Receives a string and escape the default separator.
+      def self.escape_default_separator(key) #:nodoc:
+        key.to_s.tr(FLATTEN_SEPARATOR, SEPARATOR_ESCAPE_CHAR)
+      end
+
+      # Shortcut to I18n::Backend::Flatten.normalize_flat_keys
+      # and then resolve_links.
+      def normalize_flat_keys(locale, key, scope, separator)
+        key = I18n::Backend::Flatten.normalize_flat_keys(locale, key, scope, separator)
+        resolve_link(locale, key)
+      end
+
       # Store flattened links.
       def links
         @links ||= Hash.new { |h,k| h[k] = {} }
@@ -50,23 +79,6 @@ module I18n
         hash
       end
 
-      # normalize_keys the flatten way. This method is significantly faster
-      # and creates way less objects than the one at I18n.normalize_keys.
-      # It also handles escaping the translation keys.
-      def normalize_keys(locale, key, scope, separator)
-        keys = [scope, key].flatten.compact
-        separator ||= I18n.default_separator
-
-        if separator != FLATTEN_SEPARATOR
-          keys.map! do |k|
-            k.to_s.tr("#{FLATTEN_SEPARATOR}#{separator}",
-              "#{SEPARATOR_ESCAPE_CHAR}#{FLATTEN_SEPARATOR}")
-          end
-        end
-
-        resolve_link(locale, keys.join("."))
-      end
-
       protected
 
         def store_link(locale, key, link)
@@ -86,15 +98,16 @@ module I18n
           end
         end
 
-        def find_link(locale, key)
+        def find_link(locale, key) #:nodoc:
           links[locale].each do |from, to|
             return [from, to] if key[0, from.length] == from
           end && nil
         end
 
-        def escape_default_separator(key)
-          key.to_s.tr(FLATTEN_SEPARATOR, SEPARATOR_ESCAPE_CHAR)
+        def escape_default_separator(key) #:nodoc:
+          I18n::Backend::Flatten.escape_default_separator(key)
         end
+
     end
   end
 end

data/lib/i18n/backend/interpolation_compiler.rb

@@ -11,14 +11,18 @@
 # InterpolationCompiler module to the Simple backend:
 #
 #   I18n::Backend::Simple.send(:include, I18n::Backend::InterpolationCompiler)
+#
+# Note that InterpolationCompiler does not yield meaningful results and consequently
+# should not be used with Ruby 1.9 (YARV) but improves performance everywhere else
+# (jRuby, Rubinius and 1.8.7).
 module I18n
   module Backend
     module InterpolationCompiler
       module Compiler
         extend self
 
-        TOKENIZER                    = /(\\\{\{[^\}]+\}\}|\{\{[^\}]+\}\})/
-        INTERPOLATION_SYNTAX_PATTERN = /(\\)?(\{\{([^\}]+)\}\})/
+        TOKENIZER                    = /(%%\{[^\}]+\}|%\{[^\}]+\})/
+        INTERPOLATION_SYNTAX_PATTERN = /(%)?(%\{([^\}]+)\})/
 
         def compile_if_an_interpolation(string)
           if interpolated_str?(string)
@@ -37,7 +41,7 @@ module I18n
         end
 
         protected
-        # tokenize("foo {{bar}} baz \\{{buz}}") # => ["foo ", "{{bar}}", " baz ", "\\{{buz}}"]
+        # tokenize("foo %{bar} baz %%{buz}") # => ["foo ", "%{bar}", " baz ", "%%{buz}"]
         def tokenize(str)
           str.split(TOKENIZER)
         end
@@ -102,7 +106,7 @@ module I18n
         end
       end
 
-      def merge_translations(locale, data, options = {})
+      def store_translations(locale, data, options = {})
         compile_all_strings_in(data)
         super
       end

data/lib/i18n/backend/key_value.rb

@@ -28,6 +28,12 @@ module I18n
     #   require 'rufus/tokyo/cabinet' # gem install rufus-tokyo
     #   I18n.backend = I18n::Backend::KeyValue.new(Rufus::Tokyo::Cabinet.new('*'))
     #
+    # == Performance
+    #
+    # You may make this backend even faster by including the Memoize module.
+    # However, notice that you should properly clear the cache if you change
+    # values directly in the key-store.
+    #
     # == Subtrees
     #
     # In most backends, you are allowed to retrieve part of a translation tree:
@@ -42,54 +48,58 @@ module I18n
     #   I18n::Backend::KeyValue.new(@store, false)
     #
     class KeyValue
-      attr_accessor :store
+      module Implementation
+        attr_accessor :store
 
-      include Base, Flatten
-
-      def initialize(store, subtrees=true)
-        @store, @subtrees = store, subtrees
-      end
+        include Base, Flatten
 
-      # Mute reload! since we really don't want to clean the database.
-      def reload!
-      end
-
-      def available_locales
-        locales = @store.keys.map { |k| k =~ /\./; $` }
-        locales.uniq!
-        locales.compact!
-        locales.map! { |k| k.to_sym }
-        locales
-      end
-
-      protected
+        def initialize(store, subtrees=true)
+          @store, @subtrees = store, subtrees
+        end
 
-        def lookup(locale, key, scope = [], options = {})
-          key   = normalize_keys(locale, key, scope, options[:separator])
-          value = @store["#{locale}.#{key}"]
-          value = ActiveSupport::JSON.decode(value) if value
-          value.is_a?(Hash) ? deep_symbolize_keys(value) : value
+        # Mute reload! since we really don't want to clean the database.
+        def reload!
         end
 
-        def merge_translations(locale, data, options = {})
+        def store_translations(locale, data, options = {})
           flatten_translations(locale, data, @subtrees).each do |key, value|
             key = "#{locale}.#{key}"
 
             case value
             when Hash
               if @subtrees && (old_value = @store[key])
-                old_value = ActiveSupport::JSON.decode(old_value) 
-                value = deep_symbolize_keys(old_value).merge(value) if old_value.is_a?(Hash)
+                old_value = ActiveSupport::JSON.decode(old_value)
+                value = old_value.deep_symbolize_keys.deep_merge!(value) if old_value.is_a?(Hash)
               end
             when Proc
               raise "Key-value stores cannot handle procs"
-            when Symbol
-              value = nil
             end
 
-            @store[key] = ActiveSupport::JSON.encode(value) unless value.nil?
+            @store[key] = ActiveSupport::JSON.encode(value) unless value.is_a?(Symbol)
           end
         end
+
+        def available_locales
+          init_translations unless initialized?
+
+          locales = @store.keys.map { |k| k =~ /\./; $` }
+          locales.uniq!
+          locales.compact!
+          locales.map! { |k| k.to_sym }
+          locales
+        end
+
+      protected
+
+        def lookup(locale, key, scope = [], options = {})
+          key   = normalize_flat_keys(locale, key, scope, options[:separator])
+          value = @store["#{locale}.#{key}"]
+          value = ActiveSupport::JSON.decode(value) if value
+          value.is_a?(Hash) ? value.deep_symbolize_keys : value
+        end
+      end
+
+      include Implementation
     end
   end
 end

data/lib/i18n/backend/memoize.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+#
+# Memoize module simply memoizes the values returned by lookup using
+# a flat hash and can tremendously speed up the lookup process in a backend.
+#
+# To enable it you can simply include the Memoize module to your backend:
+#
+#   I18n::Backend::Simple.send(:include, I18n::Backend::Memoize)
+#
+# Notice that it's the responsibility of the backend to define whenever the
+# cache should be cleaned.
+module I18n
+  module Backend
+    module Memoize
+      def available_locales
+        @memoized_locales ||= super
+      end
+
+      def store_translations(locale, data, options = {})
+        reset_memoizations!(locale)
+        super
+      end
+
+      def reload!
+        reset_memoizations!
+        super
+      end
+
+      protected
+
+        def lookup(locale, key, scope = nil, options = {})
+          flat_key  = I18n::Backend::Flatten.normalize_flat_keys(locale,
+            key, scope, options[:separator]).to_sym
+          flat_hash = memoized_lookup[locale.to_sym]
+          flat_hash.key?(flat_key) ? flat_hash[flat_key] : (flat_hash[flat_key] = super)
+        end
+
+        def memoized_lookup
+          @memoized_lookup ||= Hash.new { |h, k| h[k] = {} }
+        end
+
+        def reset_memoizations!(locale=nil)
+          @memoized_locales = nil
+          (locale ? memoized_lookup[locale.to_sym] : memoized_lookup).clear
+        end
+    end
+  end
+end

data/lib/i18n/backend/metadata.rb

@@ -27,7 +27,7 @@ module I18n
             def translation_metadata=(translation_metadata)
               @translation_metadata = translation_metadata
             end
-          end
+          end unless Object.method_defined?(:translation_metadata)
         end
       end
 
@@ -43,10 +43,9 @@ module I18n
         with_metadata(metadata) { super }
       end
 
-      def interpolate(locale, string, values = {})
-        with_metadata(:original => string) do
-          preserve_translation_metadata(string) { super }
-        end if string
+      def interpolate(locale, entry, values = {})
+        metadata = entry.translation_metadata.merge(:original => entry)
+        with_metadata(metadata) { super }
       end
 
       def pluralize(locale, entry, count)
@@ -61,11 +60,6 @@ module I18n
           result
         end
 
-        def preserve_translation_metadata(object, &block)
-          result = yield
-          result.translation_metadata = object.translation_metadata if result
-          result
-        end
     end
   end
 end

data/lib/i18n/backend/transliterator.rb

@@ -2,9 +2,17 @@
 module I18n
   module Backend
     module Transliterator
-
       DEFAULT_REPLACEMENT_CHAR = "?"
 
+      # Given a locale and a UTF-8 string, return the locale's ASCII
+      # approximation for the string.
+      def transliterate(locale, string, replacement = nil)
+        @transliterators ||= {}
+        @transliterators[locale] ||= Transliterator.get I18n.t(:'i18n.transliterate.rule',
+          :locale => locale, :resolve => false, :default => {})
+        @transliterators[locale].transliterate(string, replacement)
+      end
+
       # Get a transliterator instance.
       def self.get(rule = nil)
         if !rule || rule.kind_of?(Hash)
@@ -18,7 +26,6 @@ module I18n
 
       # A transliterator which accepts a Proc as its transliteration rule.
       class ProcTransliterator
-
         def initialize(rule)
           @rule = rule
         end
@@ -26,13 +33,11 @@ module I18n
         def transliterate(string, replacement = nil)
           @rule.call(string)
         end
-
       end
 
       # A transliterator which accepts a Hash of characters as its translation
       # rule.
       class HashTransliterator
-
         DEFAULT_APPROXIMATIONS = {
           "À"=>"A", "Á"=>"A", "Â"=>"A", "Ã"=>"A", "Ä"=>"A", "Å"=>"A", "Æ"=>"AE",
           "Ç"=>"C", "È"=>"E", "É"=>"E", "Ê"=>"E", "Ë"=>"E", "Ì"=>"I", "Í"=>"I",
@@ -87,7 +92,6 @@ module I18n
             hash.keys.each {|key| hash[key.to_s] = hash.delete(key).to_s}
             approximations.merge! hash
           end
-
       end
     end
   end

data/lib/i18n/config.rb

@@ -0,0 +1,84 @@
+module I18n
+  class Config
+    # The only configuration value that is not global and scoped to thread is :locale.
+    # It defaults to the default_locale.
+    def locale
+      @locale ||= default_locale
+    end
+
+    # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
+    def locale=(locale)
+      @locale = locale.to_sym rescue nil
+    end
+
+    # Returns the current backend. Defaults to +Backend::Simple+.
+    def backend
+      @@backend ||= Backend::Simple.new
+    end
+
+    # Sets the current backend. Used to set a custom backend.
+    def backend=(backend)
+      @@backend = backend
+    end
+
+    # Returns the current default locale. Defaults to :'en'
+    def default_locale
+      @@default_locale ||= :en
+    end
+
+    # Sets the current default locale. Used to set a custom default locale.
+    def default_locale=(locale)
+      @@default_locale = locale.to_sym rescue nil
+    end
+
+    # Returns an array of locales for which translations are available.
+    # Unless you explicitely set the these through I18n.available_locales=
+    # the call will be delegated to the backend and memoized on the I18n module.
+    def available_locales
+      @@available_locales ||= backend.available_locales
+    end
+
+    # Sets the available locales.
+    def available_locales=(locales)
+      @@available_locales = locales
+    end
+
+    # Returns the current default scope separator. Defaults to '.'
+    def default_separator
+      @@default_separator ||= '.'
+    end
+
+    # Sets the current default scope separator.
+    def default_separator=(separator)
+      @@default_separator = separator
+    end
+
+    # Return the current exception handler. Defaults to :default_exception_handler.
+    def exception_handler
+      @@exception_handler ||= :default_exception_handler
+    end
+
+    # Sets the exception handler.
+    def exception_handler=(exception_handler)
+      @@exception_handler = exception_handler
+    end
+
+    # Allow clients to register paths providing translation data sources. The
+    # backend defines acceptable sources.
+    #
+    # E.g. the provided SimpleBackend accepts a list of paths to translation
+    # files which are either named *.rb and contain plain Ruby Hashes or are
+    # named *.yml and contain YAML data. So for the SimpleBackend clients may
+    # register translation files like this:
+    #   I18n.load_path << 'path/to/locale/en.yml'
+    def load_path
+      @@load_path ||= []
+    end
+
+    # Sets the load path instance. Custom implementations are expected to
+    # behave like a Ruby Array.
+    def load_path=(load_path)
+      @@load_path = load_path
+    end
+  end
+end

data/lib/i18n/core_ext/hash.rb

@@ -0,0 +1,29 @@
+class Hash
+  def slice(*keep_keys)
+    h = {}
+    keep_keys.each { |key| h[key] = fetch(key) }
+    h
+  end unless Hash.method_defined?(:slice)
+
+  def except(*less_keys)
+    slice(*keys - less_keys)
+  end unless Hash.method_defined?(:except)
+
+  def deep_symbolize_keys
+    inject({}) { |result, (key, value)|
+      value = value.deep_symbolize_keys if value.is_a?(Hash)
+      result[(key.to_sym rescue key) || key] = value
+      result
+    }
+  end unless Hash.method_defined?(:deep_symbolize_keys)
+
+  # deep_merge_hash! by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+  MERGER = proc do |key, v1, v2|
+    Hash === v1 && Hash === v2 ? v1.merge(v2, &MERGER) : v2
+  end
+  
+  def deep_merge!(data)
+    merge!(data, &MERGER)
+  end unless Hash.method_defined?(:deep_merge!)
+end
+

data/lib/i18n/core_ext/string/interpolate.rb

@@ -7,13 +7,13 @@
   You may redistribute it and/or modify it under the same license terms as Ruby.
 =end
 
-if RUBY_VERSION < '1.9'
-
+begin
+  raise ArgumentError if ("a %{x}" % {:x=>'b'}) != 'a b'
+rescue ArgumentError
   # KeyError is raised by String#% when the string contains a named placeholder
   # that is not contained in the given arguments hash. Ruby 1.9 includes and
   # raises this exception natively. We define it to mimic Ruby 1.9's behaviour
   # in Ruby 1.8.x
-
   class KeyError < IndexError
     def initialize(message = nil)
       super(message || "key not found")
@@ -24,7 +24,6 @@ if RUBY_VERSION < '1.9'
   #
   # String#% method which accept "named argument". The translator can know
   # the meaning of the msgids using "named argument" instead of %s/%d style.
-
   class String
     # For older ruby versions, such as ruby-1.8.5
     alias :bytesize :size unless instance_methods.find {|m| m.to_s == 'bytesize'}

data/lib/i18n/version.rb

@@ -1,3 +1,3 @@
 module I18n
-  VERSION = "0.4.0.beta"
+  VERSION = "0.4.0.beta1"
 end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 4
   - 0
-  - beta
-  version: 0.4.0.beta
+  - beta1
+  version: 0.4.0.beta1
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-30 00:00:00 +02:00
+date: 2010-05-03 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -44,18 +44,17 @@ files:
 - lib/i18n/backend/chain.rb
 - lib/i18n/backend/cldr.rb
 - lib/i18n/backend/fallbacks.rb
-- lib/i18n/backend/fast.rb
 - lib/i18n/backend/flatten.rb
 - lib/i18n/backend/gettext.rb
-- lib/i18n/backend/helpers.rb
 - lib/i18n/backend/interpolation_compiler.rb
 - lib/i18n/backend/key_value.rb
+- lib/i18n/backend/memoize.rb
 - lib/i18n/backend/metadata.rb
 - lib/i18n/backend/pluralization.rb
 - lib/i18n/backend/simple.rb
 - lib/i18n/backend/transliterator.rb
-- lib/i18n/core_ext/hash/except.rb
-- lib/i18n/core_ext/hash/slice.rb
+- lib/i18n/config.rb
+- lib/i18n/core_ext/hash.rb
 - lib/i18n/core_ext/string/interpolate.rb
 - lib/i18n/exceptions.rb
 - lib/i18n/gettext.rb

data/lib/i18n/backend/fast.rb

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-# The Fast module contains optimizations that can tremendously speed up the
-# lookup process on the Simple backend. It works by flattening the nested
-# translation hash to a flat hash (e.g. { :a => { :b => 'c' } } becomes
-# { :'a.b' => 'c' }).
-#
-# To enable these optimizations you can simply include the Fast module to
-# the Simple backend:
-#
-#   I18n::Backend::Simple.send(:include, I18n::Backend::Fast)
-module I18n
-  module Backend
-    module Fast
-      include Flatten
-
-      # Overwrite reload! to also clean up flattened translations.
-      def reload!
-        super
-        reset_flattened_translations!
-      end
-
-      protected
-
-        # Generate flattened translations after translations are initialized.
-        def init_translations
-          super
-          flattened_translations
-        end
-
-        def lookup(locale, key, scope = nil, options = {})
-          locale = locale.to_sym
-          return nil unless flattened_translations[locale]
-
-          key = normalize_keys(locale, key, scope, options[:separator]).to_sym
-          flattened_translations[locale][key]
-        end
-
-        # Store flattened translations in a variable.
-        def flattened_translations
-          @flattened_translations ||=
-            translations.inject({}) do |result, (locale, data)|
-              result[locale] = flatten_translations(locale, data, true)
-              result
-            end
-        end
-
-        # Clean up flattened translations variable. Should be called whenever
-        # the internal hash is changed.
-        def reset_flattened_translations!
-          @flattened_translations = nil
-        end
-
-        # Overwrite merge_translations to clean up the internal hash so added
-        # translations are also cached.
-        def merge_translations(locale, data, options = {})
-          super
-          reset_flattened_translations!
-        end
-    end
-  end
-end

data/lib/i18n/backend/helpers.rb

@@ -1,25 +0,0 @@
-module I18n
-  module Backend
-    module Helpers
-      # Return a new hash with all keys and nested keys converted to symbols.
-      def deep_symbolize_keys(hash)
-        hash.inject({}) { |result, (key, value)|
-          value = deep_symbolize_keys(value) if value.is_a?(Hash)
-          result[(key.to_sym rescue key) || key] = value
-          result
-        }
-      end
-
-      # deep_merge_hash! by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
-      MERGER = proc do |key, v1, v2|
-        # TODO should probably be:
-        # raise TypeError.new("can't merge #{v1.inspect} and #{v2.inspect}") unless Hash === v1 && Hash === v2
-        Hash === v1 && Hash === v2 ? v1.merge(v2, &MERGER) : (v2 || v1)
-      end
-
-      def deep_merge_hash!(hash, data)
-        hash.merge!(data, &MERGER)
-      end
-    end
-  end
-end

data/lib/i18n/core_ext/hash/except.rb

@@ -1,8 +0,0 @@
-# from facets (http://facets.rubyforge.org)
-require 'i18n/core_ext/hash/slice'
-
-class Hash
-  def except(*less_keys)
-    slice(*keys - less_keys)
-  end
-end unless Hash.method_defined?(:except)

data/lib/i18n/core_ext/hash/slice.rb

@@ -1,8 +0,0 @@
-# from facets (http://facets.rubyforge.org)
-class Hash
-  def slice(*keep_keys)
-    h = {}
-    keep_keys.each { |key| h[key] = fetch(key) }
-    h
-  end
-end unless Hash.new.respond_to?(:slice)