thedarkone-i18n 0.1.4 → 0.2.0

data/lib/i18n/locale/fallbacks.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+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.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+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/lib/i18n/locale/tag/parents.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+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,78 @@
+# encoding: utf-8
+
+# 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,44 @@
+# encoding: utf-8
+
+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/test/all.rb

@@ -1,7 +1,5 @@
-dir = File.dirname(__FILE__)
-require dir + '/i18n_test.rb'
-require dir + '/backend_test.rb'
-require dir + '/i18n_exceptions_test.rb'
-require dir + '/fast_backend_test.rb'
-require dir + '/pluralization_compiler_test.rb'
-# *require* dir + '/custom_backend_test.rb'
+# encoding: utf-8
+
+Dir[File.dirname(__FILE__) + '/**/*_test.rb'].sort.each do |file|
+  require file
+end

data/test/api/basics.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Tests
+  module Backend
+    module Api
+      module Basics
+        def test_available_locales
+          backend_store_translations 'de', :foo => 'bar'
+          backend_store_translations 'en', :foo => 'foo'
+          assert_equal ['de', 'en'], I18n.backend.available_locales.map{|locale| locale.to_s }.sort
+        end
+      end
+    end
+  end
+end

data/test/api/interpolation.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module Tests
+  module Backend
+    module Api
+      module Interpolation
+        def interpolate(options)
+          I18n.backend.translate('en', nil, options)
+        end
+
+        def test_interpolation_given_no_interpolation_values_it_does_not_alter_the_string
+          assert_equal 'Hi {{name}}!', interpolate(:default => 'Hi {{name}}!')
+        end
+
+        def test_interpolation_given_interpolation_values_it_interpolates_the_values_to_the_string
+          assert_equal 'Hi David!', interpolate(:default => 'Hi {{name}}!', :name => 'David')
+        end
+
+        def test_interpolation_given_interpolation_values_with_nil_values_it_interpolates_the_values_to_the_string
+          assert_equal 'Hi !', interpolate(:default => 'Hi {{name}}!', :name => nil)
+        end
+
+        def test_interpolation_given_a_lambda_as_a_value_it_calls_it_when_the_string_contains_the_key
+          assert_equal 'Hi David!', interpolate(:default => 'Hi {{name}}!', :name => lambda { 'David' })
+        end
+
+        def test_interpolation_given_a_lambda_as_a_value_it_does_not_call_it_when_the_string_does_not_contain_the_key
+          assert_nothing_raised { interpolate(:default => 'Hi!', :name => lambda { raise 'fail' }) }
+        end
+
+        def test_interpolation_given_interpolation_values_but_missing_a_key_it_raises_a_missing_interpolation_argument_exception
+          assert_raises(I18n::MissingInterpolationArgument) do
+            interpolate(:default => '{{foo}}', :bar => 'bar')
+          end
+        end
+
+        def test_interpolation_does_not_raise_missing_interpolation_argument_exceptions_for_escaped_variables
+          assert_nothing_raised(I18n::MissingInterpolationArgument) do
+            assert_equal 'Barr {{foo}}', interpolate(:default => '{{bar}} \{{foo}}', :bar => 'Barr')
+          end
+        end
+
+        def test_interpolate_with_ruby_1_9_syntax
+          assert_equal 'Hi David!', interpolate(:default => 'Hi %{name}!', :name => 'David')
+        end
+
+        def test_interpolate_given_a_value_hash_interpolates_into_unicode_string
+          assert_equal 'Häi David!', interpolate(:default => 'Häi {{name}}!', :name => 'David')
+        end
+
+        def test_interpolate_given_a_unicode_value_hash_interpolates_to_the_string
+          assert_equal 'Hi ゆきひろ!', interpolate(:default => 'Hi {{name}}!', :name => 'ゆきひろ')
+        end
+
+        def test_interpolate_given_a_unicode_value_hash_interpolates_into_unicode_string
+          assert_equal 'こんにちは、ゆきひろさん!', interpolate(:default => 'こんにちは、{{name}}さん!', :name => 'ゆきひろ')
+        end
+
+        if Kernel.const_defined?(:Encoding)
+          def test_interpolate_given_a_non_unicode_multibyte_value_hash_interpolates_into_a_string_with_the_same_encoding
+            assert_equal euc_jp('Hi ゆきひろ!'), interpolate(:default => 'Hi {{name}}!', :name => euc_jp('ゆきひろ'))
+          end
+
+          def test_interpolate_given_a_unicode_value_hash_into_a_non_unicode_multibyte_string_raises_encoding_compatibility_error
+            assert_raises(Encoding::CompatibilityError) do
+              interpolate(:default => euc_jp('こんにちは、{{name}}さん!'), :name => 'ゆきひろ')
+            end
+          end
+
+          def test_interpolate_given_a_non_unicode_multibyte_value_hash_into_an_unicode_string_raises_encoding_compatibility_error
+            assert_raises(Encoding::CompatibilityError) do
+              interpolate(:default => 'こんにちは、{{name}}さん!', :name => euc_jp('ゆきひろ'))
+            end
+          end
+        end
+
+        def test_interpolate_given_a_string_containing_a_reserved_key_raises_reserved_interpolation_key
+          assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '{{default}}',   :foo => :bar) }
+          assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '{{scope}}',     :foo => :bar) }
+          assert_raises(I18n::ReservedInterpolationKey) { interpolate(:default => '{{separator}}', :foo => :bar) }
+        end
+      end
+    end
+  end
+end

