theoooo-i18n 0.2.0 → 0.2.1

data/lib/i18n/locale/fallbacks.rb

@@ -0,0 +1,98 @@
+require 'i18n/locale/tag'
+
+# Locale Fallbacks
+#
+# Extends the I18n module to hold a fallbacks instance which is set to an
+# instance of I18n::Locale::Fallbacks by default but can be swapped with a
+# different implementation.
+#
+# Locale fallbacks will compute a number of fallback locales for a given locale.
+# For example:
+#
+# <pre><code>
+# I18n.fallbacks[:"es-MX"] # => [:"es-MX", :es, :en] </code></pre>
+#
+# Locale fallbacks always fall back to
+#
+#   * all parent locales of a given locale (e.g. :es for :"es-MX") first,
+#   * the current default locales and all of their parents second
+#
+# The default locales are set to [I18n.default_locale] by default but can be
+# set to something else.
+#
+# One can additionally add any number of additional fallback locales manually.
+# These will be added before the default locales to the fallback chain. For
+# example:
+#
+#   # using the default locale as default fallback locale
+#
+#   I18n.default_locale = :"en-US"
+#   I18n.fallbacks = I18n::Fallbacks.new(:"de-AT" => :"de-DE")
+#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :"de-DE", :de, :"en-US", :en]
+#
+#   # using a custom locale as default fallback locale
+#
+#   I18n.fallbacks = I18n::Fallbacks.new(:"en-GB", :"de-AT" => :de, :"de-CH" => :de)
+#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :de, :"en-GB", :en]
+#   I18n.fallbacks[:"de-CH"] # => [:"de-CH", :de, :"en-GB", :en]
+#
+#   # mapping fallbacks to an existing instance
+#
+#   # people speaking Catalan also speak Spanish as spoken in Spain
+#   fallbacks = I18n.fallbacks
+#   fallbacks.map(:ca => :"es-ES") 
+#   fallbacks[:ca] # => [:ca, :"es-ES", :es, :"en-US", :en]
+#
+#   # people speaking Arabian as spoken in Palestine also speak Hebrew as spoken in Israel
+#   fallbacks.map(:"ar-PS" => :"he-IL")
+#   fallbacks[:"ar-PS"] # => [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en]
+#   fallbacks[:"ar-EG"] # => [:"ar-EG", :ar, :"en-US", :en]
+#
+#   # people speaking Sami as spoken in Finnland also speak Swedish and Finnish as spoken in Finnland
+#   fallbacks.map(:sms => [:"se-FI", :"fi-FI"])
+#   fallbacks[:sms] # => [:sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en]
+
+module I18n
+  module Locale
+    class Fallbacks < Hash
+      def initialize(*mappings)
+        @map = {}
+        map(mappings.pop) if mappings.last.is_a?(Hash)
+        self.defaults = mappings.empty? ? [I18n.default_locale.to_sym] : mappings
+      end
+
+      def defaults=(defaults)
+        @defaults = defaults.map { |default| compute(default, false) }.flatten
+      end
+      attr_reader :defaults
+
+      def [](locale)
+        raise InvalidLocale.new(locale) if locale.nil?
+        locale = locale.to_sym
+        super || store(locale, compute(locale))
+      end
+
+      def map(mappings)
+        mappings.each do |from, to|
+          from, to = from.to_sym, Array(to)
+          to.each do |to|
+            @map[from] ||= []
+            @map[from] << to.to_sym
+          end
+        end
+      end
+
+      protected
+
+      def compute(tags, include_defaults = true)
+        result = Array(tags).collect do |tag|
+          tags = I18n::Locale::Tag.tag(tag).self_and_parents.map! { |t| t.to_sym }
+          tags.each { |tag| tags += compute(@map[tag]) if @map[tag] }
+          tags
+        end.flatten
+        result.push(*defaults) if include_defaults
+        result.uniq
+      end
+    end
+  end
+end

data/lib/i18n/locale/tag/parents.rb

