activesupport 2.3.6.pre → 2.3.6

data/lib/active_support/vendor/{i18n-0.3.3/lib → i18n-0.3.7}/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? rescue result
           result
         rescue MissingTranslationData => exception
           I18n.cache_store.write(cache_key(*args), exception)

data/lib/active_support/vendor/{i18n-0.3.3/lib → i18n-0.3.7}/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.empty? && scope.slice!(-step, step) && (!scope.empty? || !skip_root)
       end
     end
   end

data/lib/active_support/vendor/{i18n-0.3.3/lib → i18n-0.3.7}/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/active_support/vendor/i18n-0.3.7/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

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

@@ -34,10 +34,12 @@ module I18n
       # locales it will then raise a MissingTranslationData exception as
       # usual.
       #
-      # The default option takes precedence over fallback locales, i.e. it
-      # will first evaluate a given default option before falling back to
-      # another locale.
+      # The default option takes precedence over fallback locales
+      # only when it's not a String. When default contains String it
+      # is evaluated after fallback locales.
       def translate(locale, key, options = {})
+        default = extract_string_default!(options) if options[:default]
+
         I18n.fallbacks[locale].each do |fallback|
           begin
             result = super(fallback, key, options)
@@ -45,8 +47,23 @@ module I18n
           rescue I18n::MissingTranslationData
           end
         end
+
+        return super(locale, nil, options.merge(:default => default)) if default
         raise(I18n::MissingTranslationData.new(locale, key, options))
       end
+
+      def extract_string_default!(options)
+        defaults = Array(options[:default])
+        if index = find_first_string_default(defaults)
+          options[:default] = defaults[0, index]
+          defaults[index]
+        end
+      end
+
+      def find_first_string_default(defaults)
+        defaults.each_index { |ix| return ix if String === defaults[ix] }
+        nil
+      end
     end
   end
 end

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

@@ -12,7 +12,7 @@
 module I18n
   module Backend
     module Fast
-      SEPARATOR_ESCAPE_CHAR = "\001"
+      include Links
 
       def reset_flattened_translations!
         @flattened_translations = nil
@@ -22,7 +22,7 @@ module I18n
         @flattened_translations ||= flatten_translations(translations)
       end
 
-      def merge_translations(locale, data)
+      def merge_translations(locale, data, options = {})
         super
         reset_flattened_translations!
       end
@@ -33,29 +33,30 @@ module I18n
       end
 
       protected
-        # flatten_hash({:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}})
-        # # => {:a=>'a', :b=>{:c=>'c', :d=>'d', :f=>{:x=>'x'}}, :"b.f" => {:x=>"x"}, :"b.c"=>"c", :"b.f.x"=>"x", :"b.d"=>"d"}
-        def flatten_hash(h, nested_stack = [], flattened_h = {}, orig_h=h)
-          wind_keys(h, nil, true)
-        end
-
         def flatten_translations(translations)
           # don't flatten locale roots
-          translations.inject({}) do |flattened_h, (locale_name, locale_translations)|
-            flattened_h[locale_name] = flatten_hash(locale_translations)
-            flattened_h
+          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
         end
 
-        def lookup(locale, key, scope = nil, separator = nil)
+        def lookup(locale, key, scope = nil, options = {})
           return unless key
           init_translations unless initialized?
 
+          return nil unless flattened_translations.has_key?(locale.to_sym)
+
+          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]
         end

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 require 'i18n/gettext'
-require File.expand_path(File.dirname(__FILE__) + '/../../../vendor/po_parser.rb')
+require 'i18n/gettext/po_parser'
 
 # Experimental support for using Gettext po files to store translations.
 #

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

@@ -22,16 +22,11 @@ module I18n
           key = escape_default_separator(key, separator)
           curr_key = [prev_key, key].compact.join(separator).to_sym
 
-          if value.is_a?(Symbol)
-            value = hash_lookup(orig_hash, value, separator) ||
-                    hash_lookup(hash, value, separator) || value
-          end
-
           if value.is_a?(Hash)
             result[curr_key] = value if subtree
             wind_keys(value, separator, subtree, curr_key, result, orig_hash)
           else
