i18n 0.4.0.beta1 → 0.4.0

data/CHANGELOG.textile

@@ -2,7 +2,9 @@ h1. Changelog
 
 h2. master
 
-*
+h2. 0.4.0 (2010-05-27)
+
+* "The localization proc also receives the object as option":http://github.com/svenfuchs/i18n/commit/4a8cd9fa660daaa3078e24c5851353ca377d9213
 
 h2. 0.4.0.beta1 (2010-05-03)
 

data/lib/i18n.rb

@@ -164,13 +164,13 @@ module I18n
     # Transliterates UTF-8 characters to ASCII. By default this method will
     # transliterate only Latin strings to an ASCII approximation:
     #
-    #    I18N.transliterate("Ærøskøbing")
+    #    I18n.transliterate("Ærøskøbing")
     #    # => "AEroskobing"
     #
-    #    I18N.transliterate("日本語")
+    #    I18n.transliterate("日本語")
     #    # => "???"
     #
-    # It's also possible to add support for per-locale transliterations. I18N
+    # It's also possible to add support for per-locale transliterations. I18n
     # expects transliteration rules to be stored at
     # <tt>i18n.transliterate.rule</tt>.
     #
@@ -206,12 +206,12 @@ module I18n
     #
     # 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"
+    #     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
@@ -232,6 +232,18 @@ module I18n
     end
     alias :l :localize
 
+    # Executes block with given I18n.locale set.
+    def with_locale(tmp_locale = nil)
+      if tmp_locale
+        current_locale = self.locale
+        self.locale    = tmp_locale
+      end
+      yield
+    ensure
+      self.locale = current_locale if tmp_locale
+    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.

data/lib/i18n/backend/active_record.rb

@@ -11,12 +11,7 @@ module I18n
       module Implementation
         include Base, Flatten
 
-        def reload!
-        end
-
         def available_locales
-          init_translations unless initialized?
-
           begin
             Translation.available_locales
           rescue ::ActiveRecord::StatementInvalid
@@ -25,7 +20,8 @@ module I18n
         end
 
         def store_translations(locale, data, options = {})
-          flatten_translations(locale, data).each do |key, value|
+          escape = options.fetch(:escape, true)
+          flatten_translations(locale, data, escape, false).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

data/lib/i18n/backend/base.rb

@@ -9,33 +9,28 @@ module I18n
       include I18n::Backend::Transliterator
 
       RESERVED_KEYS = [:scope, :default, :separator, :resolve]