@@ -0,0 +1,22 @@
+module I18n
+  module Locale
+    module Tag
+      module Parents
+        def parent
+          @parent ||= begin
+            segs = to_a.compact
+            segs.length > 1 ? self.class.tag(*segs[0..(segs.length-2)].join('-')) : nil
+          end
+        end
+      
+        def self_and_parents
+          @self_and_parents ||= [self] + parents
+        end
+      
+        def parents
+          @parents ||= ([parent] + (parent ? parent.parents : [])).compact
+        end
+      end
+    end
+  end
+end

data/lib/i18n/locale/tag/rfc4646.rb

@@ -0,0 +1,76 @@
+# RFC 4646/47 compliant Locale tag implementation that parses locale tags to 
+# subtags such as language, script, region, variant etc.
+#
+# For more information see by http://en.wikipedia.org/wiki/IETF_language_tag
+#
+# Rfc4646::Parser does not implement grandfathered tags.
+
+require 'i18n/locale/tag/parents'
+
+module I18n
+  module Locale
+    module Tag
+      RFC4646_SUBTAGS = [ :language, :script, :region, :variant, :extension, :privateuse, :grandfathered ]
+      RFC4646_FORMATS = { :language => :downcase, :script => :capitalize, :region => :upcase, :variant => :downcase }
+
+      class Rfc4646 < Struct.new(*RFC4646_SUBTAGS)
+        class << self
+          # Parses the given tag and returns a Tag instance if it is valid. 
+          # Returns false if the given tag is not valid according to RFC 4646.
+          def tag(tag)
+            matches = parser.match(tag)
+            new(*matches) if matches
+          end
+
+          def parser
+            @@parser ||= Rfc4646::Parser
+          end
+  
+          def parser=(parser)
+            @@parser = parser
+          end
+        end
+
+        include Parents
+
+        RFC4646_FORMATS.each do |name, format|
+          define_method(name) { self[name].send(format) unless self[name].nil? }
+        end
+      
+        def to_sym
+          to_s.to_sym
+        end
+      
+        def to_s
+          @tag ||= to_a.compact.join("-")
+        end
+  
+        def to_a
+          members.collect { |attr| self.send(attr) }
+        end
+  
+        module Parser
+          PATTERN = %r{\A(?:
+            ([a-z]{2,3}(?:(?:-[a-z]{3}){0,3})?|[a-z]{4}|[a-z]{5,8}) # language
+            (?:-([a-z]{4}))?                                        # script
+            (?:-([a-z]{2}|\d{3}))?                                  # region
+            (?:-([0-9a-z]{5,8}|\d[0-9a-z]{3}))*                     # variant
+            (?:-([0-9a-wyz](?:-[0-9a-z]{2,8})+))*                   # extension
+            (?:-(x(?:-[0-9a-z]{1,8})+))?|                           # privateuse subtag
+            (x(?:-[0-9a-z]{1,8})+)|                                 # privateuse tag
+            /* ([a-z]{1,3}(?:-[0-9a-z]{2,8}){1,2}) */               # grandfathered
+            )\z}xi 
+
+          class << self
+            def match(tag)
+              c = PATTERN.match(tag.to_s).captures
+              c[0..4] << (c[5].nil? ? c[6] : c[5])  << c[7] # TODO c[7] is grandfathered, throw a NotImplemented exception here?
+            rescue
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/locale/tag/simple.rb

@@ -0,0 +1,42 @@
+require 'i18n/locale/tag/parents'
+
+# Simple Locale tag implementation that computes subtags by simply splitting
+# the locale tag at '-' occurences.
+
+module I18n
+  module Locale
+    module Tag
+      class Simple
+        class << self
+          def tag(tag)
+            new(tag)
+          end
+        end
+
+        include Parents
+
+        attr_reader :tag
+
+        def initialize(*tag)
+          @tag = tag.join('-').to_sym
+        end
+
+        def subtags
+          @subtags = tag.to_s.split('-').map { |subtag| subtag.to_s }
+        end
+
+        def to_sym
+          tag
+        end
+
+        def to_s
+          tag.to_s
+        end
+
+        def to_a
+          subtags
+        end
+      end
+    end
+  end
+end

data/lib/i18n/locale/tag.rb

