i18n 0.3.7 → 0.4.0.beta

data/CHANGELOG.textile

@@ -0,0 +1,125 @@
+h1. Changelog
+
+h2. master
+
+*
+
+h2. 0.4.0.beta (2010-04-30)
+
+* "Added a KeyValue backend":http://github.com/svenfuchs/i18n/commit/28ca5f53ade7f545f8c0804e93564d4686b416a4
+
+* "Added transliteration support":http://github.com/svenfuchs/i18n/commit/928fdb4794959e779e90f360eb01ba043672d8d5
+
+* "Create Flatten backend module to aid handling flatten translations":http://github.com/svenfuchs/i18n/commit/2ec9d6998aa8facd7b15a3ef47a96cf2471cd8a1
+
+* "Decouple the external separator (used when storing translations) from the internal separator in Fast and ActiveRecord backends":http://github.com/svenfuchs/i18n/commit/274cb4daa0ca5e3b2bd23b45eb7f9fc58f75a79d
+
+h2. 0.3.7 (2010-04-17)
+
+* "Speed up I18n.normalize_keys by caching reused normalizations and producing less garbage":http://github.com/svenfuchs/i18n/commit/819dac0fea9c29e6545801aa107e63e355728cd4
+
+h2. 0.3.6 (2010-03-23)
+
+* "Move gettext po parser to lib":http://github.com/svenfuchs/i18n/commit/b2f038663b55727ac2327e6f07a46ba5d69d600c
+
+* "Move I18n configuration to I18n.config":http://github.com/svenfuchs/i18n/commit/4a7baea86663ead8c681008c3e80a622f0546b07
+
+h2. 0.3.5 (2010-02-26)
+
+* "Delegate I18n.normalize_translation_keys to I18n.normalize_keys and deprecate 
+the former":http://github.com/svenfuchs/i18n/commit/7284b04d5f5dd9679cb68875515cdd0cdfc96fef
+
+h2. 0.3.4 (2010-02-25)
+
+* "Rename I18n.normalize_translation_keys to I18n.normalize_keys and finally make it public":http://github.com/svenfuchs/i18n/commit/20b05fe5802df6c90fb70a4e3760b2b851b791b3
+
+* "Added CLDR supoprt":http://github.com/svenfuchs/i18n/commit/860eadf671a231e7f5dffb1bb27fa318ff7a8786
+
+h2. 0.3.3 (2009-12-29)
+
+* "Use lib/i18n/version":http://github.com/svenfuchs/i18n/commit/ff426c8e7a2438b814cb303adadec292dacb752e
+
+* "Added a benchmark suite":http://github.com/svenfuchs/i18n/commit/f9b5b9b113097724638bdab96862ffa404e67e70
+
+* "Ensure links can be handled recursively":http://github.com/svenfuchs/i18n/commit/2c50bd209f3fc24fe9dfa694c81be64340f09b7d
+
+* "Make sure we can lookup false values as translation data":http://github.com/svenfuchs/i18n/commit/561c82ba4b8921d03bfdf56cb2d0c2f287629001
+
+* "Added Fast backend module":http://github.com/svenfuchs/i18n/commit/bd2f09f0a251ca793b0e8ecc7e32177a2f091c23
+
+* "Added InterpolationCompiler backend module":http://github.com/svenfuchs/i18n/commit/91810887d1abfb28996a9183bc9004678290d28b
+
+h2. 0.3.2 (2009-12-12)
+
+* "Added Cascade backend":http://github.com/svenfuchs/i18n/commit/8009aef293e9ef8564c9005090d8380feabcaf6f
+
+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
+* "Allow configuring the default scope separator, allow to pass a custom scope separator(API addition)":http://github.com/svenfuchs/i18n/commit/5b75bfbc348061adc11e3790187a187275bfd471 (e.g. I18n.t(:'foo|bar', :separator => '|') 
+* "Pass :format option to #translate for #localize more useful lambda support":http://github.com/svenfuchs/i18n/commit/e277711b3c844fe7589b8d3f9af0f7d1b969a273
+* "Refactor Simple backend #resolve to #default and #resolve for more consistency. Now allows to pass lambdas as defaults and re-resolve Symbols":http://github.com/svenfuchs/i18n/commit/8c4ce3d923ce5fa73e973fe28217e18165549aba
+* "Add lambda support to #translate (API addition)":http://github.com/svenfuchs/i18n/commit/c90e62d8f7d3d5b78f34cfe328d871b58884f115
+* "Add lambda support to #localize (API addition)":http://github.com/svenfuchs/i18n/commit/9d390afcf33f3f469bb95e6888147152f6cc7442
+
+h2. 0.1.3 (2009-02-27)
+
+* "Remove unnecessary string encoding handling in the i18n simple backend which made the backend break on Ruby 1.9":http://github.com/svenfuchs/i18n/commit/4c3a970783861a94f2e89f46714fb3434e4f4f8d
+
+h2. 0.1.2 (2009-01-09)
+
+* "added #available_locales (returns an array of locales for which translations are available)":http://github.com/svenfuchs/i18n/commit/411f8fe7c8f3f89e9b6b921fa62ed66cb92f3af4
+* "flatten load_path before using it so that a nested array of paths won't throw up":http://github.com/svenfuchs/i18n/commit/d473a068a2b90aba98135deb225d6eb6d8104d70
+
+h2. 0.1.1 (2008-11-20)
+
+* "Use :'en' as a default locale (in favor of :'en-US')":http://github.com/svenfuchs/i18n/commit/c4b10b246aecf7da78cb2568dd0d2ab7e6b8a230
+* "Add #reload! to Simple backend":http://github.com/svenfuchs/i18n/commit/36dd2bd9973b9e1559728749a9daafa44693e964
+
+h2. 0.1.0 (2008-10-25)
+
+* "Fix Simple backend to distinguish false from nil values":http://github.com/svenfuchs/i18n/commit/39d9a47da14b5f3ba126af48923af8c30e135166
+* "Add #load_path to public api, add initialize to simple backend and remove #load_translations from public api":http://github.com/svenfuchs/i18n/commit/c4c5649e6bc8f020f1aaf5a5470bde048e22c82d
+* "Speed up Backend::Simple#interpolate":http://github.com/svenfuchs/i18n/commit/9e1ac6bf8833304e036323ec9932b9f33c468a35
+* "Remove #populate and #store_translations from public API":http://github.com/svenfuchs/i18n/commit/f4e514a80be7feb509f66824ee311905e2940900
+* "Use :other instead of :many as a plural key":http://github.com/svenfuchs/i18n/commit/0f8f20a2552bf6a2aa758d8fdd62a7154e4a1bf6
+* "Use a class instead of a module for Simple backend":http://github.com/svenfuchs/i18n/commit/08f051aa61320c17debde24a83268bc74e33b995
+* "Make Simple backend #interpolate deal with non-ASCII string encodings":http://github.com/svenfuchs/i18n/commit/d84a3f3f55543c084d5dc5d1fed613b8df148789
+* "Fix default arrays of non-existant keys returning the default array":http://github.com/svenfuchs/i18n/commit/6c04ca86c87f97dc78f07c2a4023644e5ba8b839
+
+h2. Initial implementation (June/July 2008)
+
+Initial implementation by "Sven Fuchs":http://www.workingwithrails.com/person/9963-sven-fuchs based on previous discussion/consensus of the rails-i18n team (alphabetical order) and many others:
+
+* "Matt Aimonetti":http://railsontherun.com
+* "Sven Fuchs":http://www.workingwithrails.com/person/9963-sven-fuchs
+* "Joshua Harvey":http://www.workingwithrails.com/person/759-joshua-harvey
+* "Saimon Moore":http://saimonmoore.net
+* "Stephan Soller":http://www.arkanis-development.de
+
+h2. More information
+
+* "Homepage":http://rails-i18n.org
+* "Wiki":http://rails-i18n.org/wiki
+* "Mailinglist":http://groups.google.com/group/rails-i18n
+* "About the project/history":http://www.artweb-design.de/2008/7/18/finally-ruby-on-rails-gets-internationalized
+* "Initial API Intro":http://www.artweb-design.de/2008/7/18/the-ruby-on-rails-i18n-core-api

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 The Ruby I18n team
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,93 @@
+h1. Ruby I18n
+
+Ruby Internationalization and localization solution.
+
+Features:
+
+* translation and localization
+* interpolation of values to translations (Ruby 1.9 compatible syntax)
+* pluralization (CLDR compatible)
+* customizable transliteration to ASCII
+* flexible defaults
+* bulk lookup
+* lambdas as translation data
+* custom key/scope separator
+* custom exception handlers
+* extensible architecture with a swappable backend
+
+Pluggable features:
+
+* 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: ActiveRecord::Missing and ActiveRecord::StoreProcs)
+* KeyValue (uses active_support/json and cannot store procs)
+
+For more information and lots of resources see: "http://rails-i18n.org/wiki":http://rails-i18n.org/wiki
+
+h2. Installation
+
+gem install i18n
+
+h3. Installation on Rails < 2.3.5 (deprecated)
+
+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 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
+
+Then you can `reload_i18n!` inside an i18n initializer.
+
+h2. Tests
+
+You can run tests both with
+
+* `rake test` or just `rake`
+* run any test file directly, e.g. `ruby test/api/simple_test.rb`
+* run all tests with `ruby test/all.rb`
+
+The structure of the test suite is a bit unusual as it uses modules to reuse
+particular tests in different test cases.
+
+The reason for this is that we need to enforce the I18n API across various
+combinations of extensions. E.g. the Simple backend alone needs to support
+the same API as any combination of feature and/or optimization modules included
+to the Simple backend. We test this by reusing the same API defition (implemented
+as test methods) in test cases with different setups.
+
+You can find the test cases that enforce the API in test/api. And you can find
+the API definition test methods in test/api/tests.
+
+All other test cases (e.g. as defined in test/backend, test/core\_ext) etc.
+follow the usual test setup and should be easy to grok.
+
+h2. Authors
+
+* "Sven Fuchs":http://www.artweb-design.de
+* "Joshua Harvey":http://www.workingwithrails.com/person/759-joshua-harvey
+* "Stephan Soller":http://www.arkanis-development.de
+* "Saimon Moore":http://saimonmoore.net
+* "Matt Aimonetti":http://railsontherun.com
+
+h2. Contributors
+
+http://github.com/svenfuchs/i18n/contributors
+
+h2. License
+
+MIT License. See the included MIT-LICENSE file.

