i18n 0.4.1 → 0.4.2

data/CHANGELOG.textile

@@ -1,6 +1,14 @@
 h1. Changelog
 
-h2. master
+h2. 0.4.2 (2010-10-26)
+
+* "Improve UTF8 handling":http://github.com/svenfuchs/i18n/commit/e8d5820a3b08eeca28de1a2b9c8a6ad2b9e6476c
+* "Expose I18n::VERSION":http://github.com/svenfuchs/i18n/commit/b832037bac94c7144f45f3ff5e3b4e4089781726
+* "Better deprecation output":http://github.com/svenfuchs/i18n/commit/2bee924464b8a9c33d3d7852eb1c8423aa38cc25
+
+h2. 0.4.1 (2010-06-05)
+
+* "Fix interpolation failure on Ruby 1.9":http://github.com/svenfuchs/i18n/commit/8d45bedb11c4136c00e853d104b00a8e67ec4894
 
 h2. 0.4.0 (2010-05-27)
 

data/README.textile

@@ -29,12 +29,16 @@ Alternative backends:
 * ActiveRecord (optionally: ActiveRecord::Missing and ActiveRecord::StoreProcs)
 * KeyValue (uses active_support/json and cannot store procs)
 
-For more information and lots of resources see: "http://rails-i18n.org/wiki":http://rails-i18n.org/wiki
+For more information and lots of resources see: "http://ruby-i18n.org/wiki":http://ruby-i18n.org/wiki
 
 h2. Installation
 
 gem install i18n
 
+h4. Rails version warning
+
+On Rails < 2.3.6 the method I18n.localize will fail with MissingInterpolationArgument (issue "20":http://github.com/svenfuchs/i18n/issues/issue/20). Upgrade to Rails 2.3.6 or higher (2.3.8 preferably) is recommended.
+
 h3. Installation on Rails < 2.3.5 (deprecated)
 
 Up to version 2.3.4 Rails will not accept i18n gems > 0.1.3. There is an unpacked
@@ -43,6 +47,7 @@ This requirement is relaxed in "6da03653":http://github.com/rails/rails/commit/6
 
 The new i18n gem can be loaded from vendor/plugins like this:
 
+<pre>
   def reload_i18n!
     raise "Move to i18n version 0.2.0 or greater" if Rails.version > "2.3.4"
 
@@ -50,6 +55,7 @@ The new i18n gem can be loaded from vendor/plugins like this:
     I18n::Backend.send :remove_const, "Simple"
     $: << Rails.root.join('vendor', 'plugins', 'i18n', 'lib').to_s
   end
+</pre>
 
 Then you can `reload_i18n!` inside an i18n initializer.
 
@@ -61,6 +67,23 @@ You can run tests both with
 * run any test file directly, e.g. `ruby test/api/simple_test.rb`
 * run all tests with `ruby test/all.rb`
 
+You can parametrize the test suite for using different sets of dependencies by
+using:
+
+.pre `ruby test/all.rb -w DEPENDENCIES`
+
+... where DEPENDENCIES is a comma-separated list of:
+
+* r23 or rails-2.3.x
+* r3 or rails-3.x
+* no-rails
+* sqlite
+* mysql
+
+So, e.g. this would run the test suite against Rails 2.3.x using mysql:
+
+.pre `ruby test/all.rb -w r23,mysql`
+
 The structure of the test suite is a bit unusual as it uses modules to reuse
 particular tests in different test cases.
 

data/lib/i18n.rb

@@ -7,6 +7,7 @@
 #             Matt Aimonetti (http://railsontherun.com/)
 # Copyright:: Copyright (c) 2008 The Ruby i18n Team
 # License::   MIT
+require 'i18n/version'
 require 'i18n/exceptions'
 require 'i18n/core_ext/string/interpolate'
 
@@ -145,19 +146,27 @@ module I18n
     # always return the same translations/values per unique combination of argument
     # values.
     def translate(*args)
-      options = args.pop if args.last.is_a?(Hash)
+      options = args.last.is_a?(Hash) ? args.pop : {}
       key     = args.shift
-      locale  = options && options.delete(:locale) || config.locale
-      raises  = options && options.delete(:raise)
-      config.backend.translate(locale, key, options || {})
+      backend = config.backend
+      locale  = options.delete(:locale) || config.locale
+      raises  = options.delete(:raise)
+
+      raise I18n::ArgumentError if key.is_a?(String) && key.empty?
+
+      if key.is_a?(Array)
+        key.map { |k| backend.translate(locale, k, options) }
+      else
+        backend.translate(locale, key, options)
+      end
     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 ))