-            result[curr_key] = value
+            result[unescape_default_separator(curr_key)] = value
           end
         end
 
@@ -41,16 +36,9 @@ module I18n
       def escape_default_separator(key, separator=nil)
         key.to_s.tr(separator || I18n.default_separator, SEPARATOR_ESCAPE_CHAR)
       end
-
-      def hash_lookup(hash, keys, separator = ".")
-        keys.to_s.split(separator).inject(hash) do |result, key|
-          key = key.to_sym
-          if result.respond_to?(:has_key?) and result.has_key?(key)
-            result[key]
-          else
-            return nil
-          end
-        end
+      
+      def unescape_default_separator(key, separator=nil)
+        key.to_s.tr(SEPARATOR_ESCAPE_CHAR, separator || I18n.default_separator).to_sym
       end
 
       # Expand keys chained by the the given separator through nested Hashes

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

@@ -33,7 +33,7 @@ module I18n
         end
 
         def interpolated_str?(str)
-          str.kind_of?(String) && str =~ INTERPOLATION_SYNTAX_PATTERN
+          str.kind_of?(::String) && str =~ INTERPOLATION_SYNTAX_PATTERN
         end
 
         protected
@@ -102,7 +102,7 @@ module I18n
         end
       end
 
-      def merge_translations(locale, data)
+      def merge_translations(locale, data, options = {})
         compile_all_strings_in(data)
         super
       end

data/lib/active_support/vendor/i18n-0.3.7/i18n/backend/links.rb

@@ -0,0 +1,34 @@
+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/active_support/vendor/{i18n-0.3.3/lib → i18n-0.3.7}/i18n/backend/pluralization.rb

@@ -50,7 +50,7 @@ module I18n
         end
 
         def pluralizer(locale)
-          pluralizers[locale] ||= lookup(locale, :'i18n.plural.rule')
+          pluralizers[locale] ||= I18n.t(:'i18n.plural.rule', :locale => locale, :resolve => false)
         end
     end
   end

data/lib/active_support/vendor/i18n-0.3.7/i18n/core_ext/hash/except.rb

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

data/lib/active_support/vendor/i18n-0.3.7/i18n/core_ext/hash/slice.rb

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

data/lib/active_support/vendor/{i18n-0.3.3/lib → i18n-0.3.7}/i18n/core_ext/string/interpolate.rb

@@ -96,4 +96,4 @@ if RUBY_VERSION < '1.9'
       end
     end
   end
-end
+end

data/lib/active_support/vendor/{i18n-0.3.3/lib → i18n-0.3.7}/i18n/exceptions.rb

@@ -21,7 +21,7 @@ module I18n
     attr_reader :locale, :key, :options
     def initialize(locale, key, opts = nil)
       @key, @locale, @options = key, locale, opts || {}
-      keys = I18n.send(:normalize_translation_keys, locale, key, options[:scope])
+      keys = I18n.normalize_keys(locale, key, options[:scope])
       keys << 'no key' if keys.size < 2
       super "translation missing: #{keys.join(', ')}"
     end

data/lib/active_support/vendor/{i18n-0.3.3/lib → i18n-0.3.7}/i18n/helpers/gettext.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+require 'i18n/gettext'
 
 module I18n
   module Helpers
@@ -14,7 +15,7 @@ module I18n
 
       def sgettext(msgid, separator = '|')
         scope, msgid = I18n::Gettext.extract_scope(msgid, separator)
-        I18n.t(msgid, :scope => scope, :default => msgid)
+        I18n.t(msgid, :scope => scope, :default => msgid, :separator => separator)
       end
       alias s_ sgettext
 
@@ -35,7 +36,7 @@ module I18n
       def nsgettext(msgid, msgid_plural, n = 1, separator = '|')
         if msgid.is_a?(Array)
           msgid, msgid_plural, n, separator = msgid[0], msgid[1], msgid_plural, n
-          separator = '|' unless separator.is_a?(String)
+          separator = '|' unless separator.is_a?(::String)
         end
 
         scope, msgid = I18n::Gettext.extract_scope(msgid, separator)