i18n 0.3.1 → 0.3.2

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.2

data/lib/i18n.rb

@@ -203,7 +203,7 @@ module I18n
     def translate(*args)
       options = args.last.is_a?(Hash) ? args.pop : {}
       key     = args.shift
-      locale  = options.key?(:locale) ? options.delete(:locale) : I18n.locale
+      locale  = options.delete(:locale) || I18n.locale
       raises  = options.delete(:raise)
       backend.translate(locale, key, options)
     rescue I18n::ArgumentError => exception
@@ -225,7 +225,9 @@ module I18n
     end
     alias :l :localize
 
-  protected
+  # 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

data/lib/i18n/backend.rb

@@ -3,6 +3,7 @@ module I18n
     autoload :ActiveRecord,  'i18n/backend/active_record'
     autoload :Base,          'i18n/backend/base'
     autoload :Cache,         'i18n/backend/cache'
+    autoload :Cascade,       'i18n/backend/cascade'
     autoload :Chain,         'i18n/backend/chain'
     autoload :Fallbacks,     'i18n/backend/fallbacks'
     autoload :Gettext,       'i18n/backend/gettext'

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

@@ -8,30 +8,31 @@
 # was extracted from the original backend.
 #
 # ParseTree is not compatible with Ruby 1.9.
+
+begin
+  require 'ruby2ruby'
+  require 'parse_tree'
+  require 'parse_tree_extensions'
+rescue LoadError => e
+  puts "can't use StoreProcs because: #{e.message}"
+end
+
 module I18n
   module Backend
     class ActiveRecord
       module StoreProcs
-        unless RUBY_VERSION >= '1.9'
-          class << self
-            def included(target)
-              require 'ruby2ruby'
-              require 'parse_tree'
-              require 'parse_tree_extensions'
-            end
-          end
-
-          def value=(v)
-            case v
-              when Proc
-                write_attribute(:value, v.to_ruby)
-                write_attribute(:is_proc, true)
-              else
-                write_attribute(:value, v)
-            end
+        def value=(v)
+          case 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'
       end
     end
   end
-end
+end

data/lib/i18n/backend/base.rb

@@ -173,23 +173,42 @@ module I18n
         def interpolate(locale, string, values = {})
           return string unless string.is_a?(String) && !values.empty?
 
-          s = string.gsub(INTERPOLATION_SYNTAX_PATTERN) do
-            escaped, key = $1, $2.to_sym
-            if escaped
-              "{{#{key}}}"
-            elsif RESERVED_KEYS.include?(key)
-              raise ReservedInterpolationKey.new(key, string)
-            else
-              "%{#{key}}"
+          preserve_encoding(string) do
+            s = string.gsub(INTERPOLATION_SYNTAX_PATTERN) do
+              escaped, key = $1, $2.to_sym
+              if escaped
+                "{{#{key}}}"
+              elsif RESERVED_KEYS.include?(key)
+                raise ReservedInterpolationKey.new(key, string)
+              else
+                "%{#{key}}"
+              end
+            end
+
+            values.each do |key, value|
+              value = value.call(values) if interpolate_lambda?(value, s, key)
+              value = value.to_s unless value.is_a?(String)
+              values[key] = value
             end
+
+            s % values
           end
-          values.each { |key, value| values[key] = value.call(values) if interpolate_lambda?(value, s, key) }
-          s % values
 
         rescue KeyError => e
           raise MissingInterpolationArgument.new(values, string)
         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
+          end
+        end
+
         # returns true when the given value responds to :call and the key is
         # an interpolation placeholder in the given string
         def interpolate_lambda?(object, string, key)

data/lib/i18n/backend/cache.rb

@@ -62,8 +62,12 @@ module I18n
         end
 
         def cache_key(*args)
-          # this assumes that only simple, native Ruby values are passed to I18n.translate
-          keys = ['i18n', I18n.cache_namespace, args.hash]
+          # 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('-')
         end
     end