+    def translate!(key, options={})
+      translate(key, options.merge(:raise => true))
     end
     alias :t! :translate!
 

data/lib/i18n/backend/active_record/missing.rb

@@ -8,7 +8,7 @@
 #  Example usage:
 #
 #     I18n::Backend::Chain.send(:include, I18n::Backend::ActiveRecord::Missing)
-#     I18n.backend = I18nChainBackend.new(I18n::Backend::ActiveRecord.new, I18n::Backend::Simple.new)
+#     I18n.backend = I18n::Backend::Chain.new(I18n::Backend::ActiveRecord.new, I18n::Backend::Simple.new)
 #
 #  Stub records for pluralizations will also be created for each key defined
 #  in i18n.plural.keys.
@@ -33,16 +33,16 @@ module I18n
   module Backend
     class ActiveRecord
       module Missing
+        include Flatten
+
         def store_default_translations(locale, key, options = {})
-          count, scope, default, separator = options.values_at(:count, *Base::RESERVED_KEYS)
+          count, scope, default, separator = options.values_at(:count, :scope, :default, :separator)
           separator ||= I18n.default_separator
-
-          keys = I18n.normalize_keys(locale, key, scope, separator)[1..-1]
-          key = keys.join(separator || I18n.default_separator)
+          key = normalize_flat_keys(locale, key, scope, separator)
 
           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]
+            interpolations = options.keys - Base::RESERVED_KEYS
+            keys = count ? I18n.t('i18n.plural.keys', :locale => locale).map { |k| [key, k].join(FLATTEN_SEPARATOR) } : [key]
             keys.each { |key| store_default_translation(locale, key, interpolations) }
           end
         end

data/lib/i18n/backend/active_record/translation.rb

@@ -46,33 +46,36 @@ module I18n
     #   # => 'FOO'
     class ActiveRecord
       class Translation < ::ActiveRecord::Base
+        TRUTHY_CHAR = "\001"
+        FALSY_CHAR = "\002"
+
         set_table_name 'translations'
         attr_protected :is_proc, :interpolations
 
         serialize :value
         serialize :interpolations, Array
 
-        scope_method = ::ActiveRecord::VERSION::MAJOR == 2 ? :named_scope : :scope
+        class << self
+          def locale(locale)
+            scoped(:conditions => { :locale => locale.to_s })
+          end
 
-        send scope_method, :locale, lambda { |locale|
-          { :conditions => { :locale => locale.to_s } }
-        }
+          def lookup(keys, *separator)
+            column_name = connection.quote_column_name('key')
+            keys = Array(keys).map! { |key| key.to_s }
 
