i18n 0.3.3 → 0.3.4

data/README.textile

@@ -51,6 +51,29 @@ The new i18n gem can be loaded from vendor/plugins like this:
 
 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
@@ -78,4 +101,4 @@ h2. Contributors
 
 h2. License
 
-MIT License. See the included MIT-LICENCE file.
+MIT License. See the included MIT-LICENSE file.

data/Rakefile

@@ -1,8 +1,12 @@
+require 'rake/testtask'
+
 task :default => [:test]
 
-task :test do
-  ruby "test/all.rb"
+Rake::TestTask.new(:test) do |t|
+  t.pattern = "#{File.dirname(__FILE__)}/test/all.rb"
+  t.verbose = true
 end
+Rake::Task['test'].comment = "Run all i18n tests"
 
 require File.expand_path("lib/i18n/version", File.dirname(__FILE__))
 

data/lib/i18n.rb

@@ -219,12 +219,22 @@ module I18n
 
     # Localizes certain objects, such as dates and numbers to local formatting.
     def localize(object, options = {})
-      locale = options[:locale] || I18n.locale
-      format = options[:format] || :default
-      backend.localize(locale, object, format)
+      locale = options.delete(:locale) || I18n.locale
+      format = options.delete(:format) || :default
+      backend.localize(locale, object, format, options)
     end
     alias :l :localize
 
+    # Merges the given locale, key and scope into a single array of keys.
+    # Splits keys that contain dots into multiple keys. Makes sure all
+    # keys are Symbols.
+    def normalize_keys(locale, key, scope, separator = nil)
+      keys = [locale] + Array(scope) + Array(key)
+      keys = keys.map { |k| k.to_s.split(separator || I18n.default_separator) }
+      keys = keys.flatten - ['']
+      keys.map { |k| k.to_sym }
+    end
+
   # making these private until Ruby 1.9.2 can send to protected methods again
   # see http://redmine.ruby-lang.org/repositories/revision/ruby-19?rev=24280
   private
@@ -263,15 +273,5 @@ module I18n
         @@exception_handler.call(exception, locale, key, options)
       end
     end
-
-    # Merges the given locale, key and scope into a single array of keys.
-    # Splits keys that contain dots into multiple keys. Makes sure all
-    # keys are Symbols.
-    def normalize_translation_keys(locale, key, scope, separator = nil)
-      keys = [locale] + Array(scope) + Array(key)
-      keys = keys.map { |k| k.to_s.split(separator || I18n.default_separator) }
-      keys = keys.flatten - ['']
-      keys.map { |k| k.to_sym }
-    end
   end
 end

data/lib/i18n/backend.rb

@@ -5,10 +5,12 @@ module I18n
     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 :Gettext,               'i18n/backend/gettext'
     autoload :Helpers,               'i18n/backend/helpers'
+    autoload :Links,                 'i18n/backend/links'
     autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
     autoload :Metadata,              'i18n/backend/metadata'
     autoload :Pluralization,         'i18n/backend/pluralization'

data/lib/i18n/backend/active_record.rb

@@ -1,13 +1,6 @@
 require 'i18n/backend/base'
 require 'i18n/backend/active_record/translation'
 
-#
-#  This backend reads translations from a Translations table in environment database. Note that the database
-#  will not automatically be prepopulated with missing keys. You can achieve this effect with the ActiveRecordMissing backend, 
-#  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
@@ -15,16 +8,17 @@ module I18n
       autoload :StoreProcs,  'i18n/backend/active_record/store_procs'
       autoload :Translation, 'i18n/backend/active_record/translation'
 
-      include Base
+      include Base, Links
 
       def reload!
       end
 
       def store_translations(locale, data, options = {})
         separator = options[:separator] || I18n.default_separator
-        wind_keys(data, separator).each do |key, v|
+        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 => v)
+          Translation.create(:locale => locale.to_s, :key => key.to_s, :value => value)
         end
       end
 
