i18n 0.4.2 → 0.5.0beta1

data/lib/i18n/tests/localization/time.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module I18n
+  module Tests
+    module Localization
+      module Time
+        def setup
+          super
+          setup_time_translations
+          @time = ::Time.parse('2008-03-01 6:00 UTC')
+          @other_time = ::Time.parse('2008-03-01 18:00 UTC')
+        end
+
+        test "localize Time: given the short format it uses it" do
+          # TODO should be Mrz, shouldn't it?
+          assert_equal '01. Mar 06:00', I18n.l(@time, :format => :short, :locale => :de)
+        end
+
+        test "localize Time: given the long format it uses it" do
+          assert_equal '01. März 2008 06:00', I18n.l(@time, :format => :long, :locale => :de)
+        end
+
+        # TODO Seems to break on Windows because ENV['TZ'] is ignored. What's a better way to do this?
+        # def test_localize_given_the_default_format_it_uses_it
+        #   assert_equal 'Sa, 01. Mar 2008 06:00:00 +0000', I18n.l(@time, :format => :default, :locale => :de)
+        # end
+
+        test "localize Time: given a day name format it returns the correct day name" do
+          assert_equal 'Samstag', I18n.l(@time, :format => '%A', :locale => :de)
+        end
+
+        test "localize Time: given an abbreviated day name format it returns the correct abbreviated day name" do
+          assert_equal 'Sa', I18n.l(@time, :format => '%a', :locale => :de)
+        end
+
+        test "localize Time: given a month name format it returns the correct month name" do
+          assert_equal 'März', I18n.l(@time, :format => '%B', :locale => :de)
+        end
+
+        test "localize Time: given an abbreviated month name format it returns the correct abbreviated month name" do
+          # TODO should be Mrz, shouldn't it?
+          assert_equal 'Mar', I18n.l(@time, :format => '%b', :locale => :de)
+        end
+
+        test "localize Time: given a meridian indicator format it returns the correct meridian indicator" do
+          assert_equal 'am', I18n.l(@time, :format => '%p', :locale => :de)
+          assert_equal 'pm', I18n.l(@other_time, :format => '%p', :locale => :de)
+        end
+
+        test "localize Time: given an unknown format it does not fail" do
+          assert_nothing_raised { I18n.l(@time, :format => '%x') }
+        end
+
+        test "localize Time: given a format is missing it raises I18n::MissingTranslationData" do
+          assert_raise(I18n::MissingTranslationData) { I18n.l(@time, :format => :missing) }
+        end
+
+        protected
+
+          def setup_time_translations
+            I18n.backend.store_translations :de, {
+              :time => {
+                :formats => {
+                  :default => "%a, %d. %b %Y %H:%M:%S %z",
+                  :short => "%d. %b %H:%M",
+                  :long => "%d. %B %Y %H:%M",
+                },
+                :am => 'am',
+                :pm => 'pm'
+              }
+            }
+          end
+      end
+    end
+  end
+end

data/lib/i18n/tests/lookup.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+module I18n
+  module Tests
+    module Lookup
+      def setup
+        super
+        I18n.backend.store_translations(:en, :foo => { :bar => 'bar', :baz => 'baz' }, :falsy => false, :truthy => true,
+          :string => "a", :array => %w(a b c), :hash => { "a" => "b" })
+      end
+
+      test "lookup: it returns a string" do
+        assert_equal("a", I18n.t(:string))
+      end
+
+      test "lookup: it returns hash" do
+        assert_equal({ :a => "b" }, I18n.t(:hash))
+      end
+
+      test "lookup: it returns a array" do
+        assert_equal(%w(a b c), I18n.t(:array))
+      end
+
+      test "lookup: it returns a native true" do
+        assert I18n.t(:truthy) === true
+      end
+
+      test "lookup: it returns a native false" do
+        assert I18n.t(:falsy) === false
+      end
+
+      test "lookup: given a missing key, no default and no raise option it returns an error message" do
+        assert_equal "translation missing: en.missing", I18n.t(:missing)
+      end
+
+      test "lookup: given a missing key, no default and the raise option it raises MissingTranslationData" do
+        assert_raise(I18n::MissingTranslationData) { I18n.t(:missing, :raise => true) }
+      end
+
+      test "lookup: does not raise an exception if no translation data is present for the given locale" do
+        assert_nothing_raised { I18n.t(:foo, :locale => :xx) }
+      end
+
+      test "lookup: given an array of keys it translates all of them" do
+        assert_equal %w(bar baz), I18n.t([:bar, :baz], :scope => [:foo])
+      end
+
+      test "lookup: 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('foo|bar', :separator => '|')
+      end
+
+      # 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.
+      test "lookup: given nil as a locale it does not raise but use the default locale" do
+        # assert_raise(I18n::InvalidLocale) { I18n.t(:bar, :locale => nil) }
+        assert_nothing_raised { I18n.t(:bar, :locale => nil) }
+      end
+
+      test "lookup: a resulting String is not frozen" do
+        assert !I18n.t(:string).frozen?
+      end
+
+      test "lookup: a resulting Array is not frozen" do
+        assert !I18n.t(:array).frozen?
+      end
+
+      test "lookup: a resulting Hash is not frozen" do
+        assert !I18n.t(:hash).frozen?
+      end
+    end
+  end
+end