-        send scope_method, :lookup, lambda { |keys, *separator|
-          column_name = connection.quote_column_name('key')
-          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
 
-          unless separator.empty?
-            warn "[DEPRECATION] Giving a separator to Translation.lookup is deprecated. " <<
-              "You can change the internal separator by overwriting FLATTEN_SEPARATOR."
+            namespace = "#{keys.last}#{I18n::Backend::Flatten::FLATTEN_SEPARATOR}%"
+            scoped(:conditions => ["#{column_name} IN (?) OR #{column_name} LIKE ?", keys, namespace])
           end
 
-          namespace = "#{keys.last}#{I18n::Backend::Flatten::FLATTEN_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 }
+          def available_locales
+            Translation.find(:all, :select => 'DISTINCT locale').map { |t| t.locale.to_sym }
+          end
         end
 
         def interpolates?(key)
@@ -80,13 +83,27 @@ module I18n
         end
 
         def value
+          value = read_attribute(:value)
           if is_proc
-            Kernel.eval(read_attribute(:value))
+            Kernel.eval(value)
+          elsif value == FALSY_CHAR
+            false
+          elsif value == TRUTHY_CHAR
+            true
           else
-            value = read_attribute(:value)
-            value == 'f' ? false : value
+            value
           end
         end
+
+        def value=(value)
+          if value === false
+            value = FALSY_CHAR
+          elsif value === true
+            value = TRUTHY_CHAR
+          end
+
+          write_attribute(:value, value)
+        end
       end
     end
   end

data/lib/i18n/backend/base.rb

@@ -8,10 +8,9 @@ module I18n
     module Base
       include I18n::Backend::Transliterator
 
-      RESERVED_KEYS = [:scope, :default, :separator, :resolve]
+      RESERVED_KEYS = [:scope, :default, :separator, :resolve, :object, :fallback]
       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
@@ -29,8 +28,6 @@ module I18n
 
       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?
@@ -57,9 +54,10 @@ module I18n
         raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
 
         if Symbol === format
-          key = format
+          key  = format
           type = object.respond_to?(:sec) ? 'time' : 'date'
-          format = I18n.t(:"#{type}.formats.#{key}", options.merge(:raise => true, :object => object, :locale => locale))
+          options = options.merge(:raise => true, :object => object, :locale => locale)
+          format  = I18n.t(:"#{type}.formats.#{key}", options)
         end
 
         # format = resolve(locale, object, format, options)
@@ -113,14 +111,14 @@ module I18n
         # If the given subject is a Symbol, it will be translated with the
         # 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)
+        def resolve(locale, object, subject, options = {})
           return subject if options[:resolve] == false
           case subject
           when Symbol
-            I18n.translate(subject, (options || {}).merge(:locale => locale, :raise => true))
+            I18n.translate(subject, options.merge(:locale => locale, :raise => true))
           when Proc
             date_or_time = options.delete(:object) || object
-            resolve(locale, object, subject.call(date_or_time, options), options = {})
+            resolve(locale, object, subject.call(date_or_time, options))
           else
             subject
           end
@@ -151,50 +149,29 @@ module I18n
         # interpolation).
         def interpolate(locale, string, values = {})
           return string unless string.is_a?(::String) && !values.empty?
-          original_values = values.dup
-
-          preserve_encoding(string) do
-            string = string.gsub(DEPRECATED_INTERPOLATION_SYNTAX_PATTERN) do
-              escaped, key = $1, $2.to_sym
-              if escaped
-                "{{#{key}}}"
-              else
-                warn_syntax_deprecation!
-                "%{#{key}}"
-              end
-            end
 
-            keys = string.scan(INTERPOLATION_SYNTAX_PATTERN).flatten
-            return string if keys.empty?
-
-            values.each do |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
+          string = string.gsub(DEPRECATED_INTERPOLATION_SYNTAX_PATTERN) do
+            escaped, key = $1, $2.to_sym
+            if escaped
+              "{{#{key}}}"
+            else
+              warn_syntax_deprecation!(locale, string)
+              "%{#{key}}"
             end
+          end
 
-            string % values
+          values.each do |key, value|
+            value = value.call(values) if interpolate_lambda?(value, string, key)
+            value = value.to_s unless value.is_a?(::String)
+            values[key] = value
           end
+
+          string % values
         rescue KeyError => e
           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)
-          if string.respond_to?(:encoding)
-            encoding = string.encoding
-            result = yield
-            result.force_encoding(encoding) if result.respond_to?(:force_encoding)
-            result
-          else
-            yield
+            raise MissingInterpolationArgument.new(values, string)
           end
         end
 
@@ -210,9 +187,10 @@ module I18n
         # for all other file extensions.
         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.each { |locale, d| store_translations(locale, d) }