data/lib/i18n/backend/cascade.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+# EXPERIMENTAL
+#
+# 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
+# Cascade module strips one segment off the scope part of the key and then
+# tries to look up the key in that scope.
+#
+# E.g. when a lookup for the key :"foo.bar.baz" does not yield a result then
+# the segment :bar will be stripped off the scope part :"foo.bar" and the new
+# scope :foo will be used to look up the key :baz. If that does not succeed
+# 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.
+#
+# 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
+# of scopes for a particular key.
+#
+# Thanks to Clemens Kofler for the initial idea and implementation! See
+# http://github.com/clemens/i18n-cascading-backend
+
+module I18n
+  @@fallbacks = nil
+
+  module Backend
+    module Cascade
+      def lookup(locale, key, scope = [], separator = nil)
+        return unless key
+        locale, *scope = I18n.send(:normalize_translation_keys, locale, key, scope, separator)
+        key = scope.pop
+
+        begin
+          result = super
+          return result unless result.nil?
+        end while scope.pop
+      end
+    end
+  end
+end

data/lib/i18n/backend/gettext.rb

@@ -41,7 +41,7 @@ module I18n
 
         def normalize(locale, data)
           data.inject({}) do |result, (key, value)|
-            unless key.blank?
+            unless key.nil? || key.empty?
               key, value = normalize_pluralization(locale, key, value) if key.index("\000")
 
               parts = key.split('|').reverse

data/test/api/interpolation.rb

@@ -22,11 +22,11 @@ module Tests
       end
 
       define_method "test interpolation: given a lambda as a value it calls it if the string contains the key" do
-        assert_equal 'Hi David!', interpolate(:default => 'Hi {{name}}!', :name => lambda { 'David' })
+        assert_equal 'Hi David!', interpolate(:default => 'Hi {{name}}!', :name => lambda { |*args| 'David' })
       end
 
       define_method "test interpolation: given a lambda as a value it does not call it if the string does not contain the key" do
-        assert_nothing_raised { interpolate(:default => 'Hi!', :name => lambda { raise 'fail' }) }
+        assert_nothing_raised { interpolate(:default => 'Hi!', :name => lambda { |*args| raise 'fail' }) }
       end
 
       define_method "test interpolation: given values but missing a key it raises I18n::MissingInterpolationArgument" do
@@ -64,16 +64,16 @@ module Tests
       end
 
       if Kernel.const_defined?(:Encoding)
-        define_method "test interpolation: given a utf-8 translation and a euc-jp value it returns a translation in euc-jp" do
-          assert_equal euc_jp('Hi ゆきひろ!'), interpolate(:default => 'Hi {{name}}!', :name => euc_jp('ゆきひろ'))
-        end
-
         define_method "test interpolation: given a euc-jp translation and a utf-8 value it raises Encoding::CompatibilityError" do
           assert_raises(Encoding::CompatibilityError) do
             interpolate(:default => euc_jp('こんにちは、{{name}}さん!'), :name => 'ゆきひろ')
           end
         end
         
+        # define_method "test interpolation: given a utf-8 translation and a euc-jp value it returns a translation in euc-jp" do
+        #   assert_equal euc_jp('Hi ゆきひろ!'), interpolate(:default => 'Hi {{name}}!', :name => euc_jp('ゆきひろ'))
+        # end
+        # 
         # TODO should better explain how this relates to the test above with the simpler utf-8 default string
         define_method "test interpolation: given a utf-8 translation and a euc-jp value it raises Encoding::CompatibilityError" do
           assert_raises(Encoding::CompatibilityError) do

data/test/api/localization/date.rb

@@ -45,7 +45,7 @@ module Tests
           assert_equal '[Sat, 01 Mar 2008, {}]', I18n.l(@date, :format => :proc, :locale => :de)
         end
 
-        # TODO fails, but probably should pass
+        # TODO fails, but something along these lines probably should pass
         # define_method "test localize Date: given a format that resolves to a Proc it calls the Proc with the object and extra options" do
         #   assert_equal '[Sat Mar 01 06:00:00 UTC 2008, {:foo=>"foo"}]', I18n.l(@time, :format => :proc, :foo => 'foo', :locale => :de)
         # end

data/test/api/localization/date_time.rb

@@ -48,9 +48,12 @@ module Tests
         end
 
         define_method "test localize Date: given a format that resolves to a Proc it calls the Proc with the object" do