@@ -0,0 +1,25 @@
+require 'i18n/locale/tag/simple'
+require 'i18n/locale/tag/rfc4646'
+
+module I18n
+  module Locale
+    module Tag
+      class << self
+        # Returns the current locale tag implementation. Defaults to +I18n::Locale::Tag::Simple+.
+        def implementation
+          @@implementation ||= Simple
+        end
+  
+        # Sets the current locale tag implementation. Use this to set a different locale tag implementation.
+        def implementation=(implementation)
+          @@implementation = implementation
+        end
+  
+        # Factory method for locale tags. Delegates to the current locale tag implementation.
+        def tag(tag)
+          implementation.tag(tag)
+        end
+      end
+    end
+  end
+end

data/test/backend/cache/cache_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/cache'
+require 'activesupport'
+
+class I18nCacheBackendTest < Test::Unit::TestCase
+  def setup
+    super
+    I18n.backend.meta_class.send(:include, I18n::Backend::Cache)
+    I18n.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+  end
+
+  def teardown
+    I18n.cache_store = nil
+  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)
+
+    I18n.backend.expects(:lookup).never
+    assert_equal 'Foo', I18n.t(:foo)
+
+    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) }
+  end
+
+  define_method :"test uses 'i18n' as a cache key namespace by default" do
+    assert_equal 0, I18n.backend.send(:cache_key, :foo).index('i18n')
+  end
+
+  define_method :"test adds a custom cache key namespace" do
+    with_cache_namespace('bar') do
+      assert_equal 0, I18n.backend.send(:cache_key, :foo).index('i18n-bar')
+    end
+  end
+
+  protected
+
+    def with_cache_namespace(namespace)
+      I18n.cache_namespace = namespace
+      yield
+      I18n.cache_namespace = nil
+    end
+end

data/test/backend/chain/api_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/chain'
+
+module ChainSetup
+  def setup
+    super
+    first = I18n::Backend::Simple.new
+    # first.store_translations(:en, translations)
+    I18n.backend = I18n::Backend::Chain.new(first, I18n.backend)
+  end
+end
+
+class I18nChainBackendApiBasicsTest < Test::Unit::TestCase
+  include ChainSetup
+  include Tests::Backend::Api::Basics
+end
+
+class I18nChainBackendApiTranslateTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include ChainSetup
+  include Tests::Backend::Api::Translation
+end
+
+class I18nChainBackendApiInterpolateTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include ChainSetup
+  include Tests::Backend::Api::Interpolation
+end
+
+class I18nChainBackendApiLambdaTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include ChainSetup
+  include Tests::Backend::Api::Lambda
+end
+
+class I18nChainBackendApiTranslateLinkedTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include ChainSetup
+  include Tests::Backend::Api::Link
+end
+
+class I18nChainBackendApiPluralizationTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include ChainSetup
+  include Tests::Backend::Api::Pluralization
+end
+
+class I18nChainBackendApiLocalizeDateTest < Test::Unit::TestCase
+  include ChainSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::Date
+end
+
+class I18nChainBackendApiLocalizeDateTimeTest < Test::Unit::TestCase
+  include ChainSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::DateTime
+end
+
+class I18nChainBackendApiLocalizeTimeTest < Test::Unit::TestCase
+  include ChainSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::Time
+end
+
+class I18nChainBackendApiLocalizeLambdaTest < Test::Unit::TestCase
+  include ChainSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::Lambda
+end
+