data/lib/i18n.rb

@@ -244,6 +244,69 @@ module I18n
     end
     alias :t! :translate!
 
+    # Transliterates UTF-8 characters to ASCII. By default this method will
+    # transliterate only Latin strings to an ASCII approximation:
+    #
+    #    I18N.transliterate("Ærøskøbing")
+    #    # => "AEroskobing"
+    #
+    #    I18N.transliterate("日本語")
+    #    # => "???"
+    #
+    # It's also possible to add support for per-locale transliterations. I18N
+    # expects transliteration rules to be stored at
+    # <tt>i18n.transliterate.rule</tt>.
+    #
+    # Transliteration rules can either be a Hash or a Proc. Procs must accept a
+    # single string argument. Hash rules inherit the default transliteration
+    # rules, while Procs do not.
+    #
+    # *Examples*
+    #
+    # Setting a Hash in <locale>.yml:
+    #
+    #    i18n:
+    #      transliterate:
+    #        rule:
+    #          ü: "ue"
+    #          ö: "oe"
+    #
+    # Setting a Hash using Ruby:
+    #
+    #     store_translations(:de, :i18n => {
+    #       :transliterate => {
+    #         :rule => {
+    #           "ü" => "ue",
+    #           "ö" => "oe"
+    #         }
+    #       }
+    #     )
+    #
+    # Setting a Proc:
+    #
+    #     translit = lambda {|string| MyTransliterator.transliterate(string) }
+    #     store_translations(:xx, :i18n => {:transliterate => {:rule => translit})
+    #
+    # Transliterating strings:
+    #
+    #     I18N.locale = :en
+    #     I18N.transliterate("Jürgen") # => "Jurgen"
+    #     I18N.locale = :de
+    #     I18N.transliterate("Jürgen") # => "Juergen"
+    #     I18N.transliterate("Jürgen", :locale => :en) # => "Jurgen"
+    #     I18N.transliterate("Jürgen", :locale => :de) # => "Juergen"
+    def transliterate(*args)
+      options      = args.pop if args.last.is_a?(Hash)
+      key          = args.shift
+      locale       = options && options.delete(:locale) || config.locale
+      raises       = options && options.delete(:raise)
+      replacement  = options && options.delete(:replacement)
+      config.backend.transliterate(locale, key, replacement)
+    rescue I18n::ArgumentError => exception
+      raise exception if raises
+      handle_exception(exception, locale, key, options)
+    end
+
     # Localizes certain objects, such as dates and numbers to local formatting.
     def localize(object, options = {})
       locale = options.delete(:locale) || config.locale