-          assert_equal '[Sat Mar 01 06:00:00 UTC 2008, {}]', I18n.l(@time, :format => :proc, :locale => :de)
+          if can_store_procs?
+            assert_equal '[Sat, 01 Mar 2008 06:00:00 +0000, {}]', I18n.l(@datetime, :format => :proc, :locale => :de)
+          end
         end
 
+        # TODO fails, but something along these lines probably should pass
         # define_method "test localize DateTime: given a format that resolves to a Proc it calls the Proc with the object and extra options" do
         #   assert_equal '1ter März 2008, 06:00 Uhr', I18n.l(@datetime, :long_ordinalized)
         # end

data/test/api/localization/time.rb

@@ -48,10 +48,12 @@ module Tests
         end
 
         define_method "test localize Time: given a format that resolves to a Proc it calls the Proc with the object" do
-          assert_equal '[Sat Mar 01 06:00:00 UTC 2008, {}]', I18n.l(@time, :format => :proc, :locale => :de)
+          if can_store_procs?
+            assert_equal '[Sat, 01 Mar 2008 06:00:00 +0000, {}]', I18n.l(@datetime, :format => :proc, :locale => :de)
+          end
         end
         
-        # TODO fails, but probably should pass
+        # TODO fails, but something along these lines probably should pass
         # define_method "test localize Time: given a format that resolves to a Proc it calls the Proc with the object and extra options" do
         #   assert_equal '[Sat Mar 01 06:00:00 UTC 2008, {:foo=>"foo"}]', I18n.l(@time, :format => :proc, :foo => 'foo', :locale => :de)
         # end

data/test/api/lookup.rb

@@ -30,8 +30,11 @@ module Tests
         assert_equal 'bar', I18n.t('foo|bar', :separator => '|')
       end
 
-      define_method "test lookup: given nil as a locale it raises InvalidLocale" do
-        assert_raises(I18n::InvalidLocale) { I18n.t(:bar, :locale => nil) }
+      # In fact it probably *should* fail but Rails currently relies on using the default locale instead.
+      # So we'll stick to this for now until we get it fixed in Rails.
+      define_method "test lookup: given nil as a locale it does not raise but use the default locale" do
+        # assert_raises(I18n::InvalidLocale) { I18n.t(:bar, :locale => nil) }
+        assert_nothing_raised { I18n.t(:bar, :locale => nil) }
       end
     end
   end

data/test/cases/api/active_record_test.rb

@@ -3,6 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 setup_active_record
 
+
 class I18nActiveRecordApiTest < Test::Unit::TestCase
   def setup
     I18n.backend = I18n::Backend::ActiveRecord.new
@@ -15,14 +16,14 @@ class I18nActiveRecordApiTest < Test::Unit::TestCase
   include Tests::Api::Link
   include Tests::Api::Lookup
   include Tests::Api::Pluralization
-  include Tests::Api::Procs
+  include Tests::Api::Procs unless RUBY_VERSION >= '1.9.1'
+
   include Tests::Api::Localization::Date
   include Tests::Api::Localization::DateTime
   include Tests::Api::Localization::Time
-  include Tests::Api::Localization::Procs
+  include Tests::Api::Localization::Procs unless RUBY_VERSION >= '1.9.1'
 
   define_method "test: make sure we use an ActiveRecord backend" do
     assert_equal I18n::Backend::ActiveRecord, I18n.backend.class
   end
-end
-
+end if defined?(ActiveRecord)

data/test/cases/backend/active_record/missing_test.rb

@@ -57,4 +57,4 @@ class I18nActiveRecordMissingTest < Test::Unit::TestCase
     translations = I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key %w{ foo.zero foo.one foo.other }
     assert !I18n::Backend::ActiveRecord::Translation.locale(:en).find_by_key("foo")
   end
-end
+end if defined?(ActiveRecord)

data/test/cases/backend/active_record_test.rb

@@ -3,10 +3,10 @@ require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 setup_active_record
 
+
 class I18nBackendActiveRecordTest < Test::Unit::TestCase
   def setup
     I18n.backend = I18n::Backend::ActiveRecord.new
