radiant 0.9.0.rc2 → 0.9.1

data/vendor/rails/activesupport/lib/active_support/json/decoding.rb

@@ -5,12 +5,15 @@ module ActiveSupport
   mattr_accessor :parse_json_times
 
   module JSON
+    # Listed in order of preference.
+    DECODERS = %w(Yajl Yaml)
+
     class << self
       attr_reader :parse_error
       delegate :decode, :to => :backend
 
       def backend
-        self.backend = "Yaml" unless defined?(@backend)
+        set_default_backend unless defined?(@backend)
         @backend
       end
 
@@ -30,6 +33,18 @@ module ActiveSupport
       ensure
         self.backend = old_backend
       end
+
+      def set_default_backend
+        DECODERS.find do |name|
+          begin
+            self.backend = name
+            true
+          rescue LoadError
+            # Try next decoder.
+            false
+          end
+        end
+      end
     end
   end
 end

data/vendor/rails/activesupport/lib/active_support/json/encoding.rb

@@ -22,6 +22,15 @@ module ActiveSupport
       end
 
       ESCAPED_CHARS = {
+        "\x00" => '\u0000', "\x01" => '\u0001', "\x02" => '\u0002',
+        "\x03" => '\u0003', "\x04" => '\u0004', "\x05" => '\u0005',
+        "\x06" => '\u0006', "\x07" => '\u0007', "\x0B" => '\u000B',
+        "\x0E" => '\u000E', "\x0F" => '\u000F', "\x10" => '\u0010',
+        "\x11" => '\u0011', "\x12" => '\u0012', "\x13" => '\u0013',
+        "\x14" => '\u0014', "\x15" => '\u0015', "\x16" => '\u0016',
+        "\x17" => '\u0017', "\x18" => '\u0018', "\x19" => '\u0019',
+        "\x1A" => '\u001A', "\x1B" => '\u001B', "\x1C" => '\u001C',
+        "\x1D" => '\u001D', "\x1E" => '\u001E', "\x1F" => '\u001F',
         "\010" =>  '\b',
         "\f"   =>  '\f',
         "\n"   =>  '\n',
@@ -43,9 +52,9 @@ module ActiveSupport
         def escape_html_entities_in_json=(value)
           self.escape_regex = \
             if @escape_html_entities_in_json = value
-              /[\010\f\n\r\t"\\><&]/
+              /[\x00-\x1F"\\><&]/
             else
-              /[\010\f\n\r\t"\\]/
+              /[\x00-\x1F"\\]/
             end
         end
 

data/vendor/rails/activesupport/lib/active_support/memoizable.rb

@@ -58,7 +58,7 @@ module ActiveSupport
         original_method = :"_unmemoized_#{symbol}"
         memoized_ivar = ActiveSupport::Memoizable.memoized_ivar_for(symbol)
 
-        class_eval <<-EOS, __FILE__, __LINE__
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
           include InstanceMethods                                                  # include InstanceMethods
                                                                                    #
           if method_defined?(:#{original_method})                                  # if method_defined?(:_unmemoized_mime_type)

data/vendor/rails/activesupport/lib/active_support/multibyte/unicode_database.rb

@@ -23,7 +23,7 @@ module ActiveSupport #:nodoc:
 
       # Lazy load the Unicode database so it's only loaded when it's actually used
       ATTRIBUTES.each do |attr_name|
-        class_eval(<<-EOS, __FILE__, __LINE__)
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def #{attr_name}  # def codepoints
             load            #   load
             @#{attr_name}   #   @codepoints
@@ -68,4 +68,4 @@ module ActiveSupport #:nodoc:
     # UniCode Database
     UCD = UnicodeDatabase.new
   end
-end
+end

data/vendor/rails/activesupport/lib/active_support/multibyte/utils.rb

@@ -26,11 +26,11 @@ module ActiveSupport #:nodoc:
     else
       def self.verify(string)
         if expression = valid_character
-          for c in string.split(//)
-            return false unless expression.match(c)
-          end
+          # Splits the string on character boundaries, which are determined based on $KCODE.
+          string.split(//).all? { |c| expression =~ c }
+        else
+          true
         end
-        true
       end
     end
 
@@ -49,9 +49,8 @@ module ActiveSupport #:nodoc:
     else
       def self.clean(string)
         if expression = valid_character
-          stripped = []; for c in string.split(//)
-            stripped << c if expression.match(c)
-          end; stripped.join
+          # Splits the string on character boundaries, which are determined based on $KCODE.
+          string.split(//).grep(expression).join
         else
           string
         end

data/vendor/rails/activesupport/lib/active_support/ordered_hash.rb

@@ -1,10 +1,28 @@
+require 'yaml'
+
+YAML.add_builtin_type("omap") do |type, val|
+  ActiveSupport::OrderedHash[val.map(&:to_a).map(&:first)]
+end
+
 # OrderedHash is namespaced to prevent conflicts with other implementations
 module ActiveSupport
-  # Hash is ordered in Ruby 1.9!
-  if RUBY_VERSION >= '1.9'
-    OrderedHash = ::Hash
-  else
-    class OrderedHash < Hash #:nodoc:
+  class OrderedHash < ::Hash #:nodoc:
+    def to_yaml_type
+      "!tag:yaml.org,2002:omap"
+    end
+
+    def to_yaml(opts = {})
+      YAML.quick_emit(self, opts) do |out|
+        out.seq(taguri, to_yaml_style) do |seq|
+          each do |k, v|
+            seq.add(k => v)
+          end
+        end
+      end
+    end
+
+    # Hash is ordered in Ruby 1.9!
+    if RUBY_VERSION < '1.9'
       def initialize(*args, &block)
         super
         @keys = []
@@ -52,7 +70,7 @@ module ActiveSupport
         end
         super
       end
-      
+
       def delete_if
         super
         sync_keys!
@@ -131,11 +149,10 @@ module ActiveSupport
         "#<OrderedHash #{super}>"
       end
 
-    private
-
-      def sync_keys!
-        @keys.delete_if {|k| !has_key?(k)}
-      end
+      private
+        def sync_keys!
+          @keys.delete_if {|k| !has_key?(k)}
+        end
     end
   end
 end

data/vendor/rails/activesupport/lib/active_support/testing/assertions.rb

@@ -60,6 +60,20 @@ module ActiveSupport
       def assert_no_difference(expression, message = nil, &block)
         assert_difference expression, 0, message, &block
       end
+      
+      # Test if an expression is blank. Passes if object.blank? is true.
+      #
+      #   assert_blank [] # => true
+      def assert_blank(object)
+        assert object.blank?, "#{object.inspect} is not blank"
+      end
+      
+      # Test if an expression is not blank. Passes if object.present? is true.
+      #
+      #   assert_present {:data => 'x' } # => true
+      def assert_present(object)
+        assert object.present?, "#{object.inspect} is blank"
+      end
     end
   end
 end

data/vendor/rails/activesupport/lib/active_support/values/time_zone.rb

@@ -172,19 +172,26 @@ module ActiveSupport
 
     include Comparable
     attr_reader :name
+    attr_reader :tzinfo
 
     # Create a new TimeZone object with the given name and offset. The
     # offset is the number of seconds that this time zone is offset from UTC
     # (GMT). Seconds were chosen as the offset unit because that is the unit that
     # Ruby uses to represent time zone offsets (see Time#utc_offset).
-    def initialize(name, utc_offset, tzinfo = nil)
+    def initialize(name, utc_offset = nil, tzinfo = nil)
       @name = name
       @utc_offset = utc_offset
-      @tzinfo = tzinfo
+      @tzinfo = tzinfo || TimeZone.find_tzinfo(name)
+      @current_period = nil
     end
 
     def utc_offset
-      @utc_offset ||= tzinfo.current_period.utc_offset
+      if @utc_offset
+        @utc_offset
+      else
+        @current_period ||= tzinfo.current_period
+        @current_period.utc_offset
+      end
     end
 
     # Returns the offset of this time zone as a formatted string, of the
@@ -287,77 +294,11 @@ module ActiveSupport
     end
 
     # TODO: Preload instead of lazy load for thread safety
-    def tzinfo
+    def self.find_tzinfo(name)
       require 'tzinfo' unless defined?(TZInfo)
-      @tzinfo ||= TZInfo::Timezone.get(MAPPING[name])
-    end
-
-    unless const_defined?(:ZONES)
-      ZONES = []
-      ZONES_MAP = {}
-      [[-39_600, "International Date Line West", "Midway Island", "Samoa" ],
-       [-36_000, "Hawaii" ],
-       [-32_400, "Alaska" ],
-       [-28_800, "Pacific Time (US & Canada)", "Tijuana" ],
-       [-25_200, "Mountain Time (US & Canada)", "Chihuahua", "Mazatlan",
-                 "Arizona" ],
-       [-21_600, "Central Time (US & Canada)", "Saskatchewan", "Guadalajara",
-                 "Mexico City", "Monterrey", "Central America" ],
-       [-18_000, "Eastern Time (US & Canada)", "Indiana (East)", "Bogota",
-                 "Lima", "Quito" ],
-       [-16_200, "Caracas" ],
-       [-14_400, "Atlantic Time (Canada)", "La Paz", "Santiago" ],
-       [-12_600, "Newfoundland" ],
-       [-10_800, "Brasilia", "Buenos Aires", "Georgetown", "Greenland" ],
-       [ -7_200, "Mid-Atlantic" ],
-       [ -3_600, "Azores", "Cape Verde Is." ],
-       [      0, "Dublin", "Edinburgh", "Lisbon", "London", "Casablanca",
-                 "Monrovia", "UTC" ],
-       [  3_600, "Belgrade", "Bratislava", "Budapest", "Ljubljana", "Prague",
-                 "Sarajevo", "Skopje", "Warsaw", "Zagreb", "Brussels",
-                 "Copenhagen", "Madrid", "Paris", "Amsterdam", "Berlin",
-                 "Bern", "Rome", "Stockholm", "Vienna",
-                 "West Central Africa" ],
-       [  7_200, "Bucharest", "Cairo", "Helsinki", "Kyev", "Riga", "Sofia",
-                 "Tallinn", "Vilnius", "Athens", "Istanbul", "Minsk",
-                 "Jerusalem", "Harare", "Pretoria" ],
-       [ 10_800, "Moscow", "St. Petersburg", "Volgograd", "Kuwait", "Riyadh",
-                 "Nairobi", "Baghdad" ],
-       [ 12_600, "Tehran" ],
-       [ 14_400, "Abu Dhabi", "Muscat", "Baku", "Tbilisi", "Yerevan" ],
-       [ 16_200, "Kabul" ],
-       [ 18_000, "Ekaterinburg", "Islamabad", "Karachi", "Tashkent" ],
-       [ 19_800, "Chennai", "Kolkata", "Mumbai", "New Delhi", "Sri Jayawardenepura" ],
-       [ 20_700, "Kathmandu" ],
-       [ 21_600, "Astana", "Dhaka", "Almaty",
-                 "Novosibirsk" ],
-       [ 23_400, "Rangoon" ],
-       [ 25_200, "Bangkok", "Hanoi", "Jakarta", "Krasnoyarsk" ],
-       [ 28_800, "Beijing", "Chongqing", "Hong Kong", "Urumqi",
-                 "Kuala Lumpur", "Singapore", "Taipei", "Perth", "Irkutsk",
-                 "Ulaan Bataar" ],
-       [ 32_400, "Seoul", "Osaka", "Sapporo", "Tokyo", "Yakutsk" ],
-       [ 34_200, "Darwin", "Adelaide" ],
-       [ 36_000, "Canberra", "Melbourne", "Sydney", "Brisbane", "Hobart",
-                 "Vladivostok", "Guam", "Port Moresby" ],
-       [ 39_600, "Magadan", "Solomon Is.", "New Caledonia" ],
-       [ 43_200, "Fiji", "Kamchatka", "Marshall Is.", "Auckland",
-                 "Wellington" ],
-       [ 46_800, "Nuku'alofa" ]].
-      each do |offset, *places|
-        places.each do |place|
-          place.freeze
-          zone = new(place, offset)
-          ZONES << zone
-          ZONES_MAP[place] = zone
-        end
-      end
-      ZONES.sort!
-      ZONES.freeze
-      ZONES_MAP.freeze
-
-      US_ZONES = ZONES.find_all { |z| z.name =~ /US|Arizona|Indiana|Hawaii|Alaska/ }
-      US_ZONES.freeze
+      ::TZInfo::Timezone.get(MAPPING[name] || name)
+    rescue TZInfo::InvalidTimezoneIdentifier
+      nil
     end
 
     class << self
@@ -374,7 +315,68 @@ module ActiveSupport
       # TimeZone objects per time zone, in many cases, to make it easier
       # for users to find their own time zone.
       def all
-        ZONES
+        @zones ||= zones_map.values.sort
+      end
+
+      def zones_map
+        unless defined?(@zones_map)
+          @zones_map = {}
+          [[-39_600, "International Date Line West", "Midway Island", "Samoa" ],
+           [-36_000, "Hawaii" ],
+           [-32_400, "Alaska" ],
+           [-28_800, "Pacific Time (US & Canada)", "Tijuana" ],
+           [-25_200, "Mountain Time (US & Canada)", "Chihuahua", "Mazatlan",
+                     "Arizona" ],
+           [-21_600, "Central Time (US & Canada)", "Saskatchewan", "Guadalajara",
+                     "Mexico City", "Monterrey", "Central America" ],
+           [-18_000, "Eastern Time (US & Canada)", "Indiana (East)", "Bogota",
+                     "Lima", "Quito" ],
+           [-16_200, "Caracas" ],
+           [-14_400, "Atlantic Time (Canada)", "La Paz", "Santiago" ],
+           [-12_600, "Newfoundland" ],
+           [-10_800, "Brasilia", "Buenos Aires", "Georgetown", "Greenland" ],
+           [ -7_200, "Mid-Atlantic" ],
+           [ -3_600, "Azores", "Cape Verde Is." ],
+           [      0, "Dublin", "Edinburgh", "Lisbon", "London", "Casablanca",
+                     "Monrovia", "UTC" ],
+           [  3_600, "Belgrade", "Bratislava", "Budapest", "Ljubljana", "Prague",
+                     "Sarajevo", "Skopje", "Warsaw", "Zagreb", "Brussels",
+                     "Copenhagen", "Madrid", "Paris", "Amsterdam", "Berlin",
+                     "Bern", "Rome", "Stockholm", "Vienna",
+                     "West Central Africa" ],
+           [  7_200, "Bucharest", "Cairo", "Helsinki", "Kyev", "Riga", "Sofia",
+                     "Tallinn", "Vilnius", "Athens", "Istanbul", "Minsk",
+                     "Jerusalem", "Harare", "Pretoria" ],
+           [ 10_800, "Moscow", "St. Petersburg", "Volgograd", "Kuwait", "Riyadh",
+                     "Nairobi", "Baghdad" ],
+           [ 12_600, "Tehran" ],
+           [ 14_400, "Abu Dhabi", "Muscat", "Baku", "Tbilisi", "Yerevan" ],
+           [ 16_200, "Kabul" ],
+           [ 18_000, "Ekaterinburg", "Islamabad", "Karachi", "Tashkent" ],
+           [ 19_800, "Chennai", "Kolkata", "Mumbai", "New Delhi", "Sri Jayawardenepura" ],
+           [ 20_700, "Kathmandu" ],
+           [ 21_600, "Astana", "Dhaka", "Almaty",
+                     "Novosibirsk" ],
+           [ 23_400, "Rangoon" ],
+           [ 25_200, "Bangkok", "Hanoi", "Jakarta", "Krasnoyarsk" ],
+           [ 28_800, "Beijing", "Chongqing", "Hong Kong", "Urumqi",
+                     "Kuala Lumpur", "Singapore", "Taipei", "Perth", "Irkutsk",
+                     "Ulaan Bataar" ],
+           [ 32_400, "Seoul", "Osaka", "Sapporo", "Tokyo", "Yakutsk" ],
+           [ 34_200, "Darwin", "Adelaide" ],
+           [ 36_000, "Canberra", "Melbourne", "Sydney", "Brisbane", "Hobart",
+                     "Vladivostok", "Guam", "Port Moresby" ],
+           [ 39_600, "Magadan", "Solomon Is.", "New Caledonia" ],
+           [ 43_200, "Fiji", "Kamchatka", "Marshall Is.", "Auckland",
+                     "Wellington" ],
+           [ 46_800, "Nuku'alofa" ]].
+           each do |offset, *places|
+             places.each do |place|
+               @zones_map[place] = create(place, offset)
+             end
+           end
+        end
+        @zones_map
       end
 
       # Locate a specific time zone object. If the argument is a string, it
@@ -385,7 +387,7 @@ module ActiveSupport
       def [](arg)
         case arg
           when String
-            ZONES_MAP[arg]
+            zones_map[arg] ||= lookup(arg)
           when Numeric, ActiveSupport::Duration
             arg *= 3600 if arg.abs <= 13
             all.find { |z| z.utc_offset == arg.to_i }
@@ -397,8 +399,14 @@ module ActiveSupport
       # A convenience method for returning a collection of TimeZone objects
       # for time zones in the USA.
       def us_zones
-        US_ZONES
+        @us_zones ||= all.find_all { |z| z.name =~ /US|Arizona|Indiana|Hawaii|Alaska/ }
       end
+      
+      private
+
+        def lookup(name)
+          (tzinfo = find_tzinfo(name)) && create(tzinfo.name.freeze)
+        end
     end
   end
 end

data/vendor/rails/activesupport/lib/active_support/vendor.rb

@@ -21,8 +21,16 @@ rescue Gem::LoadError
 end
 
 begin
-  gem 'i18n', '>= 0.1.3'
+  gem 'i18n', '>= 0.3.3'
 rescue Gem::LoadError
-  $:.unshift "#{File.dirname(__FILE__)}/vendor/i18n-0.1.3/lib"
+  $:.unshift "#{File.dirname(__FILE__)}/vendor/i18n-0.3.7"
 end
 require 'i18n'
+
+module I18n
+  if !respond_to?(:normalize_translation_keys) && respond_to?(:normalize_keys)
+    def self.normalize_translation_keys(*args)
+      normalize_keys(*args)
+    end
+  end
+end

data/vendor/rails/activesupport/lib/active_support/vendor/{i18n-0.1.3/lib → i18n-0.3.7}/i18n.rb

@@ -1,20 +1,32 @@
-# Authors::   Matt Aimonetti (http://railsontherun.com/),
-#             Sven Fuchs (http://www.artweb-design.de),
+# encoding: utf-8
+
+# Authors::   Sven Fuchs (http://www.artweb-design.de),
 #             Joshua Harvey (http://www.workingwithrails.com/person/759-joshua-harvey),
+#             Stephan Soller (http://www.arkanis-development.de/),
 #             Saimon Moore (http://saimonmoore.net),
-#             Stephan Soller (http://www.arkanis-development.de/)
+#             Matt Aimonetti (http://railsontherun.com/)
 # Copyright:: Copyright (c) 2008 The Ruby i18n Team
 # License::   MIT
-require 'i18n/backend/simple'
 require 'i18n/exceptions'
+require 'i18n/core_ext/string/interpolate'
 
 module I18n
-  @@backend = nil
-  @@load_path = nil
-  @@default_locale = :'en'
-  @@exception_handler = :default_exception_handler
+  autoload :Backend, 'i18n/backend'
+  autoload :Helpers, 'i18n/helpers'
+  autoload :Locale,  'i18n/locale'
+
+  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
@@ -27,27 +39,39 @@ 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.
     def default_locale=(locale)
-      @@default_locale = locale
+      @@default_locale = locale.to_sym rescue nil
     end
 
-    # Returns the current locale. Defaults to I18n.default_locale.
-    def locale
-      Thread.current[:locale] ||= default_locale
+    # 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.
+    def available_locales
+      @@available_locales ||= backend.available_locales
     end
 
-    # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
-    def locale=(locale)
-      Thread.current[:locale] = locale
+    # Sets the available locales.
+    def available_locales=(locales)
+      @@available_locales = locales
     end
 
-    # Returns an array of locales for which translations are available
-    def available_locales
-      backend.available_locales
+    # Returns the current default scope separator. Defaults to '.'
+    def default_separator
+      @@default_separator ||= '.'
+    end
+
+    # Sets the current default scope separator.
+    def default_separator=(separator)
+      @@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.
@@ -72,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,
@@ -150,7 +201,7 @@ module I18n
     # or <tt>default</tt> if no translations for <tt>:foo</tt> and <tt>:bar</tt> were found.
     #   I18n.t :foo, :default => [:bar, 'default']
     #
-    # <b>BULK LOOKUP</b>
+    # *BULK LOOKUP*
     #
     # This returns an array with the translations for <tt>:foo</tt> and <tt>:bar</tt>.
     #   I18n.t [:foo, :bar]
@@ -160,24 +211,61 @@ module I18n
     #
     # Which is the same as using a scope option:
     #   I18n.t [:foo, :bar], :scope => :baz
-    def translate(key, options = {})
-      locale = options.delete(:locale) || I18n.locale
-      backend.translate(locale, key, options)
-    rescue I18n::ArgumentError => e
-      raise e if options[:raise]
-      send(@@exception_handler, e, locale, key, options)
+    #
+    # *LAMBDAS*
+    #
+    # Both translations and defaults can be given as Ruby lambdas. Lambdas will be
+    # called and passed the key and options.
+    #
+    # E.g. assuming the key <tt>:salutation</tt> resolves to:
+    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. {{options[:name]}}" : "Mrs. {{options[:name]}}" }
+    #
+    # Then <tt>I18n.t(:salutation, :gender => 'w', :name => 'Smith') will result in "Mrs. Smith".
+    #
+    # It is recommended to use/implement lambdas in an "idempotent" way. E.g. when
+    # a cache layer is put in front of I18n.translate it will generate a cache key
+    # from the argument values passed to #translate. Therefor your lambdas should
+    # always return the same translations/values per unique combination of argument
+    # values.
+    def translate(*args)
+      options = args.pop if args.last.is_a?(Hash)
+      key     = args.shift
+      locale  = options && options.delete(:locale) || config.locale
+      raises  = options && options.delete(:raise)
+      config.backend.translate(locale, key, options || {})
+    rescue I18n::ArgumentError => exception
+      raise exception if raises
+      handle_exception(exception, locale, key, options)
     end
     alias :t :translate
 
+    def translate!(key, options = {})
+      translate(key, options.merge( :raise => true ))
+    end
+    alias :t! :translate!
+
     # 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
 
-  protected
+    # 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
+
     # Handles exceptions raised in the backend. All exceptions except for
     # MissingTranslationData exceptions are re-raised. When a MissingTranslationData
     # was caught and the option :raise is not set the handler returns an error
@@ -187,13 +275,61 @@ module I18n
       raise exception
     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)
-      keys = [locale] + Array(scope) + [key]
-      keys = keys.map { |k| k.to_s.split(/\./) }
-      keys.flatten.map { |k| k.to_sym }
+    # Any exceptions thrown in translate will be sent to the @@exception_handler
+    # which can be a Symbol, a Proc or any other Object.
+    #
+    # If exception_handler is a Symbol then it will simply be sent to I18n as
+    # a method call. A Proc will simply be called. In any other case the
+    # method #call will be called on the exception_handler object.
+    #
+    # Examples:
+    #
+    #   I18n.exception_handler = :default_exception_handler             # this is the default
+    #   I18n.default_exception_handler(exception, locale, key, options) # will be called like this
+    #
+    #   I18n.exception_handler = lambda { |*args| ... }                 # a lambda
+    #   I18n.exception_handler.call(exception, locale, key, options)    # will be called like this
+    #
+    #  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 config.exception_handler
+      when Symbol
+        send(config.exception_handler, exception, locale, key, options)
+      else
+        config.exception_handler.call(exception, locale, key, options)
+      end
+    end
+
+    # 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)
+      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