data/test/backend/chain/chain_test.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/chain'
+
+class I18nChainBackendTest < Test::Unit::TestCase
+  def setup
+    @first  = backend(:en => { 
+      :foo => 'Foo', :formats => { :short => 'short' }, :plural_1 => { :one => '{{count}}' }
+    })
+    @second = backend(:en => { 
+      :bar => 'Bar', :formats => { :long => 'long' }, :plural_2 => { :one => 'one' }
+    })
+    @chain  = I18n.backend = I18n::Backend::Chain.new(@first, @second)
+  end
+
+  define_method "test: looks up translations from the first chained backend" do
+    assert_equal 'Foo', @first.send(:translations)[:en][:foo]
+    assert_equal 'Foo', I18n.t(:foo)
+  end
+  
+  define_method "test: looks up translations from the second chained backend" do
+    assert_equal 'Bar', @second.send(:translations)[:en][:bar]
+    assert_equal 'Bar', I18n.t(:bar)
+  end
+  
+  define_method "test: defaults only apply to lookups on the last backend in the chain" do
+    assert_equal 'Foo', I18n.t(:foo, :default => 'Bah')
+    assert_equal 'Bar', I18n.t(:bar, :default => 'Bah')
+    assert_equal 'Bah', I18n.t(:bah, :default => 'Bah') # default kicks in only here
+  end
+  
+  define_method "test: default" do
+    assert_equal 'Fuh',  I18n.t(:default => 'Fuh')
+    assert_equal 'Zero', I18n.t(:default => { :zero => 'Zero' }, :count => 0)
+    assert_equal({ :zero => 'Zero' }, I18n.t(:default => { :zero => 'Zero' }))
+    assert_equal 'Foo', I18n.t(:default => :foo)
+  end
+  
+  define_method "test: namespace lookup collects results from all backends" do
+    assert_equal({ :short => 'short', :long => 'long' }, I18n.t(:formats))
+  end
+  
+  define_method "test: namespace lookup with only the first backend returning a result" do
+    assert_equal({ :one => '{{count}}' }, I18n.t(:plural_1))
+  end
+  
+  define_method "test: pluralization still works" do
+    assert_equal '1',   I18n.t(:plural_1, :count => 1)
+    assert_equal 'one', I18n.t(:plural_2, :count => 1)
+  end
+  
+  define_method "test: bulk lookup collects results from all backends" do
+    assert_equal ['Foo', 'Bar'], I18n.t([:foo, :bar])
+  end
+
+  protected
+
+    def backend(translations)
+      backend = I18n::Backend::Simple.new
+      translations.each { |locale, translations| backend.store_translations(locale, translations) }
+      backend
+    end
+end

data/test/backend/fallbacks/api_test.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/fallbacks'
+
+module FallbacksSetup
+  def setup
+    super
+    I18n.backend.meta_class.send(:include, I18n::Backend::Fallbacks)
+  end
+end
+
+class I18nFallbacksBackendApiBasicsTest < Test::Unit::TestCase
+  include FallbacksSetup
+  include Tests::Backend::Api::Basics
+end
+
+class I18nFallbacksBackendApiTranslateTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Translation
+end
+
+class I18nFallbacksBackendApiInterpolateTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Interpolation
+end
+
+class I18nFallbacksBackendApiLambdaTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Lambda
+end
+
+class I18nFallbacksBackendApiTranslateLinkedTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Link
+end
+
+class I18nFallbacksBackendApiPluralizationTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include FallbacksSetup
+  include Tests::Backend::Api::Pluralization
+end
+
+class I18nFallbacksBackendApiLocalizeDateTest < Test::Unit::TestCase
+  include FallbacksSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::Date
+end
+
+class I18nFallbacksBackendApiLocalizeDateTimeTest < Test::Unit::TestCase
+  include FallbacksSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::DateTime
+end
+
+class I18nFallbacksBackendApiLocalizeTimeTest < Test::Unit::TestCase
+  include FallbacksSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::Time
+end
+
+class I18nFallbacksBackendApiLocalizeLambdaTest < Test::Unit::TestCase
+  include FallbacksSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::Lambda
+end
+

data/test/backend/fallbacks/fallbacks_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/fallbacks'
+
+class I18nFallbacksBackendTest < Test::Unit::TestCase
+  def setup
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend.meta_class.send(:include, I18n::Backend::Fallbacks)
+    backend_store_translations(:en, :foo => 'Foo')
+  end
+
+  define_method "test: fallbacks for :de are [:de, :en]" do
+    assert_equal [:de, :en], I18n.fallbacks[:de]
+  end
+  
+  define_method "test: still returns the English translation as usual" do
+    assert_equal 'Foo', I18n.t(:foo, :locale => :en)
+  end
+  
+  define_method "test: returns the English translation for a missing German translation" do
+    assert_equal 'Foo', I18n.t(:foo, :locale => :de)
+  end
+  
+  define_method "test: raises I18n::MissingTranslationData exception when no translation was found" do
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:bar, :locale => :en, :raise => true) }
+    assert_raises(I18n::MissingTranslationData) { I18n.t(:bar, :locale => :de, :raise => true) }
+  end
+end