-    I18n::Backend::ActiveRecord::Translation.send(:include, I18n::Backend::ActiveRecord::StoreProcs)
     store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' })
   end
 
@@ -39,12 +39,14 @@ class I18nBackendActiveRecordTest < Test::Unit::TestCase
     assert_equal 'foo', I18n.t(:foo)
   end
 
-  def test_missing_translations_table_does_not_cause_available_locales_to_error
-    I18n::Backend::ActiveRecord::Translation.expects(:available_locales).raises(::ActiveRecord::StatementInvalid)
-    assert_equal [], I18n.backend.available_locales
+  with_mocha do
+    def test_missing_translations_table_does_not_cause_available_locales_to_error
+      I18n::Backend::ActiveRecord::Translation.expects(:available_locales).raises(::ActiveRecord::StatementInvalid)
+      assert_equal [], I18n.backend.available_locales
+    end
   end
 
   def test_expand_keys
     assert_equal %w(foo foo.bar foo.bar.baz), I18n.backend.send(:expand_keys, :'foo.bar.baz')
   end
-end
+end if defined?(ActiveRecord)

data/test/cases/backend/cache_test.rb

@@ -29,22 +29,25 @@ class I18nBackendCacheTest < Test::Unit::TestCase
     assert I18n.cache_store.is_a?(ActiveSupport::Cache::MemoryStore)
   end
 
-  define_method "test translate hits the backend and caches the response" do
-    I18n.backend.expects(:lookup).returns('Foo')
-    assert_equal 'Foo', I18n.t(:foo)
+  with_mocha do
+    define_method "test translate hits the backend and caches the response" do
+      I18n.backend.expects(:lookup).returns('Foo')
+      assert_equal 'Foo', I18n.t(:foo)
 
-    I18n.backend.expects(:lookup).never
-    assert_equal 'Foo', I18n.t(:foo)
+      I18n.backend.expects(:lookup).never
+      assert_equal 'Foo', I18n.t(:foo)
 
-    I18n.backend.expects(:lookup).returns('Bar')
-    assert_equal 'Bar', I18n.t(:bar)
-  end
+      I18n.backend.expects(:lookup).returns('Bar')
+      assert_equal 'Bar', I18n.t(:bar)
+    end
 
-  define_method "test still raises MissingTranslationData but also caches it" do
-    I18n.backend.expects(:lookup).returns(nil)
-    assert_raises(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
-    I18n.backend.expects(:lookup).never
-    assert_raises(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+    define_method "test still raises MissingTranslationData but also caches it" do
+      I18n.backend.expects(:lookup).returns(nil)
+      assert_raises(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+
+      I18n.backend.expects(:lookup).never
+      assert_raises(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+    end
   end
 
   define_method "test uses 'i18n' as a cache key namespace by default" do

data/test/cases/backend/cascade_test.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class I18nBackendCascadeTest < Test::Unit::TestCase
+  class Backend
+    include I18n::Backend::Base
+    include I18n::Backend::Cascade
+  end
+
+  def setup
+    I18n.backend = Backend.new
+    store_translations(:en,
+      :foo => 'foo',
+      :bar => { :baz => 'baz' }
+    )
+  end
+
+  define_method "test: still returns an existing translation as usual" do
+    assert_equal 'foo', I18n.t(:foo)
+    assert_equal 'baz', I18n.t(:'bar.baz')
+  end
+
+  define_method "test: falls back by cutting keys off the end of the scope" do
+    assert_equal 'foo', I18n.t(:'does_not_exist.foo')
+    assert_equal 'foo', I18n.t(:'does_not_exist.does_not_exist.foo')
+
+    assert_equal 'baz', I18n.t(:'bar.does_not_exist.baz')
+    assert_equal 'baz', I18n.t(:'bar.does_not_exist.does_not_exist.baz')
+  end
+
+  define_method "test: raises I18n::MissingTranslationData exception when no translation was found" do
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:'foo.does_not_exist', :raise => true) }
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:'bar.baz.does_not_exist', :raise => true) }
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:'does_not_exist.bar.baz', :raise => true) }
+  end
+
+  define_method "test: cascades before evaluating the default" do
+    assert_equal 'foo', I18n.t(:foo, :scope => :does_not_exist, :default => 'default')
+  end
+
+  define_method "test: let's us assemble required fallbacks for ActiveRecord validation messages" do
+    store_translations(:en,
+      :errors => {
+        :reply => {
+          :title => {
+            :blank => 'blank on reply title'
+          },
+          :taken => 'taken on reply'
+        },
+        :topic => {
+          :title => {
+            :format => 'format on topic title'
+          },
+          :length => 'length on topic'
+        },
+        :odd => 'odd on errors'
+      }
+    )
+    assert_equal 'blank on reply title',  I18n.t(:'errors.reply.title.blank',  :default => :'errors.topic.title.blank')
+    assert_equal 'taken on reply',        I18n.t(:'errors.reply.title.taken',  :default => :'errors.topic.title.taken')
+    assert_equal 'format on topic title', I18n.t(:'errors.reply.title.format', :default => :'errors.topic.title.format')
+    assert_equal 'length on topic',       I18n.t(:'errors.reply.title.length', :default => :'errors.topic.title.length')
+    assert_equal 'odd on errors',         I18n.t(:'errors.reply.title.odd',    :default => :'errors.topic.title.odd')
+  end
+end