data/lib/i18n/tests/pluralization.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module I18n
+  module Tests
+    module Pluralization
+      test "pluralization: given 0 it returns the :zero translation if it is defined" do
+        assert_equal 'zero', I18n.t(:default => { :zero => 'zero' }, :count => 0)
+      end
+
+      test "pluralization: given 0 it returns the :other translation if :zero is not defined" do
+        assert_equal 'bars', I18n.t(:default => { :other => 'bars' }, :count => 0)
+      end
+
+      test "pluralization: given 1 it returns the singular translation" do
+        assert_equal 'bar', I18n.t(:default => { :one => 'bar' }, :count => 1)
+      end
+
+      test "pluralization: given 2 it returns the :other translation" do
+        assert_equal 'bars', I18n.t(:default => { :other => 'bars' }, :count => 2)
+      end
+
+      test "pluralization: given 3 it returns the :other translation" do
+        assert_equal 'bars', I18n.t(:default => { :other => 'bars' }, :count => 3)
+      end
+
+      test "pluralization: given nil it returns the whole entry" do
+        assert_equal({ :one => 'bar' }, I18n.t(:default => { :one => 'bar' }, :count => nil))
+      end
+
+      test "pluralization: given incomplete pluralization data it raises I18n::InvalidPluralizationData" do
+        assert_raise(I18n::InvalidPluralizationData) { I18n.t(:default => { :one => 'bar' }, :count => 2) }
+      end
+    end
+  end
+end