@@ -257,9 +320,12 @@ module I18n
     # keys are Symbols.
     def normalize_keys(locale, key, scope, separator = nil)
       separator ||= I18n.default_separator
-      normalize_key(locale, separator) +
-        normalize_key(scope, separator) +
-        normalize_key(key, separator)
+
+      keys = []
+      keys.concat normalize_key(locale, separator)
+      keys.concat normalize_key(scope, separator)
+      keys.concat normalize_key(key, separator)
+      keys
     end
 
   # making these private until Ruby 1.9.2 can send to protected methods again
@@ -308,28 +374,20 @@ module I18n
     end
 
     def normalize_key(key, separator)
-      normalized_key_cache(separator)[key] ||=
+      normalized_key_cache[separator][key] ||=
         case key
         when Array
           key.map { |k| normalize_key(k, separator) }.flatten
-        when nil
-          []
         else
-          key = key.to_s
-          if key == ''
-            []
-          elsif key.include?(separator)
-            keys = key.split(separator) - ['']
-            keys.map { |k| k.to_sym }
-          else
-            [key.to_sym]
-          end
+          keys = key.to_s.split(separator)
+          keys.delete('')
+          keys.map!{ |k| k.to_sym }
+          keys
         end
     end
 
-    def normalized_key_cache(separator)
+    def normalized_key_cache
       @normalized_key_cache ||= Hash.new { |h,k| h[k] = {} }
-      @normalized_key_cache[separator]
     end
   end
 end

data/lib/i18n/backend.rb

@@ -8,12 +8,14 @@ module I18n
     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 :Links,                 'i18n/backend/links'
     autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
+    autoload :KeyValue,              'i18n/backend/key_value'
     autoload :Metadata,              'i18n/backend/metadata'
     autoload :Pluralization,         'i18n/backend/pluralization'
     autoload :Simple,                'i18n/backend/simple'
+    autoload :Transliterator,        'i18n/backend/transliterator'
   end
 end

data/lib/i18n/backend/active_record.rb

@@ -8,20 +8,11 @@ module I18n
       autoload :StoreProcs,  'i18n/backend/active_record/store_procs'
       autoload :Translation, 'i18n/backend/active_record/translation'
 
-      include Base, Links
+      include Base, Flatten
 
       def reload!
       end
 