data/test/cases/i18n_test.rb

@@ -71,26 +71,28 @@ class I18nTest < Test::Unit::TestCase
     I18n.exception_handler = :default_exception_handler # revert it
   end
 
-  def test_uses_custom_exception_handler
-    I18n.exception_handler = :custom_exception_handler
-    I18n.expects(:custom_exception_handler)
-    I18n.translate :bogus
-    I18n.exception_handler = :default_exception_handler # revert it
-  end
+  with_mocha do
+    def test_uses_custom_exception_handler
+      I18n.exception_handler = :custom_exception_handler
+      I18n.expects(:custom_exception_handler)
+      I18n.translate :bogus
+      I18n.exception_handler = :default_exception_handler # revert it
+    end
 
-  def test_delegates_translate_to_backend
-    I18n.backend.expects(:translate).with 'de', :foo, {}
-    I18n.translate :foo, :locale => 'de'
-  end
+    def test_delegates_translate_to_backend
+      I18n.backend.expects(:translate).with 'de', :foo, {}
+      I18n.translate :foo, :locale => 'de'
+    end
 
-  def test_delegates_localize_to_backend
-    I18n.backend.expects(:localize).with 'de', :whatever, :default
-    I18n.localize :whatever, :locale => 'de'
-  end
+    def test_delegates_localize_to_backend
+      I18n.backend.expects(:localize).with 'de', :whatever, :default
+      I18n.localize :whatever, :locale => 'de'
+    end
 
-  def test_translate_given_no_locale_uses_i18n_locale
-    I18n.backend.expects(:translate).with :en, :foo, {}
-    I18n.translate :foo
+    def test_translate_given_no_locale_uses_i18n_locale
+      I18n.backend.expects(:translate).with :en, :foo, {}
+      I18n.translate :foo
+    end
   end
 
   def test_translate_on_nested_symbol_keys_works
@@ -117,10 +119,12 @@ class I18nTest < Test::Unit::TestCase
     assert_equal [".", ","], I18n.t(%w(format.separator format.delimiter), :scope => 'currency')
   end
 
-  def test_translate_with_options_using_scope_works
-    I18n.backend.expects(:translate).with('de', :precision, :scope => :"currency.format")
-    I18n.with_options :locale => 'de', :scope => :'currency.format' do |locale|
-      locale.t :precision
+  with_mocha do
+    def test_translate_with_options_using_scope_works
+      I18n.backend.expects(:translate).with('de', :precision, :scope => :"currency.format")
+      I18n.with_options :locale => 'de', :scope => :'currency.format' do |locale|
+        locale.t :precision
+      end
     end
   end
 

data/test/test_helper.rb

@@ -5,12 +5,18 @@ $: << File.expand_path(File.dirname(__FILE__))
 
 require 'rubygems'
 require 'test/unit'
-require 'mocha'
 require 'i18n'
 require 'i18n/core_ext/object/meta_class'
 require 'time'
 require 'yaml'
 