data/test/backend/pluralization/api_test.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/pluralization'
+
+module PluralizationSetup
+  def setup
+    super
+    I18n.backend.meta_class.send(:include, I18n::Backend::Pluralization)
+    I18n.load_path << locales_dir + '/plurals.rb'
+  end
+end
+
+class I18nPluralizationBackendApiBasicsTest < Test::Unit::TestCase
+  include PluralizationSetup
+  include Tests::Backend::Api::Basics
+end
+
+class I18nPluralizationBackendApiTranslateTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include PluralizationSetup
+  include Tests::Backend::Api::Translation
+end
+
+class I18nPluralizationBackendApiInterpolateTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include PluralizationSetup
+  include Tests::Backend::Api::Interpolation
+end
+
+class I18nPluralizationBackendApiLambdaTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include PluralizationSetup
+  include Tests::Backend::Api::Lambda
+end
+
+class I18nPluralizationBackendApiTranslateLinkedTest < Test::Unit::TestCase
+  include Tests::Backend::Simple::Setup::Base
+  include PluralizationSetup
+  include Tests::Backend::Api::Link
+end
+
+class I18nPluralizationBackendApiPluralizeTest < Test::Unit::TestCase
+  include PluralizationSetup
+  include Tests::Backend::Simple::Setup::Base
+  include Tests::Backend::Api::Pluralization
+end
+
+class I18nPluralizationBackendApiLocalizeDateTest < Test::Unit::TestCase
+  include PluralizationSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::Date
+end
+
+class I18nPluralizationBackendApiLocalizeDateTimeTest < Test::Unit::TestCase
+  include PluralizationSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::DateTime
+end
+
+class I18nPluralizationBackendApiLocalizeTimeTest < Test::Unit::TestCase
+  include PluralizationSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::Time
+end
+
+class I18nPluralizationBackendApiLocalizeLambdaTest < Test::Unit::TestCase
+  include PluralizationSetup
+  include Tests::Backend::Simple::Setup::Localization
+  include Tests::Backend::Api::Localization::Lambda
+end
+

data/test/backend/pluralization/pluralization_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'i18n/backend/pluralization'
+
+class I18nPluralizationBackendTest < Test::Unit::TestCase
+  def setup
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend.meta_class.send(:include, I18n::Backend::Pluralization)
+    @pluralizer = lambda { |n| n == 1 ? :one : n == 0 || (2..10).include?(n % 100) ? :few : (11..19).include?(n % 100) ? :many : :other }
+    backend_store_translations(:foo, :i18n => { :pluralize => @pluralizer })
+    @entry = { :zero => 'zero', :one => 'one', :few => 'few', :many => 'many', :other => 'other' }
+  end
+
+  define_method :"test: pluralization picks a pluralizer from :'i18n.pluralize'" do
+    assert_equal @pluralizer, I18n.backend.send(:pluralizer, :foo)
+  end
+
+  define_method :"test: pluralization picks :one for 1" do
+    assert_equal 'one', I18n.t(:count => 1, :default => @entry, :locale => :foo)
+  end
+
+  define_method :"test: pluralization picks :few for 2" do
+    assert_equal 'few', I18n.t(:count => 2, :default => @entry, :locale => :foo)
+  end
+
+  define_method :"test: pluralization picks :many for 11" do
+    assert_equal 'many', I18n.t(:count => 11, :default => @entry, :locale => :foo)
+  end
+
+  define_method :"test: pluralization picks zero for 0 if the key is contained in the data" do
+    assert_equal 'zero', I18n.t(:count => 0, :default => @entry, :locale => :foo)
+  end
+
+  define_method :"test: pluralization picks few for 0 if the key is not contained in the data" do
+    @entry.delete(:zero)
+    assert_equal 'few', I18n.t(:count => 0, :default => @entry, :locale => :foo)
+  end
+end