+          raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}", true)
+          data = send(:"load_#{type}", filename)
+          raise InvalidLocaleData.new(filename) unless data.is_a?(Hash)
+          data.each { |locale, d| store_translations(locale, d || {}) }
         end
 
         # Loads a plain Ruby translations file. eval'ing the file must yield
@@ -224,12 +202,12 @@ module I18n
         # Loads a YAML translations file. The data must have locales as
         # toplevel keys.
         def load_yml(filename)
-          YAML::load(IO.read(filename))
+          YAML.load_file(filename)
         end
 
-        def warn_syntax_deprecation! #:nodoc:
+        def warn_syntax_deprecation!(locale, string) #:nodoc:
           return if @skip_syntax_deprecation
-          warn "The {{key}} interpolation syntax in I18n messages is deprecated. Please use %{key} instead.\n#{caller.join("\n")}"
+          warn "The {{key}} interpolation syntax in I18n messages is deprecated. Please use %{key} instead.\n#{locale} - #{string}\n"
           @skip_syntax_deprecation = true
         end
     end

data/lib/i18n/backend/cache.rb

@@ -6,11 +6,11 @@
 # To enable caching you can simply include the Cache module to the Simple
 # backend - or whatever other backend you are using:
 #
-#  I18n::Backend::Simple.send(:include, I18n::Backend::Cache)
+#   I18n::Backend::Simple.send(:include, I18n::Backend::Cache)
 #
 # You will also need to set a cache store implementation that you want to use:
 #
-#  I18n.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+#   I18n.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
 #
 # You can use any cache implementation you want that provides the same API as
 # ActiveSupport::Cache (only the methods #fetch and #write are being used).
@@ -18,6 +18,23 @@
 # The cache_key implementation assumes that you only pass values to
 # I18n.translate that return a valid key from #hash (see
 # http://www.ruby-doc.org/core/classes/Object.html#M000337).
+#
+# If you use a lambda as a default value in your translation like this:
+#
+#   I18n.t(:"date.order", :default => lambda {[:month, :day, :year]})
+#
+# Then you will always have a cache miss, because each time this method
+# is called the lambda will have a different hash value. If you know
+# the result of the lambda is a constant as in the example above, then
+# to cache this you can make the lambda a constant, like this:
+#
+#   DEFAULT_DATE_ORDER = lambda {[:month, :day, :year]}
+#   ...
+#   I18n.t(:"date.order", :default => DEFAULT_DATE_ORDER)
+#
+# If the lambda may result in different values for each call then consider
+# also using the Memoize backend.
+#
 module I18n
   class << self
     @@cache_store = nil
@@ -47,31 +64,41 @@ module I18n
   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
+      def translate(locale, key, options = {})
+        I18n.perform_caching? ? fetch(cache_key(locale, key, options)) { super } : super
       end
 
       protected
 
-        def fetch(*args, &block)
-          result = I18n.cache_store.fetch(cache_key(*args), &block)
+        def fetch(cache_key, &block)
+          result = fetch_storing_missing_translation_exception(cache_key, &block)
           raise result if result.is_a?(Exception)
           result = result.dup if result.frozen? rescue result
           result
+        end
+
+        def fetch_storing_missing_translation_exception(cache_key, &block)
+          fetch_ignoring_procs(cache_key, &block)
         rescue MissingTranslationData => exception
-          I18n.cache_store.write(cache_key(*args), exception)
-          raise exception
+          I18n.cache_store.write(cache_key, exception)
+          exception
         end
 
-        def cache_key(*args)
+        def fetch_ignoring_procs(cache_key, &block)
+          I18n.cache_store.read(cache_key) || yield.tap do |result|
+            I18n.cache_store.write(cache_key, result) unless result.is_a?(Proc)
+          end
+        end
+
+        def cache_key(locale, key, options)
           # This assumes that only simple, native Ruby values are passed to I18n.translate.
