activesupport 2.3.6.pre → 2.3.6

data/lib/active_support/vendor.rb

@@ -23,7 +23,7 @@ end
 begin
   gem 'i18n', '>= 0.3.3'
 rescue Gem::LoadError
-  $:.unshift "#{File.dirname(__FILE__)}/vendor/i18n-0.3.3/lib"
+  $:.unshift "#{File.dirname(__FILE__)}/vendor/i18n-0.3.7"
 end
 require 'i18n'
 

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

@@ -15,13 +15,18 @@ module I18n
   autoload :Helpers, 'i18n/helpers'
   autoload :Locale,  'i18n/locale'
 
-  @@backend = nil
-  @@load_path = nil
-  @@default_locale = :en
-  @@default_separator = '.'
-  @@exception_handler = :default_exception_handler
+  class Config
+    # The only configuration value that is not global and scoped to thread is :locale.
+    # It defaults to the default_locale.
+    def locale
+      @locale ||= default_locale
+    end
+
+    # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
+    def locale=(locale)
+      @locale = locale.to_sym rescue nil
+    end
 
-  class << self
     # Returns the current backend. Defaults to +Backend::Simple+.
     def backend
       @@backend ||= Backend::Simple.new
@@ -34,7 +39,7 @@ module I18n
 
     # Returns the current default locale. Defaults to :'en'
     def default_locale
-      @@default_locale
+      @@default_locale ||= :en
     end
 
     # Sets the current default locale. Used to set a custom default locale.
@@ -42,16 +47,6 @@ module I18n
       @@default_locale = locale.to_sym rescue nil
     end
 
-    # Returns the current locale. Defaults to I18n.default_locale.
-    def locale
-      Thread.current[:locale] ||= default_locale
-    end
-
-    # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
-    def locale=(locale)
-      Thread.current[:locale] = locale.to_sym rescue nil
-    end
-
     # Returns an array of locales for which translations are available.
     # Unless you explicitely set the these through I18n.available_locales=
     # the call will be delegated to the backend and memoized on the I18n module.
@@ -66,7 +61,7 @@ module I18n
 
     # Returns the current default scope separator. Defaults to '.'
     def default_separator
-      @@default_separator
+      @@default_separator ||= '.'
     end
 
     # Sets the current default scope separator.
@@ -74,6 +69,11 @@ module I18n
       @@default_separator = separator
     end
 
+    # Return the current exception handler. Defaults to :default_exception_handler.
+    def exception_handler
+      @@exception_handler ||= :default_exception_handler
+    end
+
     # Sets the exception handler.
     def exception_handler=(exception_handler)
       @@exception_handler = exception_handler
@@ -96,12 +96,39 @@ module I18n
     def load_path=(load_path)
       @@load_path = load_path
     end
+  end
+
+  class << self
+
+    # Gets I18n configuration object.
+    def config
+      Thread.current[:i18n_config] ||= I18n::Config.new
+    end
+
+    # Sets I18n configuration object.
+    def config=(value)
+      Thread.current[:i18n_config] = value
+    end
+
+    # Write methods which delegates to the configuration object
+    %w(locale backend default_locale available_locales default_separator
+      exception_handler load_path).each do |method|
+      module_eval <<-DELEGATORS, __FILE__, __LINE__ + 1
+        def #{method}
+          config.#{method}
+        end
+
+        def #{method}=(value)
+          config.#{method} = (value)
+        end
+      DELEGATORS
+    end
 
     # Tells the backend to reload translations. Used in situations like the
     # Rails development environment. Backends can implement whatever strategy
     # is useful.
     def reload!
-      backend.reload!
+      config.backend.reload!
     end
 
     # Translates, pluralizes and interpolates a given key using a given locale,
@@ -203,9 +230,9 @@ module I18n
     def translate(*args)
       options = args.pop if args.last.is_a?(Hash)
       key     = args.shift
-      locale  = options && options.delete(:locale) || I18n.locale
+      locale  = options && options.delete(:locale) || config.locale
       raises  = options && options.delete(:raise)
-      backend.translate(locale, key, options || {})
+      config.backend.translate(locale, key, options || {})
     rescue I18n::ArgumentError => exception
       raise exception if raises
       handle_exception(exception, locale, key, options)
@@ -219,12 +246,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) || config.locale
+      format = options.delete(:format) || :default
+      config.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)
+      separator ||= I18n.default_separator
+      normalize_key(locale, separator) +
+        normalize_key(scope, separator) +
+        normalize_key(key, separator)
+    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
@@ -256,22 +293,43 @@ module I18n
     #  I18n.exception_handler = I18nExceptionHandler.new                # an object
     #  I18n.exception_handler.call(exception, locale, key, options)     # will be called like this
     def handle_exception(exception, locale, key, options)
-      case @@exception_handler
+      case config.exception_handler
       when Symbol
-        send(@@exception_handler, exception, locale, key, options)
+        send(config.exception_handler, exception, locale, key, options)
       else
-        @@exception_handler.call(exception, locale, key, options)
+        config.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.
+    # Deprecated. Will raise a warning in future versions and then finally be
+    # removed. Use I18n.normalize_keys instead.
     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 }
+      normalize_keys(locale, key, scope, separator)
+    end
+
+    def normalize_key(key, separator)
+      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
+        end
+    end
+
+    def normalized_key_cache(separator)
+      @normalized_key_cache ||= Hash.new { |h,k| h[k] = {} }
+      @normalized_key_cache[separator]
     end
   end
 end

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

@@ -23,15 +23,15 @@ 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
 
-        Translation.send(:include, self) unless RUBY_VERSION >= '1.9'
+        Translation.send(:include, self) if method(:to_s).respond_to?(:to_ruby)
       end
     end
   end

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

@@ -10,7 +10,8 @@ module I18n
     #   create_table :translations do |t|
     #     t.string :locale
     #     t.string :key
-    #     t.string :value
+    #     t.text   :value
+    #     t.text   :interpolations
     #     t.boolean :is_proc, :default => false
     #   end
     #
@@ -47,31 +48,35 @@ module I18n
       class Translation < ::ActiveRecord::Base
         set_table_name 'translations'
         attr_protected :is_proc, :interpolations
-        
+
         serialize :value
         serialize :interpolations, Array
 
-        named_scope :locale, lambda { |locale|
+        scope_method = ::ActiveRecord::VERSION::MAJOR == 2 ? :named_scope : :scope
+
+        send scope_method, :locale, lambda { |locale|
           { :conditions => { :locale => locale.to_s } }
         }
 
-        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] }
+        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}%"
+          { :conditions => ["#{column_name} IN (?) OR #{column_name} LIKE ?", keys, namespace] }
         }
 
         def self.available_locales
           Translation.find(:all, :select => 'DISTINCT locale').map { |t| t.locale.to_sym }
         end
-        
+
         def interpolates?(key)
           self.interpolations.include?(key) if self.interpolations
         end
 
         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/active_support/vendor/{i18n-0.3.3/lib → i18n-0.3.7}/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,11 +57,10 @@ 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)
+        # format = resolve(locale, object, format, options)
         format = format.to_s.gsub(/%[aAbBp]/) do |match|
           case match
           when '%a' then I18n.t(:"date.abbr_day_names",                  :locale => locale, :format => format)[object.wday]
@@ -108,16 +108,16 @@ 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
+            result = resolve(locale, key, result, options) if result.is_a?(Symbol)
+            String === result ? result.dup : 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