-      def store_translations(locale, data, options = {})
-        separator = options[:separator] || I18n.default_separator
-        wind_keys(data, separator).each do |key, value|
-          store_link(locale, key, value) if value.is_a?(Symbol)
-          Translation.locale(locale).lookup(expand_keys(key, separator), separator).delete_all
-          Translation.create(:locale => locale.to_s, :key => key.to_s, :value => value)
-        end
-      end
-
       def available_locales
         begin
           Translation.available_locales
@@ -33,32 +24,34 @@ module I18n
       protected
 
         def lookup(locale, key, scope = [], options = {})
-          return unless key
-
-          separator = options[:separator] || I18n.default_separator
-
-          key = resolve_link(locale, key)
-          key = (Array(scope) + Array(key)).join(separator)
-          result = Translation.locale(locale).lookup(key, separator).all
+          key = normalize_keys(locale, key, scope, options[:separator])
+          result = Translation.locale(locale).lookup(key).all
 
           if result.empty?
-            return nil
+            nil
           elsif result.first.key == key
-            return result.first.value
+            result.first.value
           else
-            chop_range = (key.size + separator.size)..-1
+            chop_range = (key.size + FLATTEN_SEPARATOR.size)..-1
             result = result.inject({}) do |hash, r|
               hash[r.key.slice(chop_range)] = r.value
               hash
             end
-            deep_symbolize_keys(unwind_keys(result, separator))
+            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)
           end
         end
 
         # For a key :'foo.bar.baz' return ['foo', 'foo.bar', 'foo.bar.baz']
-        def expand_keys(key, separator = I18n.default_separator)
-          key.to_s.split(separator).inject([]) do |keys, key|
-            keys << [keys.last, key].compact.join(separator)
+        def expand_keys(key)
+          key.to_s.split(FLATTEN_SEPARATOR).inject([]) do |keys, key|
+            keys << [keys.last, key].compact.join(FLATTEN_SEPARATOR)
           end
         end
     end

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

@@ -40,7 +40,7 @@ module I18n
           keys = I18n.normalize_keys(locale, key, scope, separator)[1..-1]
           key = keys.join(separator || I18n.default_separator)
 
-          unless ActiveRecord::Translation.locale(locale).lookup(key, separator).exists?
+          unless ActiveRecord::Translation.locale(locale).lookup(key).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) }
@@ -55,11 +55,9 @@ module I18n
 
         def translate(locale, key, options = {})
           super
-
-          rescue I18n::MissingTranslationData => e
-            self.store_default_translations(locale, key, options)
-
-            raise e
+        rescue I18n::MissingTranslationData => e
+          self.store_default_translations(locale, key, options)
+          raise e
         end
       end
     end

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

@@ -60,9 +60,14 @@ module I18n
 
         send scope_method, :lookup, lambda { |keys, *separator|
           column_name = connection.quote_column_name('key')
-          keys        = Array(keys).map! { |key| key.to_s }
-          separator   = separator.first || I18n.default_separator
-          namespace   = "#{keys.last}#{separator}%"
+          keys = Array(keys).map! { |key| key.to_s }
+
+          unless separator.empty?
+            warn "[DEPRECATION] Giving a separator to Translation.lookup is deprecated. " <<
+              "You can change the internal separator by overwriting FLATTEN_SEPARATOR."
+          end
+
+          namespace = "#{keys.last}#{I18n::Backend::Flatten::FLATTEN_SEPARATOR}%"
           { :conditions => ["#{column_name} IN (?) OR #{column_name} LIKE ?", keys, namespace] }
         }
 

data/lib/i18n/backend/base.rb

@@ -30,24 +30,34 @@ module I18n
         raise InvalidLocale.new(locale) unless locale
         return key.map { |k| translate(locale, k, options) } if key.is_a?(Array)
 
+        entry = lookup!(locale, key, options)
+
         if options.empty?
-          entry = resolve(locale, key, lookup(locale, key), options)
+          entry = resolve(locale, key, entry, options)
           raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
         else
-          count, scope, default = options.values_at(:count, :scope, :default)
+          count, default = options.values_at(:count, :default)
           values = options.reject { |name, value| RESERVED_KEYS.include?(name) }
 
-          entry = lookup(locale, key, scope, options)
           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) if values
+          entry = pluralize(locale, entry, count) if count
+          entry = interpolate(locale, entry, values)
         end
 
         entry
       end
 
+      # 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
+
       # Acts the same as +strftime+, but uses a localized version of the
       # format string. Takes a key from the date/time formats translations as
       # a format argument (<em>e.g.</em>, <tt>:short</tt> in <tt>:'date.formats'</tt>).
@@ -103,20 +113,27 @@ module I18n
           @translations ||= {}
         end
 
+        # Check if the key is valid and then initialize the translation and
+        # trigger the default lookup behavior.
+        def lookup!(locale, key, options)
+          return unless key
+          init_translations unless initialized?
+          lookup(locale, key, options[:scope], options)
+        end
+
         # Looks up a translation from the translations hash. Returns nil if
         # eiher key is nil, or locale, scope or key do not exist as a key in the
         # nested translations hash. Splits keys or scopes containing dots
         # into multiple keys, i.e. <tt>currency.format</tt> is regarded the same as
         # <tt>%w(currency format)</tt>.
         def lookup(locale, key, scope = [], options = {})