data/lib/i18n/tests/procs.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module I18n
+  module Tests
+    module Procs
+      test "lookup: given a translation is a proc it calls the proc with the key and interpolation values" do
+        I18n.backend.store_translations(:en, :a_lambda => lambda { |*args| filter_args(*args) })
+        assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(:a_lambda, :foo => 'foo')
+      end
+
+      test "defaults: given a default is a Proc it calls it with the key and interpolation values" do
+        proc = lambda { |*args| filter_args(*args) }
+        assert_equal '[nil, {:foo=>"foo"}]', I18n.t(nil, :default => proc, :foo => 'foo')
+      end
+
+      test "defaults: given a default is a key that resolves to a Proc it calls it with the key and interpolation values" do
+        I18n.backend.store_translations(:en, :a_lambda => lambda { |*args| filter_args(*args) })
+        assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(nil, :default => :a_lambda, :foo => 'foo')
+        assert_equal '[:a_lambda, {:foo=>"foo"}]', I18n.t(nil, :default => [nil, :a_lambda], :foo => 'foo')
+      end
+
+      test "interpolation: given an interpolation value is a lambda it calls it with key and values before interpolating it" do
+        proc = lambda { |*args| filter_args(*args) }
+        assert_match %r(\[\{:foo=>#<Proc.*>\}\]), I18n.t(nil, :default => '%{foo}', :foo => proc)
+      end
+
+      test "interpolation: given a key resolves to a Proc that returns a string then interpolation still works" do
+        proc = lambda { |*args| "%{foo}: " + filter_args(*args) }
+        assert_equal 'foo: [nil, {:foo=>"foo"}]', I18n.t(nil, :default => proc, :foo => 'foo')
+      end
+
+      test "pluralization: given a key resolves to a Proc that returns valid data then pluralization still works" do
+        proc = lambda { |*args| { :zero => 'zero', :one => 'one', :other => 'other' } }
+        assert_equal 'zero',  I18n.t(:default => proc, :count => 0)
+        assert_equal 'one',   I18n.t(:default => proc, :count => 1)
+        assert_equal 'other', I18n.t(:default => proc, :count => 2)
+      end
+
+      test "lookup: given the option :resolve => false was passed it does not resolve proc translations" do
+        I18n.backend.store_translations(:en, :a_lambda => lambda { |*args| filter_args(*args) })
+        assert_equal Proc, I18n.t(:a_lambda, :resolve => false).class
+      end
+
+      test "lookup: given the option :resolve => false was passed it does not resolve proc default" do
+        assert_equal Proc, I18n.t(nil, :default => lambda { |*args| filter_args(*args) }, :resolve => false).class
+      end
+
+      protected
+
+      def filter_args(*args)
+        args.map {|arg| arg.delete(:fallback) if arg.is_a?(Hash) ; arg }.inspect
+      end
+    end
+  end
+end

data/lib/i18n/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: i18n
 version: !ruby/object:Gem::Version 
-  hash: 11
-  prerelease: false
+  hash: -1150612293
+  prerelease: true
   segments: 
   - 0
-  - 4
-  - 2
-  version: 0.4.2
+  - 5
+  - 0beta1
+  version: 0.5.0beta1
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-26 00:00:00 +02:00
+date: 2010-11-14 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -34,10 +34,6 @@ extra_rdoc_files: []
 files: 
 - lib/i18n.rb
 - lib/i18n/backend.rb
-- lib/i18n/backend/active_record.rb
-- lib/i18n/backend/active_record/missing.rb
-- lib/i18n/backend/active_record/store_procs.rb
-- lib/i18n/backend/active_record/translation.rb
 - lib/i18n/backend/base.rb
 - lib/i18n/backend/cache.rb
 - lib/i18n/backend/cascade.rb
@@ -66,6 +62,19 @@ files:
 - lib/i18n/locale/tag/parents.rb
 - lib/i18n/locale/tag/rfc4646.rb
 - lib/i18n/locale/tag/simple.rb
+- lib/i18n/tests.rb
+- lib/i18n/tests/basics.rb
+- lib/i18n/tests/defaults.rb
+- lib/i18n/tests/interpolation.rb
+- lib/i18n/tests/link.rb
+- lib/i18n/tests/localization.rb
+- lib/i18n/tests/localization/date.rb
+- lib/i18n/tests/localization/date_time.rb
+- lib/i18n/tests/localization/procs.rb
+- lib/i18n/tests/localization/time.rb
+- lib/i18n/tests/lookup.rb
+- lib/i18n/tests/pluralization.rb
+- lib/i18n/tests/procs.rb
 - lib/i18n/version.rb
 - README.textile
 - MIT-LICENSE

data/lib/i18n/backend/active_record.rb

@@ -1,61 +0,0 @@
-require 'i18n/backend/base'
-require 'i18n/backend/active_record/translation'
-
-module I18n
-  module Backend
-    class ActiveRecord
-      autoload :Missing,     'i18n/backend/active_record/missing'
-      autoload :StoreProcs,  'i18n/backend/active_record/store_procs'
-      autoload :Translation, 'i18n/backend/active_record/translation'
-
-      module Implementation
-        include Base, Flatten
-
-        def available_locales
-          begin
-            Translation.available_locales
-          rescue ::ActiveRecord::StatementInvalid
-            []
-          end
-        end
-
-        def store_translations(locale, data, options = {})
-          escape = options.fetch(:escape, true)
-          flatten_translations(locale, data, escape, false).each do |key, value|
-            Translation.locale(locale).lookup(expand_keys(key)).delete_all
-            Translation.create(:locale => locale.to_s, :key => key.to_s, :value => value)
-          end
-        end
-
-      protected
-
-        def lookup(locale, key, scope = [], options = {})
-          key = normalize_flat_keys(locale, key, scope, options[:separator])
-          result = Translation.locale(locale).lookup(key).all
-
-          if result.empty?
-            nil
-          elsif result.first.key == key
-            result.first.value
-          else
-            chop_range = (key.size + FLATTEN_SEPARATOR.size)..-1
-            result = result.inject({}) do |hash, r|
-              hash[r.key.slice(chop_range)] = r.value
-              hash
-            end
-            result.deep_symbolize_keys
-          end
-        end
-
-        # For a key :'foo.bar.baz' return ['foo', 'foo.bar', 'foo.bar.baz']
-        def expand_keys(key)
-          key.to_s.split(FLATTEN_SEPARATOR).inject([]) do |keys, key|
-            keys << [keys.last, key].compact.join(FLATTEN_SEPARATOR)
-          end
-        end
-      end
-
-      include Implementation
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-#  This extension stores translation stub records for missing translations to
-#  the database.
-#
-#  This is useful if you have a web based translation tool. It will populate
-#  the database with untranslated keys as the application is being used. A
-#  translator can then go through these and add missing translations.
-#
-#  Example usage:
-#
-#     I18n::Backend::Chain.send(:include, I18n::Backend::ActiveRecord::Missing)
-#     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.
-#
-#  For example:
-#
-#    # en.yml
-#    en:
-#      i18n:
-#        plural:
-#          keys: [:zero, :one, :other]
-#
-#    # pl.yml
-#    pl:
-#      i18n:
-#        plural:
-#          keys: [:zero, :one, :few, :other]
-#
-#  It will also persist interpolation keys in Translation#interpolations so
-#  translators will be able to review and use them.
-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, :scope, :default, :separator)
-          separator ||= I18n.default_separator
-          key = normalize_flat_keys(locale, key, scope, separator)
-
-          unless ActiveRecord::Translation.locale(locale).lookup(key).exists?
-            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
-
-        def store_default_translation(locale, key, interpolations)
-          translation = ActiveRecord::Translation.new :locale => locale.to_s, :key => key
-          translation.interpolations = interpolations
-          translation.save
-        end
-
-        def translate(locale, key, options = {})
-          super
-        rescue I18n::MissingTranslationData => e
-          self.store_default_translations(locale, key, options)
-          raise e
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# This module is intended to be mixed into the ActiveRecord backend to allow
-# storing Ruby Procs as translation values in the database.
-#
-#   I18n.backend = I18n::Backend::ActiveRecord.new
-#   I18n::Backend::ActiveRecord::Translation.send(:include, I18n::Backend::ActiveRecord::StoreProcs)
-#
-# The StoreProcs module requires the ParseTree and ruby2ruby gems and therefor
-# 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
-        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) if method(:to_s).respond_to?(:to_ruby)
-      end
-    end
-  end
-end