@@ -38,13 +32,15 @@ module I18n
 
       protected
 
-        def lookup(locale, key, scope = [], separator = nil)
+        def lookup(locale, key, scope = [], options = {})
           return unless key
 
-          separator ||= I18n.default_separator
-          key = (Array(scope) + Array(key)).join(separator)
+          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
+
           if result.empty?
             return nil
           elsif result.first.key == key

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

@@ -37,7 +37,7 @@ module I18n
           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]
+          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?

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

@@ -23,11 +23,11 @@ module I18n
       module StoreProcs
         def value=(v)
           case v
-            when Proc
-              write_attribute(:value, v.to_ruby)
-              write_attribute(:is_proc, true)
-            else
-              write_attribute(:value, v)
+          when Proc
+            write_attribute(:value, v.to_ruby)
+            write_attribute(:is_proc, true)
+          else
+            write_attribute(:value, v)
           end
         end
 

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

@@ -56,9 +56,11 @@ module I18n
         }
 
         named_scope :lookup, lambda { |keys, *separator|
-          keys = Array(keys).map! { |key| key.to_s }
-          separator = separator.first || I18n.default_separator
-          { :conditions => ["`key` IN (?) OR `key` LIKE '#{keys.last}#{separator}%'", keys] }
+          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}%"
+          { :conditions => ["#{column_name} IN (?) OR #{column_name} LIKE ?", keys, namespace] }
         }
 
         def self.available_locales
@@ -71,7 +73,7 @@ module I18n
 
         def value
           if is_proc
-            Kernel.eval read_attribute(:value)
+            Kernel.eval(read_attribute(:value))
           else
             value = read_attribute(:value)
             value == 'f' ? false : value

data/lib/i18n/backend/base.rb

@@ -1,13 +1,14 @@
 # encoding: utf-8
 
 require 'yaml'
+require 'i18n/core_ext/hash/except'
 
 module I18n
   module Backend
     module Base
       include I18n::Backend::Helpers
 
-      RESERVED_KEYS = [:scope, :default, :separator]
+      RESERVED_KEYS = [:scope, :default, :separator, :resolve]
       INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
 
       # Accepts a list of paths to translation files. Loads translations from
@@ -22,7 +23,7 @@ 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)
+        merge_translations(locale, data, options)
       end
 
       def translate(locale, key, options = {})
@@ -33,10 +34,10 @@ module I18n
           entry = resolve(locale, key, lookup(locale, key), options)
           raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
         else
-          count, scope, default, separator = options.values_at(:count, :scope, :default, :separator)
+          count, scope, default = options.values_at(:count, :scope, :default)
           values = options.reject { |name, value| RESERVED_KEYS.include?(name) }
 
-          entry = lookup(locale, key, scope, separator)
+          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?
 
@@ -56,8 +57,7 @@ module I18n
         if Symbol === format
           key = format
           type = object.respond_to?(:sec) ? 'time' : 'date'
-          format = lookup(locale, :"#{type}.formats.#{key}")
-          raise(MissingTranslationData.new(locale, key, options)) if format.nil?
+          format = I18n.t(:"#{type}.formats.#{key}", :locale => locale, :raise => true)
         end
 
         format = resolve(locale, object, format, options)
@@ -108,15 +108,15 @@ module I18n
         # 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 = [], separator = nil)
+        def lookup(locale, key, scope = [], options = {})
           return unless key
           init_translations unless initialized?
-          keys = I18n.send(:normalize_translation_keys, locale, key, scope, separator)
+          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, :separator => separator) if result.is_a?(Symbol)
+            result = resolve(locale, key, result, options) if result.is_a?(Symbol)
             result
           end
         end
@@ -142,6 +142,7 @@ module I18n
         # given options. If it is a Proc then it will be evaluated. All other
         # subjects will be returned directly.
         def resolve(locale, object, subject, options = nil)
