i18n 0.3.6 → 0.3.7

data/Rakefile

@@ -1,29 +0,0 @@
-require 'rake/testtask'
-
-task :default => [:test]
-
-Rake::TestTask.new(:test) do |t|
-  t.pattern = "#{File.dirname(__FILE__)}/test/all.rb"
-  t.verbose = true
-end
-Rake::Task['test'].comment = "Run all i18n tests"
-
-require File.expand_path("lib/i18n/version", File.dirname(__FILE__))
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "i18n"
-    s.version = I18n::VERSION
-    s.rubyforge_project = "i18n"
-    s.summary = "New wave Internationalization support for Ruby"
-    s.email = "rails-i18n@googlegroups.com"
-    s.homepage = "http://rails-i18n.org"
-    s.description = "Add Internationalization support to your Ruby application."
-    s.authors = ['Sven Fuchs', 'Joshua Harvey', 'Matt Aimonetti', 'Stephan Soller', 'Saimon Moore']
-    s.files =  FileList["[A-Z]*", "{lib,test}/**/*"]
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end

data/test/all.rb

@@ -1,8 +0,0 @@
-# encoding: utf-8
-
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(dir)
-
-Dir["#{dir}/**/*_test.rb"].sort.each do |file|
-  require file.sub(/^#{dir}\/(.*)\.rb$/, '\1')
-end

data/test/api.rb

@@ -1,18 +0,0 @@
-module Tests
-  module Api
-    autoload :Basics,        'api/tests/basics'
-    autoload :Defaults,      'api/tests/defaults'
-    autoload :Interpolation, 'api/tests/interpolation'
-    autoload :Link,          'api/tests/link'
-    autoload :Lookup,        'api/tests/lookup'
-    autoload :Pluralization, 'api/tests/pluralization'
-    autoload :Procs,         'api/tests/procs'
-
-    module Localization
-      autoload :Date,        'api/tests/localization/date'
-      autoload :DateTime,    'api/tests/localization/date_time'
-      autoload :Procs,       'api/tests/localization/procs'
-      autoload :Time,        'api/tests/localization/time'
-    end
-  end
-end

data/test/api/active_record_test.rb

@@ -1,30 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-require 'api'
-
-require_active_record!
-
-class I18nActiveRecordApiTest < Test::Unit::TestCase
-  def setup
-    I18n.backend = I18n::Backend::ActiveRecord.new
-    super
-  end
-
-  include Tests::Api::Basics
-  include Tests::Api::Defaults
-  include Tests::Api::Interpolation
-  include Tests::Api::Link
-  include Tests::Api::Lookup
-  include Tests::Api::Pluralization
-  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 # unless RUBY_VERSION >= '1.9.1'
-
-  test "make sure we use an ActiveRecord backend" do
-    assert_equal I18n::Backend::ActiveRecord, I18n.backend.class
-  end
-end if defined?(ActiveRecord)

data/test/api/all_features_test.rb

@@ -1,59 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-begin
-  require 'rubygems'
-  require 'active_support'
-rescue LoadError
-  puts "not testing with Cache enabled because active_support can not be found"
-end
-
-require 'test_helper'
-require 'api'
-
-class I18nAllFeaturesApiTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Cache
-    include I18n::Backend::Metadata
-    include I18n::Backend::Cascade
-    include I18n::Backend::Fallbacks
-    include I18n::Backend::Pluralization
-    include I18n::Backend::Fast
-    include I18n::Backend::InterpolationCompiler
-  end
-
-  def setup
-    I18n.backend = I18n::Backend::Chain.new(Backend.new, I18n::Backend::Simple.new)
-    I18n.cache_store = cache_store
-    super
-  end
-
-  def teardown
-    I18n.cache_store.clear
-    I18n.cache_store = nil
-    super
-  end
-
-  def cache_store
-    ActiveSupport::Cache.lookup_store(:memory_store) if defined?(ActiveSupport) && defined?(ActiveSupport::Cache)
-  end
-
-  include Tests::Api::Basics
-  include Tests::Api::Defaults
-  include Tests::Api::Interpolation
-  include Tests::Api::Link
-  include Tests::Api::Lookup
-  include Tests::Api::Pluralization
-  include Tests::Api::Procs
-  include Tests::Api::Localization::Date
-  include Tests::Api::Localization::DateTime
-  include Tests::Api::Localization::Time
-  include Tests::Api::Localization::Procs
-
-  test "make sure we use a Chain backend with an all features backend" do
-    assert_equal I18n::Backend::Chain, I18n.backend.class
-    assert_equal Backend, I18n.backend.backends.first.class
-  end
-
-  # links: test that keys stored on one backend can link to keys stored on another backend
-end

data/test/api/cascade_test.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-require 'api'
-
-class I18nCascadeApiTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Cascade
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    super
-  end
-
-  include Tests::Api::Basics
-  include Tests::Api::Defaults
-  include Tests::Api::Interpolation
-  include Tests::Api::Link
-  include Tests::Api::Lookup
-  include Tests::Api::Pluralization
-  include Tests::Api::Procs
-  include Tests::Api::Localization::Date
-  include Tests::Api::Localization::DateTime
-  include Tests::Api::Localization::Time
-  include Tests::Api::Localization::Procs
-
-  test "make sure we use a backend with Cascade included" do
-    assert_equal Backend, I18n.backend.class
-  end
-end

data/test/api/chain_test.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-require 'api'
-
-class I18nApiChainTest < Test::Unit::TestCase
-  def setup
-    super
-    I18n.backend = I18n::Backend::Chain.new(I18n::Backend::Simple.new, I18n.backend)
-  end
-
-  include Tests::Api::Basics
-  include Tests::Api::Defaults
-  include Tests::Api::Interpolation
-  include Tests::Api::Link
-  include Tests::Api::Lookup
-  include Tests::Api::Pluralization
-  include Tests::Api::Procs
-  include Tests::Api::Localization::Date
-  include Tests::Api::Localization::DateTime
-  include Tests::Api::Localization::Time
-  include Tests::Api::Localization::Procs
-
-  test "make sure we use the Chain backend" do
-    assert_equal I18n::Backend::Chain, I18n.backend.class
-  end
-end

data/test/api/fallbacks_test.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-require 'api'
-
-class I18nFallbacksApiTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Fallbacks
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    super
-  end
-
-  include Tests::Api::Basics
-  include Tests::Api::Defaults
-  include Tests::Api::Interpolation
-  include Tests::Api::Link
-  include Tests::Api::Lookup
-  include Tests::Api::Pluralization
-  include Tests::Api::Procs
-  include Tests::Api::Localization::Date
-  include Tests::Api::Localization::DateTime
-  include Tests::Api::Localization::Time
-  include Tests::Api::Localization::Procs
-
-  test "make sure we use a backend with Fallbacks included" do
-    assert_equal Backend, I18n.backend.class
-  end
-  
-  # links: test that keys stored on one backend can link to keys stored on another backend
-end

data/test/api/fast_test.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-require 'api'
-
-class I18nFastBackendApiTest < Test::Unit::TestCase
-  include Tests::Api::Basics
-  include Tests::Api::Defaults
-  include Tests::Api::Interpolation
-  include Tests::Api::Link
-  include Tests::Api::Lookup
-  include Tests::Api::Pluralization
-  include Tests::Api::Procs
-  include Tests::Api::Localization::Date
-  include Tests::Api::Localization::DateTime
-  include Tests::Api::Localization::Time
-  include Tests::Api::Localization::Procs
-  
-  class FastBackend
-    include I18n::Backend::Base
-    include I18n::Backend::Fast
-  end
-
-  def setup
-    I18n.backend = FastBackend.new
-    super
-  end
-  
-  test "make sure we use the FastBackend backend" do
-    assert_equal FastBackend, I18n.backend.class
-  end
-end

data/test/api/pluralization_test.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-require 'api'
-
-class I18nPluralizationApiTest < Test::Unit::TestCase
-  class Backend
-    include I18n::Backend::Base
-    include I18n::Backend::Pluralization
-  end
-
-  def setup
-    I18n.backend = Backend.new
-    super
-  end
-
-  include Tests::Api::Basics
-  include Tests::Api::Defaults
-  include Tests::Api::Interpolation
-  include Tests::Api::Link
-  include Tests::Api::Lookup
-  include Tests::Api::Pluralization
-  include Tests::Api::Procs
-  include Tests::Api::Localization::Date
-  include Tests::Api::Localization::DateTime
-  include Tests::Api::Localization::Time
-  include Tests::Api::Localization::Procs
-
-  test "make sure we use a backend with Pluralization included" do
-    assert_equal Backend, I18n.backend.class
-  end
-  
-  # links: test that keys stored on one backend can link to keys stored on another backend
-end

data/test/api/simple_test.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../')); $:.uniq!
-require 'test_helper'
-require 'api'
-require 'api'
-
-class I18nSimpleBackendApiTest < Test::Unit::TestCase
-  include Tests::Api::Basics
-  include Tests::Api::Defaults
-  include Tests::Api::Interpolation
-  include Tests::Api::Link
-  include Tests::Api::Lookup
-  include Tests::Api::Pluralization
-  include Tests::Api::Procs
-  include Tests::Api::Localization::Date
-  include Tests::Api::Localization::DateTime
-  include Tests::Api::Localization::Time
-  include Tests::Api::Localization::Procs
-
-  test "make sure we use the Simple backend" do
-    assert_equal I18n::Backend::Simple, I18n.backend.class
-  end
-end

data/test/api/tests/basics.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-module Tests
-  module Api
-    module Basics
-      def test_available_locales
-        store_translations('de', :foo => 'bar')
-        store_translations('en', :foo => 'foo')
-
-        assert I18n.available_locales.include?(:de)
-        assert I18n.available_locales.include?(:en)
-      end
-    end
-  end
-end

data/test/api/tests/defaults.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-module Tests
-  module Api
-    module Defaults
-      def setup
-        super
-        store_translations(:foo => { :bar => 'bar', :baz => 'baz' })
-      end
-      
-      define_method "test defaults: given nil as a key it returns the given default" do
-        assert_equal 'default', I18n.t(nil, :default => 'default')
-      end
-      
-      define_method "test defaults: given a symbol as a default it translates the symbol" do
-        assert_equal 'bar', I18n.t(nil, :default => :'foo.bar')
-      end
-
-      define_method "test defaults: given a symbol as a default and a scope it stays inside the scope when looking up the symbol" do
-        assert_equal 'bar', I18n.t(:missing, :default => :bar, :scope => :foo)
-      end
-
-      define_method "test defaults: given an array as a default it returns the first match" do
-        assert_equal 'bar', I18n.t(:does_not_exist, :default => [:does_not_exist_2, :'foo.bar'])
-      end
-
-      define_method "test defaults: given an array of missing keys it raises a MissingTranslationData exception" do
-        assert_raise I18n::MissingTranslationData do
-          I18n.t(:does_not_exist, :default => [:does_not_exist_2, :does_not_exist_3], :raise => true)
-        end
-      end
-
-      define_method "test defaults: using a custom scope separator" do
-        # data must have been stored using the custom separator when using the ActiveRecord backend
-        I18n.backend.store_translations(:en, { :foo => { :bar => 'bar' } }, { :separator => '|' })
-        assert_equal 'bar', I18n.t(nil, :default => :'foo|bar', :separator => '|')
-      end
-    end
-  end
-end

data/test/api/tests/interpolation.rb

@@ -1,92 +0,0 @@
-# encoding: utf-8
-
-module Tests
-  module Api
-    module Interpolation
-      def interpolate(*args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        key = args.pop
-        I18n.backend.translate('en', key, options)
-      end
-
-      define_method "test interpolation: given no values it does not alter the string" do
-        assert_equal 'Hi {{name}}!', interpolate(:default => 'Hi {{name}}!')
-      end
-
-      define_method "test interpolation: given values it interpolates them into the string" do
-        assert_equal 'Hi David!', interpolate(:default => 'Hi {{name}}!', :name => 'David')
-      end
-
-      define_method "test interpolation: given a nil value it still interpolates it into the string" do
-        assert_equal 'Hi !', interpolate(:default => 'Hi {{name}}!', :name => nil)
-      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 { |*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 { |*args| raise 'fail' }) }
-      end
-
-      define_method "test interpolation: given values but missing a key it raises I18n::MissingInterpolationArgument" do
-        assert_raise(I18n::MissingInterpolationArgument) do
-          interpolate(:default => '{{foo}}', :bar => 'bar')
-        end
-      end
-
-      define_method "test interpolation: it does not raise I18n::MissingInterpolationArgument for escaped variables" do
-        assert_nothing_raised(I18n::MissingInterpolationArgument) do
-          assert_equal 'Barr {{foo}}', interpolate(:default => '{{bar}} \{{foo}}', :bar => 'Barr')
-        end
-      end
-
-      define_method "test interpolation: it does not change the original, stored translation string" do
-        I18n.backend.store_translations(:en, :interpolate => 'Hi {{name}}!')
-        assert_equal 'Hi David!', interpolate(:interpolate, :name => 'David')
-        assert_equal 'Hi Yehuda!', interpolate(:interpolate, :name => 'Yehuda')
-      end
-
-      define_method "test interpolation: works with Ruby 1.9 syntax" do
-        assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => 'David')
-      end
-
-      define_method "test interpolation: given the translation is in utf-8 it still works" do
-        assert_equal 'Häi David!', interpolate(:default => 'Häi {{name}}!', :name => 'David')
-      end
-
-      define_method "test interpolation: given the value is in utf-8 it still works" do
-        assert_equal 'Hi ゆきひろ!', interpolate(:default => 'Hi {{name}}!', :name => 'ゆきひろ')
-      end
-
-      define_method "test interpolation: given the translation and the value are in utf-8 it still works" do
-        assert_equal 'こんにちは、ゆきひろさん!', interpolate(:default => 'こんにちは、{{name}}さん!', :name => 'ゆきひろ')
-      end
-
-      if Kernel.const_defined?(:Encoding)
-        define_method "test interpolation: given a euc-jp translation and a utf-8 value it raises Encoding::CompatibilityError" do
-          assert_raise(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_raise(Encoding::CompatibilityError) do
-            interpolate(:default => 'こんにちは、{{name}}さん!', :name => euc_jp('ゆきひろ'))
-          end
-        end
-      end
-
-      define_method "test interpolation: given a translations containing a reserved key it raises I18n::ReservedInterpolationKey" do
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:default => '{{default}}',   :foo => :bar) }
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:default => '{{scope}}',     :foo => :bar) }
-        assert_raise(I18n::ReservedInterpolationKey) { interpolate(:default => '{{separator}}', :foo => :bar) }
-      end
-    end
-  end
-end