-          return unless key
-          init_translations unless initialized?
           keys = I18n.normalize_keys(locale, key, scope, options[:separator])
+
           keys.inject(translations) do |result, key|
             key = key.to_sym
             return nil unless result.is_a?(Hash) && result.has_key?(key)
             result = result[key]
-            result = resolve(locale, key, result, options) if result.is_a?(Symbol)
+            result = resolve(locale, key, result, options.merge(:scope => nil)) if result.is_a?(Symbol)
             String === result ? result.dup : result
           end
         end
@@ -249,17 +266,9 @@ module I18n
         def merge_translations(locale, data, options = {})
           locale = locale.to_sym
           translations[locale] ||= {}
-          separator = options[:separator] || I18n.default_separator
-          data = unwind_keys(data, separator)
-          data = deep_symbolize_keys(data)
 
-          # deep_merge 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
-          translations[locale].merge!(data, &merger)
+          data = deep_symbolize_keys(data)
+          deep_merge_hash!(translations[locale], data)
         end
     end
   end

data/lib/i18n/backend/cascade.rb

@@ -36,7 +36,6 @@ module I18n
   module Backend
     module Cascade
       def lookup(locale, key, scope = [], options = {})
-        return unless key
         return super unless cascade = options[:cascade]
 
         separator = options[:separator] || I18n.default_separator

data/lib/i18n/backend/fast.rb

@@ -12,57 +12,50 @@
 module I18n
   module Backend
     module Fast
-      include Links
+      include Flatten
 
-      def reset_flattened_translations!
-        @flattened_translations = nil
-      end
-
-      def flattened_translations
-        @flattened_translations ||= flatten_translations(translations)
-      end
-
-      def merge_translations(locale, data, options = {})
-        super
-        reset_flattened_translations!
-      end
-
-      def init_translations
+      # Overwrite reload! to also clean up flattened translations.
+      def reload!
         super
         reset_flattened_translations!
       end
 
       protected
-        def flatten_translations(translations)
-          # don't flatten locale roots
-          translations.inject({}) do |result, (locale, translations)|
-            result[locale] = wind_keys(translations, nil, true)
-            result[locale].each do |key, value|
-              store_link(locale, key, value) if value.is_a?(Symbol)
-            end
-            result
-          end
+
+        # Generate flattened translations after translations are initialized.
+        def init_translations
+          super
+          flattened_translations
         end
 
         def lookup(locale, key, scope = nil, options = {})
-          return unless key
-          init_translations unless initialized?
+          locale = locale.to_sym
+          return nil unless flattened_translations[locale]
 
-          return nil unless flattened_translations.has_key?(locale.to_sym)
+          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
 
-          separator = options[:separator]
-          if separator && I18n.default_separator != separator
-            key   = cleanup_non_standard_separator(key, separator)
-            scope = Array(scope).map{|k| cleanup_non_standard_separator(k, separator)} if scope
-          end
-          
-          key = resolve_link(locale, key)
-          key = (Array(scope) + [key]).join(I18n.default_separator) if scope
-          flattened_translations[locale.to_sym][key.to_sym]
+        # Clean up flattened translations variable. Should be called whenever
+        # the internal hash is changed.
+        def reset_flattened_translations!
+          @flattened_translations = nil
         end
 
-        def cleanup_non_standard_separator(key, user_separator)
-          escape_default_separator(key).tr(user_separator, I18n.default_separator)
+        # 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

data/lib/i18n/backend/flatten.rb

@@ -0,0 +1,100 @@
+module I18n
+  module Backend
+    # This module contains several helpers to assist flattening translations.
+    # You may want to flatten translations for:
+    #
+    #   1) speed up lookups, as in the Fast backend;
+    #   2) In case you want to store translations in a data store, as in ActiveRecord backend;
+    #
+    # You can check both backends above for some examples.
+    # This module also keeps all links in a hash so they can be properly resolved when flattened.
+    module Flatten
+      SEPARATOR_ESCAPE_CHAR = "\001"
+      FLATTEN_SEPARATOR = "."
+
+      # Store flattened links.
+      def links
+        @links ||= Hash.new { |h,k| h[k] = {} }
+      end
+
+      # Flatten keys for nested Hashes by chaining up keys:
+      #
+      #   >> { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}.wind
+      #   => { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }
+      #
+      def flatten_keys(hash, prev_key = nil, &block)
+        hash.each_pair do |key, value|
+          key = escape_default_separator(key)
+          curr_key = [prev_key, key].compact.join(FLATTEN_SEPARATOR).to_sym
+          yield curr_key, value
+          flatten_keys(value, curr_key, &block) if value.is_a?(Hash)
+        end
+      end
+
+      # Receives a hash of translations (where the key is a locale and
+      # the value is another hash) and return a hash with all
+      # translations flattened.
+      #
+      # Nested hashes are included in the flattened hash just if subtree
+      # is true and Symbols are automatically stored as links.
+      def flatten_translations(locale, data, subtree=false)
+        hash = {}
+        flatten_keys(data) do |key, value|
+          if value.is_a?(Hash)
+            hash[key] = value if subtree
+          else
+            store_link(locale, key, value) if value.is_a?(Symbol)
+            hash[key] = value
+          end
+        end
+        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)
+          links[locale.to_sym][key.to_s] = link.to_s
+        end
+
+        def resolve_link(locale, key)
+          key, locale = key.to_s, locale.to_sym
+          links = self.links[locale]
+
+          if links.key?(key)
+            links[key]
+          elsif link = find_link(locale, key)
+            store_link(locale, key, key.gsub(*link))
+          else
+            key
+          end
+        end
+
+        def find_link(locale, key)
+          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)
+        end
+    end
+  end
+end