+          return subject if options[:resolve] == false
           case subject
           when Symbol
             I18n.translate(subject, (options || {}).merge(:locale => locale, :raise => true))
@@ -176,7 +177,7 @@ module I18n
         # the <tt>{{...}}</tt> key in a string (once for the string and once for the
         # interpolation).
         def interpolate(locale, string, values = {})
-          return string unless string.is_a?(String) && !values.empty?
+          return string unless string.is_a?(::String) && !values.empty?
 
           preserve_encoding(string) do
             s = string.gsub(INTERPOLATION_SYNTAX_PATTERN) do
@@ -192,7 +193,7 @@ module I18n
 
             values.each do |key, value|
               value = value.call(values) if interpolate_lambda?(value, s, key)
-              value = value.to_s unless value.is_a?(String)
+              value = value.to_s unless value.is_a?(::String)
               values[key] = value
             end
 
@@ -227,7 +228,7 @@ module I18n
         def load_file(filename)
           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 = send(:"load_#{type}", filename) # TODO raise a meaningful exception if this does not yield a Hash
           data.each { |locale, d| merge_translations(locale, d) }
         end
 
@@ -245,13 +246,19 @@ module I18n
 
         # Deep merges the given translations hash with the existing translations
         # for the given locale
-        def merge_translations(locale, data)
+        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 { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+          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)
         end
     end

data/lib/i18n/backend/cache.rb

@@ -55,6 +55,7 @@ module I18n
         def fetch(*args, &block)
           result = I18n.cache_store.fetch(cache_key(*args), &block)
           raise result if result.is_a?(Exception)
+          result = result.dup if result.frozen?
           result
         rescue MissingTranslationData => exception
           I18n.cache_store.write(cache_key(*args), exception)

data/lib/i18n/backend/cascade.rb

@@ -2,7 +2,7 @@
 
 # EXPERIMENTAL
 #
-# The cascade module adds the ability to do cascading lookups to backends that
+# The Cascade module adds the ability to do cascading lookups to backends that
 # are compatible to the Simple backend.
 #
 # By cascading lookups we mean that for any key that can not be found the
@@ -15,7 +15,15 @@
 # then the remaining scope segment :foo will be omitted, too, and again the
 # key :baz will be looked up (now with no scope).
 #
-# Defaults will only kick in after the cascading lookups haven't succeeded.
+# To enable a cascading lookup one passes the :cascade option:
+#
+#   I18n.t(:'foo.bar.baz', :cascade => true)
+#
+# This will return the first translation found for :"foo.bar.baz", :"foo.baz"
+# or :baz in this order.
+#
+# The cascading lookup takes precedence over resolving any given defaults.
+# I.e. defaults will kick in after the cascading lookups haven't succeeded.
 #
 # This behavior is useful for libraries like ActiveRecord validations where
 # the library wants to give users a bunch of more or less fine-grained options
@@ -25,19 +33,25 @@
 # http://github.com/clemens/i18n-cascading-backend
 
 module I18n
-  @@fallbacks = nil
-
   module Backend
     module Cascade
-      def lookup(locale, key, scope = [], separator = nil)
+      def lookup(locale, key, scope = [], options = {})
         return unless key
-        locale, *scope = I18n.send(:normalize_translation_keys, locale, key, scope, separator)
-        key = scope.pop
+        return super unless cascade = options[:cascade]
+
+        separator = options[:separator] || I18n.default_separator
+        skip_root = cascade.has_key?(:skip_root) ? cascade[:skip_root] : true
+        step      = cascade[:step]
+
+        keys   = I18n.normalize_keys(nil, key, nil, separator)
+        offset = options[:cascade][:offset] || keys.length
+        scope  = I18n.normalize_keys(nil, nil, scope, separator) + keys
+        key    = scope.slice!(-offset, offset).join(separator)
 
         begin
           result = super
           return result unless result.nil?