-          # Also, in Ruby < 1.8.7 {}.hash != {}.hash
-          # (see http://paulbarry.com/articles/2009/09/14/why-rails-3-will-require-ruby-1-8-7)
-          # If args.inspect does not work for you for some reason, patches are very welcome :)
-          hash = RUBY_VERSION >= "1.8.7" ? args.hash : args.inspect
-          keys = ['i18n', I18n.cache_namespace, hash]
-          keys.compact.join('-')
+          "i18n/#{I18n.cache_namespace}/#{locale}/#{key.hash}/#{USE_INSPECT_HASH ? options.inspect.hash : options.hash}"
         end
+
+      private
+        # In Ruby < 1.9 the following is true: { :foo => 1, :bar => 2 }.hash == { :foo => 2, :bar => 1 }.hash
+        # Therefore we must use the hash of the inspect string instead to avoid cache key colisions.
+        USE_INSPECT_HASH = RUBY_VERSION <= "1.9"
     end
   end
-end
+end

data/lib/i18n/backend/chain.rb

@@ -17,61 +17,66 @@ 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
-      include Base
+      module Implementation
+        include Base
 
-      attr_accessor :backends
+        attr_accessor :backends
 
-      def initialize(*backends)
-        self.backends = backends
-      end
+        def initialize(*backends)
+          self.backends = backends
+        end
 
-      def reload!
-        backends.each { |backend| backend.reload! }
-      end
+        def reload!
+          backends.each { |backend| backend.reload! }
+        end
 
-      def store_translations(locale, data, options = {})
-        backends.first.store_translations(locale, data, options = {})
-      end
+        def store_translations(locale, data, options = {})
+          backends.first.store_translations(locale, data, options = {})
+        end
 
-      def available_locales
-        backends.map { |backend| backend.available_locales }.flatten.uniq
-      end
+        def available_locales
+          backends.map { |backend| backend.available_locales }.flatten.uniq
+        end
 
-      def translate(locale, key, options = {})
-        return key.map { |k| translate(locale, k, options) } if key.is_a?(Array)
+        def translate(locale, key, default_options = {})
+          namespace = nil
+          options = default_options.except(:default)
 
-        default = options.delete(:default)
-        namespace = {}
-        backends.each do |backend|
-          begin
-            options.update(:default => default) if default and backend == backends.last
-            translation = backend.translate(locale, key, options)
-            if namespace_lookup?(translation, options)
-              namespace.update(translation)
-            elsif !translation.nil?
-              return translation
+          backends.each do |backend|
+            begin
+              options = default_options if backend == backends.last
+              translation = backend.translate(locale, key, options)
+              if namespace_lookup?(translation, options)
+                namespace ||= {}
+                namespace.merge!(translation)
+              elsif !translation.nil?
+                return translation
+              end
+            rescue MissingTranslationData
             end
-          rescue MissingTranslationData
           end
+
+          return namespace if namespace
+          raise(I18n::MissingTranslationData.new(locale, key, options))
         end
-        return namespace unless namespace.empty?
-        raise(I18n::MissingTranslationData.new(locale, key, options))
-      end
 
-      def localize(locale, object, format = :default, options = {})
-        backends.each do |backend|
-          begin
-            result = backend.localize(locale, object, format, options) and return result
-          rescue MissingTranslationData
+        def localize(locale, object, format = :default, options = {})
+          backends.each do |backend|
+            begin
+              result = backend.localize(locale, object, format, options) and return result
+            rescue MissingTranslationData
+            end
           end
+          raise(I18n::MissingTranslationData.new(locale, format, options))
         end
-        raise(I18n::MissingTranslationData.new(locale, format, options))
+
+        protected
+          def namespace_lookup?(result, options)
+            result.is_a?(Hash) && !options.has_key?(:count)
+          end
       end
 
-      protected
-        def namespace_lookup?(result, options)
-          result.is_a?(Hash) and not options.has_key?(:count)
-        end
+      include Implementation
     end
   end
 end

data/lib/i18n/backend/fallbacks.rb

@@ -35,11 +35,13 @@ module I18n
       # usual.
       #
       # 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.