data/lib/i18n/backend/helpers.rb

@@ -1,8 +1,6 @@
 module I18n
   module Backend
     module Helpers
-      SEPARATOR_ESCAPE_CHAR = "\001"
-
       # Return a new hash with all keys and nested keys converted to symbols.
       def deep_symbolize_keys(hash)
         hash.inject({}) { |result, (key, value)|
@@ -12,57 +10,16 @@ module I18n
         }
       end
 
-      # Flatten keys for nested Hashes by chaining up keys using the separator
-      #   >> { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}.wind
-      #   => { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }
-      def wind_keys(hash, separator = nil, subtree = false, prev_key = nil, result = {}, orig_hash=hash)
-        separator ||= I18n.default_separator
-
-        hash.each_pair do |key, value|
-          key = escape_default_separator(key, separator)
-          curr_key = [prev_key, key].compact.join(separator).to_sym
-
-          if value.is_a?(Hash)
-            result[curr_key] = value if subtree
-            wind_keys(value, separator, subtree, curr_key, result, orig_hash)
-          else
-            result[unescape_default_separator(curr_key)] = value
-          end
-        end
-
-        result
-      end
-
-      def escape_default_separator(key, separator=nil)
-        key.to_s.tr(separator || I18n.default_separator, SEPARATOR_ESCAPE_CHAR)
-      end
-      
-      def unescape_default_separator(key, separator=nil)
-        key.to_s.tr(SEPARATOR_ESCAPE_CHAR, separator || I18n.default_separator).to_sym
+      # 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
 
-      # Expand keys chained by the the given separator through nested Hashes
-      #   >> { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }.unwind
-      #   => { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}
-      def unwind_keys(hash, separator = ".")
-        result = {}
-        hash.each do |key, value|
-          keys = key.to_s.split(separator)
-          curr = result
-          curr = curr[keys.shift] ||= {} while keys.size > 1
-          curr[keys.shift] = value
-        end
-        result
+      def deep_merge_hash!(hash, data)
+        hash.merge!(data, &MERGER)
       end
-
-      # # Flatten the given array once
-      # def flatten_once(array)
-      #   result = []
-      #   for element in array # a little faster than each
-      #     result.push(*element)
-      #   end
-      #   result
-      # end
     end
   end
 end

data/lib/i18n/backend/key_value.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+require 'i18n/backend/base'
+require 'active_support/json'
+
+module I18n
+  module Backend
+    # This is a basic backend for key value stores. It receives on
+    # initialization the store, which should respond to three methods:
+    #
+    # * store#[](key)         - Used to get a value
+    # * store#[]=(key, value) - Used to set a value
+    # * store#keys            - Used to get all keys
+    #
+    # Since these stores only supports string, all values are converted
+    # to JSON before being stored, allowing it to also store booleans,
+    # hashes and arrays. However, this store does not support Procs.
+    #
+    # As the ActiveRecord backend, Symbols are just supported when loading
+    # translations from the filesystem or through explicit store translations.
+    #
+    # Also, avoid calling I18n.available_locales since it's a somehow
+    # expensive operation in most stores.
+    #
+    # == Example
+    #
+    # To setup I18n to use TokyoCabinet in memory is quite straightforward:
+    #
+    #   require 'rufus/tokyo/cabinet' # gem install rufus-tokyo
+    #   I18n.backend = I18n::Backend::KeyValue.new(Rufus::Tokyo::Cabinet.new('*'))
+    #
+    # == Subtrees
+    #
+    # In most backends, you are allowed to retrieve part of a translation tree:
+    #
+    #   I18n.backend.store_translations :en, :foo => { :bar => :baz }
+    #   I18n.t "foo" #=> { :bar => :baz }
+    #
+    # This backend supports this feature by default, but it slows down the storage
+    # of new data considerably and makes hard to delete entries. That said, you are
+    # allowed to disable the storage of subtrees on initialization:
+    #
+    #   I18n::Backend::KeyValue.new(@store, false)
+    #
+    class KeyValue
+      attr_accessor :store
+
+      include Base, Flatten
+
+      def initialize(store, subtrees=true)
+        @store, @subtrees = store, subtrees
+      end
+
+      # 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 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
+        end
+
+        def merge_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)
+              end
+            when Proc
+              raise "Key-value stores cannot handle procs"
+            when Symbol
+              value = nil
+            end
+
+            @store[key] = ActiveSupport::JSON.encode(value) unless value.nil?
+          end
+        end
+    end
+  end
+end

data/lib/i18n/backend/metadata.rb

@@ -13,9 +13,7 @@
 # into the Simple backend class - or whatever other backend you are using:
 #
 #   I18n::Backend::Simple.send(:include, I18n::Backend::Metadata)