-        end while scope.pop
+        end while scope.slice!(-step, step) && (!scope.empty? || !skip_root)
       end
     end
   end

data/lib/i18n/backend/chain.rb

@@ -62,7 +62,8 @@ module I18n
             result = backend.localize(locale, object, format, options) and return result
           rescue MissingTranslationData
           end
-        end and nil
+        end
+        raise(I18n::MissingTranslationData.new(locale, format, options))
       end
 
       protected

data/lib/i18n/backend/cldr.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+require 'cldr'
+
+module I18n
+  module Backend
+    module Cldr
+      include ::Cldr::Format
+
+      def localize(locale, object, format = :default, options = {})
+        options[:as] ||= detect_type(object, options)
+        send(:"format_#{options[:as]}", locale, object, format, options)
+      end
+
+      def format_decimal(locale, object, format = :default, options = {})
+        formatter(locale, :decimal, format).apply(object, options)
+      end
+
+      def format_integer(locale, object, format = :default, options = {})
+        format_object(number, options.merge(:precision => 0))
+      end
+
+      def format_currency(locale, object, format = :default, options = {})
+        options.merge!(:currency => lookup_currency(locale, options[:currency], object)) if options[:currency].is_a?(Symbol)
+        formatter(locale, :currency, format).apply(object, options)
+      end
+
+      def format_percent(locale, object, format = :default, options = {})
+        formatter(locale, :percent, format).apply(object, options)
+      end
+
+      def format_date(locale, object, format = :default, options = {})
+        formatter(locale, :date, format).apply(object, options)
+      end
+
+      def format_time(locale, object, format = :default, options = {})
+        formatter(locale, :time, format).apply(object, options)
+      end
+
+      def format_datetime(locale, object, format = :default, options = {})
+        key  = :"calendars.gregorian.formats.datetime.#{format}.pattern"
+        date = I18n.l(object, :format => options[:date_format] || format, :locale => locale, :as => :date)
+        time = I18n.l(object, :format => options[:time_format] || format, :locale => locale, :as => :time)
+        I18n.t(key, :date => date, :time => time, :locale => locale, :raise => true)
+      end
+
+      protected
+
+        def detect_type(object, options)
+          options.has_key?(:currency) ? :currency : case object
+          when ::Numeric
+            :decimal
+          when ::Date, ::DateTime, ::Time
+            object.class.name.downcase.to_sym
+          else
+            raise_unspecified_format_type!
+          end
+        end
+
+        def formatter(locale, type, format)
+          (@formatters ||= {})[:"#{locale}.#{type}.#{format}"] ||= begin
+            format = lookup_format(locale, type, format)
+            data   = lookup_format_data(locale, type)
+            ::Cldr::Format.const_get(type.to_s.camelize).new(format, data)
+          end
+        end
+
+        def lookup_format(locale, type, format)
+          key = case type
+          when :date, :time, :datetime
+            :"calendars.gregorian.formats.#{type}.#{format}.pattern"
+          else
+            :"numbers.formats.#{type}.patterns.#{format || :default}"
+          end
+          I18n.t(key, :locale => locale, :raise => true)
+        end
+
+        def lookup_format_data(locale, type)
+          key = case type
+          when :date, :time, :datetime
+            :'calendars.gregorian'
+          else
+            :'numbers.symbols'
+          end
+          I18n.t(key, :locale => locale, :raise => true)
+        end
+
+        def lookup_currency(locale, currency, count)
+          I18n.t(:"currencies.#{currency}", :locale => locale, :count => count)
+        end
+
+        def raise_unspecified_format_type!
+          raise ArgumentError.new("You have to specify a format type, e.g. :as => :number.")
+        end
+
+        def raise_unspecified_currency!
+          raise ArgumentError.new("You have to specify a currency, e.g. :currency => 'EUR'.")
+        end
+    end
+  end
+end