+begin
+  require 'mocha'
+rescue LoadError
+  puts "skipping tests using mocha as mocha can't be found"
+end
+
+
 Dir[File.dirname(__FILE__) + '/api/**/*.rb'].each do |filename|
   require filename
 end
@@ -24,11 +30,15 @@ $KCODE = 'u' unless RUBY_VERSION >= '1.9'
 #   end
 # end
 
-class Test::Unit::TestCase  
+class Test::Unit::TestCase
   def self.test(name, &block)
     define_method("test: " + name, &block)
   end
 
+  def self.with_mocha
+    yield if Object.respond_to?(:expects)
+  end
+
   def teardown
     I18n.locale = nil
     I18n.default_locale = :en
@@ -40,13 +50,13 @@ class Test::Unit::TestCase
   def translations
     I18n.backend.instance_variable_get(:@translations)
   end
-  
+
   def store_translations(*args)
     data   = args.pop
     locale = args.pop || :en
     I18n.backend.store_translations(locale, data)
   end
-  
+
   def locales_dir
     File.dirname(__FILE__) + '/fixtures/locales'
   end
@@ -54,27 +64,36 @@ class Test::Unit::TestCase
   def euc_jp(string)
     string.encode!(Encoding::EUC_JP)
   end
+
+  def can_store_procs?
+    I18n::Backend::ActiveRecord === I18n.backend and
+    I18n::Backend::ActiveRecord.included_modules.include?(I18n::Backend::ActiveRecord::StoreProcs)
+  end
 end
 
 def setup_active_record
-  require 'active_record'
-  require 'i18n/backend/active_record/store_procs'
+  begin
+    require 'activerecord'
+    require 'i18n/backend/active_record'
+    require 'i18n/backend/active_record/store_procs'
 
-  if I18n::Backend::Simple.method_defined?(:interpolate_with_deprecated_syntax)
-    I18n::Backend::Simple.send(:remove_method, :interpolate) rescue NameError
-  end
+    if I18n::Backend::Simple.method_defined?(:interpolate_with_deprecated_syntax)
+      I18n::Backend::Simple.send(:remove_method, :interpolate) rescue NameError
+    end
 
-  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-  ActiveRecord::Migration.verbose = false
-  ActiveRecord::Schema.define(:version => 1) do
-    create_table :translations do |t|
-      t.string :locale
-      t.string :key
-      t.string :value
-      t.string :interpolations
-      t.boolean :is_proc, :default => false
+    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+    ActiveRecord::Migration.verbose = false
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :translations do |t|
+        t.string :locale
+        t.string :key
+        t.string :value
+        t.string :interpolations
+        t.boolean :is_proc, :default => false
+      end
     end
-  end
 
-  I18n::Backend::ActiveRecord::Translation.send(:include, I18n::Backend::ActiveRecord::StoreProcs)
+  rescue LoadError
+    puts "skipping tests using activerecord as activerecord can't be found"
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: i18n
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-11 00:00:00 +01:00
+date: 2009-12-12 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -39,6 +39,7 @@ files:
 - lib/i18n/backend/active_record/translation.rb
 - lib/i18n/backend/base.rb
 - lib/i18n/backend/cache.rb
+- lib/i18n/backend/cascade.rb
 - lib/i18n/backend/chain.rb
 - lib/i18n/backend/fallbacks.rb
 - lib/i18n/backend/gettext.rb
@@ -79,6 +80,7 @@ files:
 - test/cases/backend/active_record/missing_test.rb
 - test/cases/backend/active_record_test.rb
 - test/cases/backend/cache_test.rb
+- test/cases/backend/cascade_test.rb
 - test/cases/backend/chain_test.rb
 - test/cases/backend/fallbacks_test.rb
 - test/cases/backend/helpers_test.rb
@@ -150,6 +152,7 @@ test_files:
 - test/cases/backend/active_record/missing_test.rb
 - test/cases/backend/active_record_test.rb
 - test/cases/backend/cache_test.rb
+- test/cases/backend/cascade_test.rb
 - test/cases/backend/chain_test.rb
 - test/cases/backend/fallbacks_test.rb
 - test/cases/backend/helpers_test.rb