+      # only when it's a Symbol. When the default contains a String or a Proc
+      # it is evaluated last after all the fallback locales have been tried.
       def translate(locale, key, options = {})
-        default = extract_string_default!(options) if options[:default]
+        return super if options[:fallback]
+        default = extract_string_or_lambda_default!(options) if options[:default]
 
+        options[:fallback] = true
         I18n.fallbacks[locale].each do |fallback|
           begin
             result = super(fallback, key, options)
@@ -47,21 +49,22 @@ module I18n
           rescue I18n::MissingTranslationData
           end
         end
+        options.delete(:fallback)
 
         return super(locale, nil, options.merge(:default => default)) if default
         raise(I18n::MissingTranslationData.new(locale, key, options))
       end
 
-      def extract_string_default!(options)
+      def extract_string_or_lambda_default!(options)
         defaults = Array(options[:default])
-        if index = find_first_string_default(defaults)
+        if index = find_first_string_or_lambda_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] }
+      def find_first_string_or_lambda_default(defaults)
+        defaults.each_with_index { |default, ix| return ix if String === default || Proc === default }
         nil
       end
     end

data/lib/i18n/backend/gettext.rb

@@ -49,9 +49,7 @@ module I18n
                 normalized = { part => normalized.empty? ? value : normalized }
               end
 
-              # 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 }
-              result.merge!(normalized, &merger)
+              result.deep_merge!(normalized)
             end
             result
           end

data/lib/i18n/backend/simple.rb

@@ -71,11 +71,11 @@ module I18n
           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)
+          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

data/lib/i18n/config.rb

@@ -32,15 +32,17 @@ module I18n
     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.
+    # Unless you explicitely set these through I18n.available_locales=
+    # the call will be delegated to the backend.
     def available_locales
-      @@available_locales ||= backend.available_locales
+      @@available_locales ||= nil
+      @@available_locales || backend.available_locales
     end
 
     # Sets the available locales.
     def available_locales=(locales)
-      @@available_locales = locales
+      @@available_locales = Array(locales).map {|locale| locale.to_sym}
+      @@available_locales = nil if @@available_locales.empty?
     end
 
     # Returns the current default scope separator. Defaults to '.'

data/lib/i18n/exceptions.rb

@@ -17,10 +17,20 @@ module I18n
     end
   end
 
+  class InvalidLocaleData < ArgumentError
+    attr_reader :filename
+    def initialize(filename)
+      @filename = filename
+      super "can not load translations from #{filename}, expected it to return a hash, but does not"
+    end
+  end
+
   class MissingTranslationData < ArgumentError
     attr_reader :locale, :key, :options
     def initialize(locale, key, opts = nil)
-      @key, @locale, @options = key, locale, opts || {}
+      @key, @locale, @options = key, locale, opts.dup || {}
+      options.each { |k, v| options[k] = v.inspect if v.is_a?(Proc) }
+
       keys = I18n.normalize_keys(locale, key, options[:scope])
       keys << 'no key' if keys.size < 2
       super "translation missing: #{keys.join(', ')}"

data/lib/i18n/gettext/helpers.rb

@@ -6,7 +6,7 @@ module I18n
     # Implements classical Gettext style accessors. To use this include the
     # module to the global namespace or wherever you want to use it.
     #
-    #   include I18n::Helpers::Gettext
+    #   include I18n::Gettext::Helpers
     module Helpers
       def gettext(msgid, options = {})
         I18n.t(msgid, { :default => msgid, :separator => '|' }.merge(options))

data/lib/i18n/version.rb

@@ -1,3 +1,3 @@
 module I18n
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: i18n
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: false
   segments: 
   - 0
   - 4
-  - 1
-  version: 0.4.1
+  - 2
+  version: 0.4.2
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-05 00:00:00 +02:00
+date: 2010-10-26 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -93,12 +93,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 23
+      hash: 17
       segments: 
       - 1
       - 3
-      - 6
-      version: 1.3.6
+      - 5
+      version: 1.3.5
 requirements: []
 
 rubyforge_project: "[none]"