data/test/api/lambda.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module Tests
+  module Backend
+    module Api
+      module Lambda
+        def test_translate_simple_proc
+          setup_proc_translations
+          assert_equal 'bar=bar, baz=baz, foo=foo', I18n.backend.translate('en', :a_lambda, :foo => 'foo', :bar => 'bar', :baz => 'baz')
+        end
+
+        def test_translate_proc_in_defaults
+          setup_proc_translations
+          assert_equal 'bar=bar, baz=baz, foo=foo', I18n.backend.translate('en', :does_not_exist, :default => :a_lambda, :foo => 'foo', :bar => 'bar', :baz => 'baz')
+          assert_equal 'bar=bar, baz=baz, foo=foo', I18n.backend.translate('en', :does_not_exist, :default => [:does_not_exist_2, :does_not_exist_3, :a_lambda], :foo => 'foo', :bar => 'bar', :baz => 'baz')
+        end
+
+        def test_translate_proc_with_pluralize
+          setup_proc_translations
+          params = { :zero => 'zero', :one => 'one', :other => 'other' }
+          assert_equal 'zero',  I18n.backend.translate('en', :lambda_for_pluralize, params.merge(:count => 0))
+          assert_equal 'one',   I18n.backend.translate('en', :lambda_for_pluralize, params.merge(:count => 1))
+          assert_equal 'other', I18n.backend.translate('en', :lambda_for_pluralize, params.merge(:count => 2))
+        end
+
+        def test_translate_proc_with_interpolate
+          setup_proc_translations
+          assert_equal 'bar baz foo', I18n.backend.translate('en', :lambda_for_interpolate, :foo => 'foo', :bar => 'bar', :baz => 'baz')
+        end
+
+        def test_translate_with_proc_as_default
+          expected = 'result from lambda'
+          assert_equal expected, I18n.backend.translate(:en, :'does not exist', :default => lambda { |key, values| expected })
+        end
+
+        private
+
+          def setup_proc_translations
+            I18n.backend.store_translations 'en', {
+              :a_lambda => lambda { |key, values|
+                values.keys.sort_by(&:to_s).collect { |key| "#{key}=#{values[key]}"}.join(', ')
+              },
+              :lambda_for_pluralize => lambda { |key, values| values },
+              :lambda_for_interpolate => lambda { |key, values|
+                "{{#{values.keys.sort_by(&:to_s).join('}} {{')}}}"
+              }
+            }
+          end
+      end
+    end
+  end
+end