activesupport 2.3.8 → 2.3.9.pre

data/lib/active_support/vendor/{i18n-0.3.7 → i18n-0.4.1}/i18n/backend.rb

@@ -2,18 +2,19 @@ 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 :Links,                 'i18n/backend/links'
-    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'
+    autoload :Transliterator,        'i18n/backend/transliterator'
   end
 end

data/lib/active_support/vendor/i18n-0.4.1/i18n/backend/active_record.rb

@@ -0,0 +1,61 @@
+require 'i18n/backend/base'
+require 'i18n/backend/active_record/translation'
+
+module I18n
+  module Backend
+    class ActiveRecord
+      autoload :Missing,     'i18n/backend/active_record/missing'
+      autoload :StoreProcs,  'i18n/backend/active_record/store_procs'
+      autoload :Translation, 'i18n/backend/active_record/translation'
+
+      module Implementation
+        include Base, Flatten
+
+        def available_locales
+          begin
+            Translation.available_locales
+          rescue ::ActiveRecord::StatementInvalid
+            []
+          end
+        end
+
+        def store_translations(locale, data, options = {})
+          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
+        end
+
+      protected
+
+        def lookup(locale, key, scope = [], options = {})
+          key = normalize_flat_keys(locale, key, scope, options[:separator])
+          result = Translation.locale(locale).lookup(key).all
+
+          if result.empty?
+            nil
+          elsif result.first.key == key
+            result.first.value
+          else
+            chop_range = (key.size + FLATTEN_SEPARATOR.size)..-1
+            result = result.inject({}) do |hash, r|
+              hash[r.key.slice(chop_range)] = r.value
+              hash
+            end
+            result.deep_symbolize_keys
+          end
+        end
+
+        # For a key :'foo.bar.baz' return ['foo', 'foo.bar', 'foo.bar.baz']
+        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
+
+      include Implementation
+    end
+  end
+end

data/lib/active_support/vendor/{i18n-0.3.7 → i18n-0.4.1}/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/active_support/vendor/{i18n-0.3.7 → i18n-0.4.1}/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/active_support/vendor/{i18n-0.3.7 → i18n-0.4.1}/i18n/backend/base.rb

@@ -1,50 +1,52 @@
 # 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]
-      INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
+      RESERVED_KEYS_PATTERN = /%\{(#{RESERVED_KEYS.join("|")})\}/
+      DEPRECATED_INTERPOLATION_SYNTAX_PATTERN = /(\\)?\{\{([^\}]+)\}\}/
+      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 = {})
-        merge_translations(locale, data, options)
+        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 = key && lookup(locale, key, options[:scope], options)
+
         if options.empty?
-          entry = resolve(locale, key, lookup(locale, key), options)
-          raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
+          entry = resolve(locale, key, entry, options)
         else
-          count, scope, default = options.values_at(:count, :scope, :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
+          count, default = options.values_at(:count, :default)
+          values = options.except(*RESERVED_KEYS)
+          entry = entry.nil? && default ?
+            default(locale, key, default, options) : resolve(locale, key, entry, options)
         end
 
+        raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
+        entry = entry.dup if entry.is_a?(String)
+
+        entry = pluralize(locale, entry, count) if count
+        entry = interpolate(locale, entry, values) if values
         entry
       end
 
@@ -57,7 +59,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)
@@ -74,51 +76,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
 
-        # 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 = {})
-          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)
-            String === result ? result.dup : result
-          end
+          raise NotImplementedError
         end
 
         # Evaluates defaults.
@@ -147,7 +119,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
@@ -160,7 +133,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
@@ -170,38 +143,48 @@ 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
         # interpolation).
         def interpolate(locale, string, values = {})
           return string unless string.is_a?(::String) && !values.empty?
+          original_values = values.dup
 
           preserve_encoding(string) do
-            s = string.gsub(INTERPOLATION_SYNTAX_PATTERN) do
+            string = string.gsub(DEPRECATED_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
 
+            keys = string.scan(INTERPOLATION_SYNTAX_PATTERN).flatten
+            return string if keys.empty?
+
             values.each do |key, value|
-              value = value.call(values) if interpolate_lambda?(value, s, key)
-              value = value.to_s unless value.is_a?(::String)
-              values[key] = value
+              if keys.include?(key.to_s)
+                value = value.call(values) if interpolate_lambda?(value, string, key)
+                value = value.to_s unless value.is_a?(::String)
+                values[key] = value
+              else
+                values.delete(key)
+              end
             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(original_values, string)
+          end
         end
 
         def preserve_encoding(string)
@@ -229,7 +212,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
@@ -244,22 +227,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] ||= {}
-          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)
+        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/active_support/vendor/{i18n-0.3.7 → i18n-0.4.1}/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/active_support/vendor/{i18n-0.3.7 → i18n-0.4.1}/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/active_support/vendor/{i18n-0.3.7 → i18n-0.4.1}/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/active_support/vendor/i18n-0.4.1/i18n/backend/flatten.rb

@@ -0,0 +1,113 @@
+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 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.
+    # 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 = "."
+
+      # 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] = {} }
+      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, escape, prev_key=nil, &block)
+        hash.each_pair do |key, value|
+          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, escape, 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, escape, subtree)
+        hash = {}
+        flatten_keys(data, escape) 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
+
+      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) #:nodoc:
+          links[locale].each do |from, to|
+            return [from, to] if key[0, from.length] == from
+          end && nil
+        end
+
+        def escape_default_separator(key) #:nodoc:
+          I18n::Backend::Flatten.escape_default_separator(key)
+        end
+
+    end
+  end
+end