-
-require 'i18n/core_ext/object/meta_class'
-
+#
 module I18n
   module Backend
     module Metadata

data/lib/i18n/backend/transliterator.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+module I18n
+  module Backend
+    module Transliterator
+
+      DEFAULT_REPLACEMENT_CHAR = "?"
+
+      # Get a transliterator instance.
+      def self.get(rule = nil)
+        if !rule || rule.kind_of?(Hash)
+          HashTransliterator.new(rule)
+        elsif rule.kind_of? Proc
+          ProcTransliterator.new(rule)
+        else
+          raise I18n::ArgumentError, "Transliteration rule must be a proc or a hash."
+        end
+      end
+
+      # A transliterator which accepts a Proc as its transliteration rule.
+      class ProcTransliterator
+
+        def initialize(rule)
+          @rule = rule
+        end
+
+        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",
+          "Î"=>"I", "Ï"=>"I", "Ð"=>"D", "Ñ"=>"N", "Ò"=>"O", "Ó"=>"O", "Ô"=>"O",
+          "Õ"=>"O", "Ö"=>"O", "×"=>"x", "Ø"=>"O", "Ù"=>"U", "Ú"=>"U", "Û"=>"U",
+          "Ü"=>"U", "Ý"=>"Y", "Þ"=>"Th", "ß"=>"ss", "à"=>"a", "á"=>"a", "â"=>"a",
+          "ã"=>"a", "ä"=>"a", "å"=>"a", "æ"=>"ae", "ç"=>"c", "è"=>"e", "é"=>"e",
+          "ê"=>"e", "ë"=>"e", "ì"=>"i", "í"=>"i", "î"=>"i", "ï"=>"i", "ð"=>"d",
+          "ñ"=>"n", "ò"=>"o", "ó"=>"o", "ô"=>"o", "õ"=>"o", "ö"=>"o", "ø"=>"o",
+          "ù"=>"u", "ú"=>"u", "û"=>"u", "ü"=>"u", "ý"=>"y", "þ"=>"th", "ÿ"=>"y",
+          "Ā"=>"A", "ā"=>"a", "Ă"=>"A", "ă"=>"a", "Ą"=>"A", "ą"=>"a", "Ć"=>"C",
+          "ć"=>"c", "Ĉ"=>"C", "ĉ"=>"c", "Ċ"=>"C", "ċ"=>"c", "Č"=>"C", "č"=>"c",
+          "Ď"=>"D", "ď"=>"d", "Đ"=>"D", "đ"=>"d", "Ē"=>"E", "ē"=>"e", "Ĕ"=>"E",
+          "ĕ"=>"e", "Ė"=>"E", "ė"=>"e", "Ę"=>"E", "ę"=>"e", "Ě"=>"E", "ě"=>"e",
+          "Ĝ"=>"G", "ĝ"=>"g", "Ğ"=>"G", "ğ"=>"g", "Ġ"=>"G", "ġ"=>"g", "Ģ"=>"G",
+          "ģ"=>"g", "Ĥ"=>"H", "ĥ"=>"h", "Ħ"=>"H", "ħ"=>"h", "Ĩ"=>"I", "ĩ"=>"i",
+          "Ī"=>"I", "ī"=>"i", "Ĭ"=>"I", "ĭ"=>"i", "Į"=>"I", "į"=>"i", "İ"=>"I",
+          "ı"=>"i", "IJ"=>"IJ", "ij"=>"ij", "Ĵ"=>"J", "ĵ"=>"j", "Ķ"=>"K", "ķ"=>"k",
+          "ĸ"=>"k", "Ĺ"=>"L", "ĺ"=>"l", "Ļ"=>"L", "ļ"=>"l", "Ľ"=>"L", "ľ"=>"l",
+          "Ŀ"=>"L", "ŀ"=>"l", "Ł"=>"L", "ł"=>"l", "Ń"=>"N", "ń"=>"n", "Ņ"=>"N",
+          "ņ"=>"n", "Ň"=>"N", "ň"=>"n", "ʼn"=>"'n", "Ŋ"=>"NG", "ŋ"=>"ng",
+          "Ō"=>"O", "ō"=>"o", "Ŏ"=>"O", "ŏ"=>"o", "Ő"=>"O", "ő"=>"o", "Œ"=>"OE",
+          "œ"=>"oe", "Ŕ"=>"R", "ŕ"=>"r", "Ŗ"=>"R", "ŗ"=>"r", "Ř"=>"R", "ř"=>"r",
+          "Ś"=>"S", "ś"=>"s", "Ŝ"=>"S", "ŝ"=>"s", "Ş"=>"S", "ş"=>"s", "Š"=>"S",
+          "š"=>"s", "Ţ"=>"T", "ţ"=>"t", "Ť"=>"T", "ť"=>"t", "Ŧ"=>"T", "ŧ"=>"t",
+          "Ũ"=>"U", "ũ"=>"u", "Ū"=>"U", "ū"=>"u", "Ŭ"=>"U", "ŭ"=>"u", "Ů"=>"U",
+          "ů"=>"u", "Ű"=>"U", "ű"=>"u", "Ų"=>"U", "ų"=>"u", "Ŵ"=>"W", "ŵ"=>"w",
+          "Ŷ"=>"Y", "ŷ"=>"y", "Ÿ"=>"Y", "Ź"=>"Z", "ź"=>"z", "Ż"=>"Z", "ż"=>"z",
+          "Ž"=>"Z", "ž"=>"z"
+        }
+
+        def initialize(rule = nil)
+          @rule = rule
+          add DEFAULT_APPROXIMATIONS
+          add rule if rule
+        end
+
+        def transliterate(string, replacement = nil)
+          string.gsub(/[^\x00-\x7f]/u) do |char|
+            approximations[char] || replacement || DEFAULT_REPLACEMENT_CHAR
+          end
+        end
+
+        private
+
+          def approximations
+            @approximations ||= {}
+          end
+
+          # Add transliteration rules to the approximations hash.
+          def add(hash)
+            hash.keys.each {|key| hash[key.to_s] = hash.delete(key).to_s}
+            approximations.merge! hash
+          end
+
+      end
+    end
+  end
+end