-      RESERVED_KEYS_PATTERN = /%?%\{(#{RESERVED_KEYS.join("|")})\}/
-      INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
+      RESERVED_KEYS_PATTERN = /%\{(#{RESERVED_KEYS.join("|")})\}/
+      DEPRECATED_INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
 
       # Accepts a list of paths to translation files. Loads translations from
       # plain Ruby (*.rb) or YAML files (*.yml). See #load_rb and #load_yml
       # for details.
       def load_translations(*filenames)
+        filenames = I18n.load_path.flatten if filenames.empty?
         filenames.each { |filename| load_file(filename) }
       end
 
-      # Stores translations for the given locale in memory.
-      # This uses a deep merge for the translations hash, so existing
-      # translations will be overwritten by new ones only at the deepest
-      # level of the hash.
+      # This method receives a locale, a data hash and options for storing translations.
+      # Should be implemented
       def store_translations(locale, data, options = {})
-        locale = locale.to_sym
-        translations[locale] ||= {}
-
-        data = data.deep_symbolize_keys
-        translations[locale].deep_merge!(data)
+        raise NotImplementedError
       end
 
       def translate(locale, key, options = {})
         raise InvalidLocale.new(locale) unless locale
         return key.map { |k| translate(locale, k, options) } if key.is_a?(Array)
 
-        entry = lookup!(locale, key, options)
+        entry = key && lookup(locale, key, options[:scope], options)
 
         if options.empty?
           entry = resolve(locale, key, entry, options)
@@ -63,7 +58,7 @@ module I18n
         if Symbol === format
           key = format
           type = object.respond_to?(:sec) ? 'time' : 'date'
-          format = I18n.t(:"#{type}.formats.#{key}", :locale => locale, :raise => true)
+          format = I18n.t(:"#{type}.formats.#{key}", options.merge(:raise => true, :object => object, :locale => locale))
         end
 
         # format = resolve(locale, object, format, options)
@@ -80,60 +75,21 @@ module I18n
         object.strftime(format)
       end
 
-      def initialized?
-        @initialized ||= false
-      end
-
       # Returns an array of locales for which translations are available
       # ignoring the reserved translation meta data key :i18n.
       def available_locales
-        init_translations unless initialized?
-        translations.inject([]) do |locales, (locale, data)|
-          locales << locale unless (data.keys - [:i18n]).empty?
-          locales
-        end
+        raise NotImplementedError
       end
 
       def reload!
-        @initialized = false
-        @translations = nil
         @skip_syntax_deprecation = false
       end
 
       protected
 
-        def init_translations
-          load_translations(*I18n.load_path.flatten)
-          @initialized = true
-        end
-
-        def translations
-          @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>.
+        # The method which actually looks up for the translation in the store.
         def lookup(locale, key, scope = [], options = {})
-          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.merge(:scope => nil)) if result.is_a?(Symbol)
-            result
-          end
+          raise NotImplementedError
         end
 
         # Evaluates defaults.
@@ -162,7 +118,8 @@ module I18n
           when Symbol
             I18n.translate(subject, (options || {}).merge(:locale => locale, :raise => true))
           when Proc
-            resolve(locale, object, subject.call(object, options), options = {})
+            date_or_time = options.delete(:object) || object
+            resolve(locale, object, subject.call(date_or_time, options), options = {})
           else
             subject
           end
@@ -175,7 +132,7 @@ module I18n
         # and the second translation if it is equal to 1. Other backends can
         # implement more flexible or complex pluralization rules.
         def pluralize(locale, entry, count)
-          return entry unless entry.is_a?(Hash) and count
+          return entry unless entry.is_a?(Hash) && count
 
           key = :zero if count == 0 && entry.has_key?(:zero)
           key ||= count == 1 ? :one : :other
@@ -193,9 +150,9 @@ module I18n
         # interpolation).
         def interpolate(locale, string, values = {})
           return string unless string.is_a?(::String) && !values.empty?
-
+          
           preserve_encoding(string) do
-            string = string.gsub(INTERPOLATION_SYNTAX_PATTERN) do
+            string = string.gsub(DEPRECATED_INTERPOLATION_SYNTAX_PATTERN) do
               escaped, key = $1, $2.to_sym
               if escaped
                 "{{#{key}}}"

data/lib/i18n/backend/flatten.rb

@@ -3,7 +3,7 @@ module I18n
     # 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;
+    #   1) speed up lookups, as in the Memoize 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.
@@ -51,12 +51,12 @@ module I18n
       #   >> { "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)
+      def flatten_keys(hash, escape, prev_key=nil, &block)
         hash.each_pair do |key, value|
-          key = escape_default_separator(key)
+          key = escape_default_separator(key) if escape
           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)
+          flatten_keys(value, escape, curr_key, &block) if value.is_a?(Hash)
         end
       end
 
@@ -66,9 +66,9 @@ module I18n
       #
       # 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)
+      def flatten_translations(locale, data, escape, subtree)
         hash = {}
-        flatten_keys(data) do |key, value|
+        flatten_keys(data, escape) do |key, value|
           if value.is_a?(Hash)
             hash[key] = value if subtree
           else

data/lib/i18n/backend/key_value.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 require 'i18n/backend/base'
 require 'active_support/json'
 
@@ -47,6 +48,7 @@ module I18n
     #
     #   I18n::Backend::KeyValue.new(@store, false)
     #
+    # This is useful if you are using a KeyValue backend chained to a Simple backend.
     class KeyValue
       module Implementation
         attr_accessor :store
@@ -57,12 +59,9 @@ module I18n
           @store, @subtrees = store, subtrees
         end
 
-        # Mute reload! since we really don't want to clean the database.
-        def reload!
-        end
-
         def store_translations(locale, data, options = {})
-          flatten_translations(locale, data, @subtrees).each do |key, value|
+          escape = options.fetch(:escape, true)
+          flatten_translations(locale, data, escape, @subtrees).each do |key, value|
             key = "#{locale}.#{key}"
 
             case value
@@ -80,8 +79,6 @@ module I18n
         end
 
         def available_locales
-          init_translations unless initialized?
-
           locales = @store.keys.map { |k| k =~ /\./; $` }
           locales.uniq!
           locales.compact!

data/lib/i18n/backend/simple.rb

@@ -1,22 +1,87 @@
 # encoding: utf-8
 
-# Stub class for the Simple backend. The actual implementation is provided by
-# the backend Base class. This makes it easier to extend the Simple backend's
-# behaviour by including modules. E.g.:
-#
-# module I18n::Backend::Pluralization
-#   def pluralize(*args)
-#     # extended pluralization logic
-#     super
-#   end
-# end
-#
-# I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
-
 module I18n
   module Backend
+    # A simple backend that reads translations from YAML files and stores them in
+    # an in-memory hash. Relies on the Base backend.
+    #
+    # The implementation is provided by a Implementation module allowing to easily
+    # extend Simple backend's behavior by including modules. E.g.:
+    #
+    # module I18n::Backend::Pluralization
+    #   def pluralize(*args)
+    #     # extended pluralization logic
+    #     super
+    #   end
+    # end
+    #
+    # I18n::Backend::Simple.send(:include, I18n::Backend::Pluralization)
     class Simple
-      include Base
+      module Implementation
+        include Base
+
+        def initialized?
+          @initialized ||= false
+        end
+
+        # Stores translations for the given locale in memory.
+        # This uses a deep merge for the translations hash, so existing
+        # translations will be overwritten by new ones only at the deepest
+        # level of the hash.
+        def store_translations(locale, data, options = {})
+          locale = locale.to_sym
+          translations[locale] ||= {}
+          data = data.deep_symbolize_keys
+          translations[locale].deep_merge!(data)
+        end
+
+        # Get available locales from the translations hash
+        def available_locales
+          init_translations unless initialized?
+          translations.inject([]) do |locales, (locale, data)|
+            locales << locale unless (data.keys - [:i18n]).empty?
+            locales
+          end
+        end
+
+        # Clean up translations hash and set initialized to false on reload!
+        def reload!
+          @initialized = false
+          @translations = nil
+          super
+        end
+
+      protected
+
+        def init_translations
+          load_translations
+          @initialized = true
+        end
+
+        def translations
+          @translations ||= {}
+        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 = {})
+          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.merge(:scope => nil)) if result.is_a?(Symbol)
+            result
+          end
+        end
+      end
+
+      include Implementation
     end
   end
 end

data/lib/i18n/version.rb

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

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: i18n
 version: !ruby/object:Gem::Version 
-  prerelease: true
+  prerelease: false
   segments: 
   - 0
   - 4
   - 0
-  - beta1
-  version: 0.4.0.beta1
+  version: 0.4.0
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -19,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-03 00:00:00 +02:00
+date: 2010-05-27 00:00:00 +02:00
 default_executable: 
 dependencies: []