data/lib/i18n/gettext.rb

@@ -5,6 +5,8 @@ module I18n
     PLURAL_SEPARATOR  = "\001"
     CONTEXT_SEPARATOR = "\004"
 
+    autoload :Helpers, 'i18n/gettext/helpers'
+
     @@plural_keys = { :en => [:one, :other] }
 
     class << self

data/lib/i18n/{helpers/gettext.rb → gettext/helpers.rb}

@@ -2,12 +2,12 @@
 require 'i18n/gettext'
 
 module I18n
-  module Helpers
+  module Gettext
     # Implements classical Gettext style accessors. To use this include the
     # module to the global namespace or wherever you want to use it.
     #
     #   include I18n::Helpers::Gettext
-    module Gettext
+    module Helpers
       def gettext(msgid, options = {})
         I18n.t(msgid, { :default => msgid, :separator => '|' }.merge(options))
       end

data/lib/i18n/locale/fallbacks.rb

@@ -28,7 +28,7 @@
 #
 #   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] # TODO does not seem to work this way?
+#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :"de-DE", :de, :"en-US", :en]
 #
 #   # using a custom locale as default fallback locale
 #
@@ -55,10 +55,10 @@
 module I18n
   module Locale
     class Fallbacks < Hash
-      def initialize(*args)
+      def initialize(*mappings)
         @map = {}
-        map(args.pop) if args.last.is_a?(Hash) # TODO allow mappings anywhere in the args array
-        self.defaults = args.empty? ? [I18n.default_locale.to_sym] : args
+        map(mappings.pop) if mappings.last.is_a?(Hash)
+        self.defaults = mappings.empty? ? [I18n.default_locale.to_sym] : mappings
       end
 
       def defaults=(defaults)

data/lib/i18n/version.rb

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

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: i18n
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  prerelease: true
   segments: 
   - 0
-  - 3
-  - 7
-  version: 0.3.7
+  - 4
+  - 0
+  - beta
+  version: 0.4.0.beta
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -18,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-17 00:00:00 +02:00
+date: 2010-04-30 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -44,22 +45,22 @@ files:
 - 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/links.rb
+- lib/i18n/backend/key_value.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/core_ext/object/meta_class.rb
 - lib/i18n/core_ext/string/interpolate.rb
 - lib/i18n/exceptions.rb
 - lib/i18n/gettext.rb
+- lib/i18n/gettext/helpers.rb
 - lib/i18n/gettext/po_parser.rb
-- lib/i18n/helpers.rb
-- lib/i18n/helpers/gettext.rb
 - lib/i18n/locale.rb
 - lib/i18n/locale/fallbacks.rb
 - lib/i18n/locale/tag.rb
@@ -67,6 +68,9 @@ files:
 - lib/i18n/locale/tag/rfc4646.rb
 - lib/i18n/locale/tag/simple.rb
 - lib/i18n/version.rb
+- README.textile
+- MIT-LICENSE
+- CHANGELOG.textile
 has_rdoc: true
 homepage: http://github.com/svenfuchs/i18n
 licenses: []

data/lib/i18n/backend/links.rb

@@ -1,34 +0,0 @@
-module I18n
-  module Backend
-    module Links
-      protected
-        def links(locale)
-          @links ||= {}
-          @links[locale.to_sym] ||= {}
-        end
-
-        def store_link(locale, key, link)
-          links(locale)[key.to_s] = link.to_s
-        end
-
-        def resolve_link(locale, key)
-          key   = key.to_s
-          links = self.links(locale)
-
-          if links.key?(key)
-            links[key]
-          elsif link = find_link(locale, key)
-            store_link(locale, key, key.gsub(*link))
-          else
-            key
-          end
-        end
-
-        def find_link(locale, key)
-          links(locale).each do |from, to|
-            return [from, to] if key[0, from.length] == from
-          end && nil
-        end
-    end
-  end
-end

data/lib/i18n/core_ext/object/meta_class.rb

@@ -1,5 +0,0 @@
-Object.class_eval do
-  def meta_class
-    class << self; self; end
-  end
-end unless Object.method_defined?(:meta_class)

data/lib/i18n/helpers.rb

@@ -1,5 +0,0 @@
-module I18n
-  module Helpers
-    autoload :Gettext, 'i18n/helpers/gettext'
-  end
-end