i18n-inflector 2.0.1 → 2.1.0

data/test/inflector_test.rb

@@ -21,10 +21,22 @@ class I18nInflectorTest < Test::Unit::TestCase
                                               :default    => 'neutral' },
                                             :person => {
                                               :i   => 'I',
-                                              :you => 'You'}
+                                              :you => 'You'},
+                                            :@gender => {
+                                                :m => 'male',
+                                                :f => 'female',
+                                                :n => 'neuter',
+                                                :s => 'strange',
+                                                :masculine  => '@m',
+                                                :feminine   => '@f',
+                                                :neuter     => '@n',
+                                                :neutral    => '@neuter',
+                                                :default    => 'neutral' }
                                         }   })
 
-    store_translations(:xx, 'welcome' => 'Dear @{f:Lady|m:Sir|n:You|All}!')
+    store_translations(:xx, 'welcome'       => 'Dear @{f:Lady|m:Sir|n:You|All}!')
+    store_translations(:xx, 'named_welcome' => 'Dear @gender{f:Lady|m:Sir|n:You|All}!')
+    I18n.locale = :en
   end
 
   test "backend inflector has methods to test its switches" do
@@ -53,6 +65,13 @@ class I18nInflectorTest < Test::Unit::TestCase
     end
   end
 
+  test "backend inflector strict store_translations: allows duplicated tokens across differend kinds" do
+    assert_nothing_raised I18n::DuplicatedInflectionToken do
+      store_translations(:xx, :i18n => { :inflections => { :@gender => { :o => 'other' }, :@person => { :o => 'o' }}})
+      store_translations(:xx, :i18n => { :inflections => { :gender => { :o => 'other' },  :@gender => { :o => 'o' }}})
+    end
+  end
+
   test "backend inflector store_translations: raises I18n::BadInflectionAlias when bad alias is given" do
      assert_raise I18n::BadInflectionAlias do
        store_translations(:xx, :i18n => { :inflections => { :gender => { :o => '@nonexistant' }}})
@@ -60,18 +79,28 @@ class I18nInflectorTest < Test::Unit::TestCase
      assert_raise I18n::BadInflectionAlias do
        store_translations(:xx, :i18n => { :inflections => { :gender => { :default => '@nonexistant' }}})
      end
-   end
+      assert_raise I18n::BadInflectionAlias do
+        store_translations(:xx, :i18n => { :inflections => { :@gender => { :oh => '@nonex' }}})
+      end
+      assert_raise I18n::BadInflectionAlias do
+        store_translations(:xx, :i18n => { :inflections => { :@gender => { :default => '@nonex' }}})
+      end
+  end
 
-   test "backend inflector store_translations: raises I18n::BadInflectionToken when duplicated token is given" do
+  test "backend inflector store_translations: raises I18n::BadInflectionToken when bad token is given" do
      assert_raise I18n::BadInflectionToken do
        store_translations(:xx, :i18n => { :inflections => { :gender => { :o => '@' }}})
        store_translations(:xx, :i18n => { :inflections => { :gender => { :tok => nil }}})
+       store_translations(:xx, :i18n => { :inflections => { :@gender => { :o => '@' }}})
+       store_translations(:xx, :i18n => { :inflections => { :@gender => { :tok => nil }}})
      end
-   end
+  end
 
   test "backend inflector translate: allows pattern-only translation data" do
     store_translations(:xx, 'clear_welcome' => '@{f:Lady|m:Sir|n:You|All}')
     assert_equal 'Lady', I18n.t('clear_welcome', :gender => 'f', :locale => :xx)
+    store_translations(:xx, 'clear_welcome' => '@gender{f:Lady|m:Sir|n:You|All}')
+    assert_equal 'Lady', I18n.t('clear_welcome', :gender => 'f', :locale => :xx)
   end
 
   test "backend inflector translate: allows patterns to be escaped using @@ or \\@" do
@@ -166,10 +195,10 @@ class I18nInflectorTest < Test::Unit::TestCase
     tr = I18n.backend.send(:translations)
     tr[:xx][:i18n][:inflections][:gender].delete(:default)
     store_translations(:xx, :i18n => { :inflections => { :gender => { :o => 'other' }}})
-    assert_raise(I18n::InvalidOptionForKind) { I18n.t('welcome', :locale => :xx, :inflector_raises => true) }
-    assert_raise(I18n::InvalidOptionForKind) { I18n.t('welcome', :locale => :xx, :gender => "", :inflector_raises => true) }
-    assert_raise(I18n::InvalidOptionForKind) { I18n.t('welcome', :locale => :xx, :gender => nil, :inflector_raises => true) }
-    assert_raise I18n::InvalidOptionForKind do
+    assert_raise(I18n::InflectionOptionNotFound)  { I18n.t('welcome', :locale => :xx, :inflector_raises => true) }
+    assert_raise(I18n::InflectionOptionIncorrect) { I18n.t('welcome', :locale => :xx, :gender => "", :inflector_raises => true) }
+    assert_raise(I18n::InflectionOptionIncorrect) { I18n.t('welcome', :locale => :xx, :gender => nil, :inflector_raises => true) }
+    assert_raise I18n::InflectionOptionNotFound do
      I18n.inflector.options.raises = true
      I18n.t('welcome', :locale => :xx)
     end
@@ -196,6 +225,15 @@ class I18nInflectorTest < Test::Unit::TestCase
   test "backend inflector translate: works with %{} patterns" do
     store_translations(:xx, 'hi' => 'Dear @{f:Lady|m:%{test}}!')
     assert_equal 'Dear Dude!', I18n.t('hi', :gender => :m, :locale => :xx, :test => "Dude")
+    store_translations(:xx, 'to be'   => '%{person} @{i:am|you:are}')
+    assert_equal 'you are', I18n.t('to be', :person => :you, :locale => :xx)
+  end
+
+  test "backend inflector translate: works with doubled patterns" do
+    store_translations(:xx, 'dd' => 'Dear @{f:Lady|m:Sir|All}! Dear @{f:Lady|m:Sir|All}!')
+    assert_equal 'Dear Lady! Dear Lady!', I18n.t('dd', :gender => :f, :locale => :xx)
+    store_translations(:xx, 'hi' => 'Dear @{f:Lady|m:%{test}}! Dear @{f:Lady|m:%{test}}!')
+    assert_equal 'Dear Dude! Dear Dude!', I18n.t('hi', :gender => :m, :locale => :xx, :test => "Dude")
   end
 
   test "backend inflector translate: works with tokens separated by commas" do
@@ -205,10 +243,10 @@ class I18nInflectorTest < Test::Unit::TestCase
 
   test "backend inflector translate: works with negative tokens" do
     store_translations(:xx, 'hi' => 'Dear @{!m:Lady|m:Sir|n:You|All}!')
-    assert_equal 'Dear Lady!',  I18n.t('hi', :gender => :n, :locale => :xx)
-    assert_equal 'Dear Sir!',   I18n.t('hi', :gender => :m, :locale => :xx)
-    assert_equal 'Dear Lady!',  I18n.t('hi', :locale => :xx)
-    assert_equal 'Dear Lady!',  I18n.t('hi', :gender => :unknown, :locale => :xx)
+    assert_equal 'Dear Lady!',    I18n.t('hi', :gender => :n, :locale => :xx)
+    assert_equal 'Dear Sir!',     I18n.t('hi', :gender => :m, :locale => :xx)
+    assert_equal 'Dear Lady!',    I18n.t('hi', :locale => :xx)
+    assert_equal 'Dear Lady!',    I18n.t('hi', :gender => :unknown, :locale => :xx)
     store_translations(:xx, 'hi' => 'Hello @{!m:Ladies|n:You}')
     assert_equal 'Hello Ladies',  I18n.t('hi', :gender => :n, :locale => :xx)
     assert_equal 'Hello Ladies',  I18n.t('hi', :gender => :f, :locale => :xx)
@@ -242,11 +280,81 @@ class I18nInflectorTest < Test::Unit::TestCase
     assert_equal 'Dear Sir!', I18n.t('hi', :gender => :masculine, :locale => :xx)
   end
 
+  test "backend inflector translate: recognizes named patterns and strict kinds" do
+    store_translations(:xx, :i18n => { :inflections => { :@gender => { :s => 'sir', :o => 'other', :s => 'a', :n => 'n', :default => 'n' }}})
+    store_translations(:xx, 'hi'  => 'Dear @gender{s:Sir|o:Other|n:You|All}!')
+    assert_equal 'Dear Sir!',   I18n.t('hi', :gender  => :s,       :locale => :xx)
+    assert_equal 'Dear Other!', I18n.t('hi', :gender  => :o,       :locale => :xx)
+    assert_equal 'Dear You!',   I18n.t('hi',                       :locale => :xx)
+    assert_equal 'Dear You!',   I18n.t('hi', :gender  => "",       :locale => :xx)
+    assert_equal 'Dear You!',   I18n.t('hi', :gender  => :unknown, :locale => :xx)
+    assert_equal 'Dear You!',   I18n.t('hi', :@gender => :unknown, :locale => :xx)
+  end
+
+  test "backend inflector translate: prioritizes @-style kinds in options for named patterns" do
+    store_translations(:xx, :i18n => { :inflections => { :@gender => { :s => 'sir', :o => 'other', :s => 'a', :n => 'n', :default => 'n' }}})
+    store_translations(:xx, 'hi'  => 'Dear @gender{s:Sir|o:Other|n:You|All}!')
+    assert_equal 'Dear Sir!',   I18n.t('hi', :gender => :s,                       :locale => :xx)
+    assert_equal 'Dear You!',   I18n.t('hi', :gender => :s, :@gender => :unknown, :locale => :xx)
+    assert_equal 'Dear You!',   I18n.t('hi', :gender => :s, :@gender => nil,      :locale => :xx)
+    assert_equal 'Dear Sir!',   I18n.t('hi', :gender => :s, :@gender => :s,       :locale => :xx)
+
+  end
+
   test "inflector inflected_locales: lists languages that support inflection" do
     assert_equal [:xx], I18n.inflector.inflected_locales
     assert_equal [:xx], I18n.inflector.inflected_locales(:gender)
   end
 
+  test "inflector.strict inflected_locales: lists languages that support inflection" do
+    assert_equal [:xx], I18n.inflector.strict.inflected_locales
+    assert_equal [:xx], I18n.inflector.strict.inflected_locales(:gender)
+    store_translations(:yy, :i18n => { :inflections => { :@person => { :s => 'sir'}}})
+    assert_equal [:xx], I18n.inflector.strict.inflected_locales(:gender)
+    assert_equal [:yy], I18n.inflector.strict.inflected_locales(:person)
+    assert_equal [:xx], I18n.inflector.inflected_locales(:gender)
+    assert_equal [:yy], I18n.inflector.inflected_locales(:@person)
+    assert_equal [:xx,:yy], I18n.inflector.inflected_locales.sort{|k,v| k.to_s<=>v.to_s}
+    assert_equal [:xx,:yy], I18n.inflector.strict.inflected_locales.sort{|k,v| k.to_s<=>v.to_s}
+    store_translations(:zz, :i18n => { :inflections => { :some => { :s => 'sir'}}})
+    assert_equal [:xx,:yy,:zz], I18n.inflector.inflected_locales.sort{|k,v| k.to_s<=>v.to_s}
+    assert_equal [:xx,:yy],     I18n.inflector.strict.inflected_locales.sort{|k,v| k.to_s<=>v.to_s}
+    assert_equal [],            I18n.inflector.inflected_locales(:@some)
+    assert_equal [:zz],         I18n.inflector.inflected_locales(:some)
+  end
+
+  test "inflector inflected_locale?: tests if the given locale supports inflection" do
+    assert_equal true, I18n.inflector.inflected_locale?(:xx)
+    I18n.locale = :xx
+    assert_equal true, I18n.inflector.inflected_locale?
+  end
+
+  test "inflector.strict inflected_locale?: tests if the given locale supports inflection" do
+    assert_equal true, I18n.inflector.strict.inflected_locale?(:xx)
+    I18n.locale = :xx
+    assert_equal true, I18n.inflector.strict.inflected_locale?
+  end
+
+  test "inflector new_database creates a database with inflections" do
+    assert_kind_of I18n::Inflector::InflectionData, I18n.inflector.new_database(:yy)
+    assert_equal true,  I18n.inflector.inflected_locale?(:yy)
+    assert_equal false, I18n.inflector.inflected_locale?(:yyyyy)
+  end
+
+  test "inflector add_database adds existing database with inflections" do
+    db = I18n::Inflector::InflectionData.new(:zz)
+    assert_kind_of I18n::Inflector::InflectionData, I18n.inflector.add_database(db)
+    assert_equal true,  I18n.inflector.inflected_locale?(:zz)
+    assert_equal false, I18n.inflector.inflected_locale?(:zzzzzz)
+  end
+
+  test "inflector delete_database deletes existing inflections database" do
+    I18n.inflector.new_database(:vv)
+    assert_equal true,        I18n.inflector.inflected_locale?(:vv)
+    assert_kind_of NilClass,  I18n.inflector.delete_database(:vv)
+    assert_equal false,       I18n.inflector.inflected_locale?(:vv)
+  end
+
   test "inflector locale_supported?: checks if a language supports inflection" do
     assert_equal true,  I18n.inflector.locale_supported?(:xx)
     assert_equal false, I18n.inflector.locale_supported?(:pl)
@@ -262,29 +370,97 @@ class I18nInflectorTest < Test::Unit::TestCase
     assert_equal false, I18n.inflector.locale_supported?
   end
 
+  test "inflector.strict locale_supported?: checks if a language supports inflection" do
+    assert_equal true,  I18n.inflector.strict.locale_supported?(:xx)
+    assert_equal false, I18n.inflector.strict.locale_supported?(:pl)
+    assert_equal false, I18n.inflector.strict.locale_supported?(nil)
+    assert_equal false, I18n.inflector.strict.locale_supported?("")
+    I18n.locale = :xx
+    assert_equal true,  I18n.inflector.strict.locale_supported?
+    I18n.locale = :pl
+    assert_equal false, I18n.inflector.strict.locale_supported?
+    I18n.locale = nil
+    assert_equal false, I18n.inflector.strict.locale_supported?
+    I18n.locale = ""
+    assert_equal false, I18n.inflector.strict.locale_supported?
+  end
+
   test "inflector has_token?: checks if a token exists" do
     assert_equal true, I18n.inflector.has_token?(:neuter, :gender, :xx)
     assert_equal true, I18n.inflector.has_token?(:neuter, :xx)
-    assert_equal true, I18n.inflector.has_token?(:f, :xx)
-    assert_equal true, I18n.inflector.has_token?(:you, :xx)
+    assert_equal true, I18n.inflector.has_token?(:f,      :xx)
+    assert_equal true, I18n.inflector.has_token?(:you,    :xx)
     I18n.locale = :xx
     assert_equal true, I18n.inflector.has_token?(:f)
     assert_equal true, I18n.inflector.has_token?(:you)  
     assert_equal false,I18n.inflector.has_token?(:faafaffafafa)
   end
 
+  test "inflector.strict has_token?: checks if a token exists" do
+    assert_equal true,  I18n.inflector.strict.has_token?(:neuter,  :gender, :xx)
+    assert_equal true,  I18n.inflector.strict.has_token?(:f,       :gender, :xx)
+    assert_equal false, I18n.inflector.strict.has_token?(:you,     :gender)
+    I18n.locale = :xx
+    assert_equal true,  I18n.inflector.strict.has_token?(:f,       :gender)
+    assert_equal false, I18n.inflector.strict.has_token?(:you,     :gender)  
+    assert_equal false, I18n.inflector.strict.has_token?(:faafaffafafa)
+  end
+
+  test "inflector has_kind?: checks if an inflection kind exists" do
+    assert_equal true,  I18n.inflector.has_kind?(:gender, :xx)
+    assert_equal true,  I18n.inflector.has_kind?(:person, :xx)
+    assert_equal false, I18n.inflector.has_kind?(:nonono, :xx)
+    assert_equal false, I18n.inflector.has_kind?(nil,     :xx)
+    I18n.locale = :xx
+    assert_equal true,  I18n.inflector.has_kind?(:gender)
+    assert_equal true,  I18n.inflector.has_kind?(:person)
+    assert_equal false, I18n.inflector.has_kind?(:faafaffafafa)
+  end
+
+  test "inflector.strict has_kind?: checks if an inflection kind exists" do
+    assert_equal true,  I18n.inflector.strict.has_kind?(:gender, :xx)
+    assert_equal false, I18n.inflector.strict.has_kind?(:person, :xx)
+    assert_equal false, I18n.inflector.strict.has_kind?(nil,     :xx)
+    I18n.locale = :xx
+    assert_equal true,  I18n.inflector.strict.has_kind?(:gender)
+    assert_equal false, I18n.inflector.strict.has_kind?(nil)  
+    assert_equal false, I18n.inflector.strict.has_kind?(:faafaffa)
+  end
+
   test "inflector kind: checks what is the inflection kind of the given token" do
-    assert_equal :gender, I18n.inflector.kind(:neuter, :xx)
-    assert_equal :gender, I18n.inflector.kind(:f, :xx)
-    assert_equal :person, I18n.inflector.kind(:you, :xx)
+    assert_equal :gender, I18n.inflector.kind(:neuter,  :xx)
+    assert_equal :gender, I18n.inflector.kind(:f,       :xx)
+    assert_equal :person, I18n.inflector.kind(:you,     :xx)
+    assert_equal nil,     I18n.inflector.kind(nil,      :xx)
+    assert_equal nil,     I18n.inflector.kind(nil,      nil)
+    assert_equal nil,     I18n.inflector.kind(:nononono,:xx)
     I18n.locale = :xx
     assert_equal :gender, I18n.inflector.kind(:neuter)
     assert_equal :gender, I18n.inflector.kind(:f)
     assert_equal :person, I18n.inflector.kind(:you)  
-    assert_equal nil, I18n.inflector.kind(:faafaffafafa)
+    assert_equal nil,     I18n.inflector.kind(nil)
+    assert_equal nil,     I18n.inflector.kind(:faafaffa)
+  end
+
+  test "inflector.strict kind: checks what is the inflection kind of the given token" do
+    assert_equal :gender, I18n.inflector.strict.kind(:neuter,  :gender,  :xx)
+    assert_equal :gender, I18n.inflector.strict.kind(:f,       :gender,  :xx)
+    assert_equal nil, I18n.inflector.strict.kind(:f,           :nontrue, :xx)
+    assert_equal nil, I18n.inflector.strict.kind(:f,           nil,      :xx)
+    assert_equal nil, I18n.inflector.strict.kind(nil,          :gender,  :xx)
+    assert_equal nil, I18n.inflector.strict.kind(nil,          nil,      :xx)
+    assert_equal nil, I18n.inflector.strict.kind(:faafaffafafa, nil,     :xx)
+    assert_equal nil, I18n.inflector.strict.kind(:nil,         :faafafa, :xx)
+    I18n.locale = :xx
+    assert_equal :gender, I18n.inflector.strict.kind(:neuter,  :gender)
+    assert_equal :gender, I18n.inflector.strict.kind(:f,       :gender)
+    assert_equal nil,     I18n.inflector.strict.kind(:f,       :nontrue)
+    assert_equal nil,     I18n.inflector.strict.kind(nil,      :gender)
+    assert_equal nil,     I18n.inflector.strict.kind(nil,      nil)
+    assert_equal nil,     I18n.inflector.strict.kind(:faafaffa)
   end
 
-  test "inflector true_token: gets true token for a given token name" do
+  test "inflector true_token: gets true token for the given token name" do
     assert_equal :n,  I18n.inflector.true_token(:neuter, :xx)
     assert_equal :f,  I18n.inflector.true_token(:f, :xx)
     I18n.locale = :xx
@@ -293,19 +469,78 @@ class I18nInflectorTest < Test::Unit::TestCase
     assert_equal :f,  I18n.inflector.true_token(:f, :xx)
     assert_equal nil, I18n.inflector.true_token(:f, :person, :xx)
     assert_equal nil, I18n.inflector.true_token(:f, :nokind, :xx)
-    assert_equal nil, I18n.inflector.true_token(:faafaffafafa)
+    assert_equal nil, I18n.inflector.true_token(:faafaffa)
+  end
+
+  test "inflector.strict true_token: gets true token for the given token name" do
+    assert_equal :n,  I18n.inflector.strict.true_token(:neuter,  :gender,  :xx )
+    assert_equal :f,  I18n.inflector.strict.true_token(:f,       :gender,  :xx )
+    I18n.locale = :xx
+    assert_equal :n,  I18n.inflector.strict.true_token(:neuter,  :gender       )
+    assert_equal :f,  I18n.inflector.strict.true_token(:f,       :gender       )
+    assert_equal :f,  I18n.inflector.strict.true_token(:f,       :gender,  :xx )
+    assert_equal nil, I18n.inflector.strict.true_token(:f,       :person,  :xx )
+    assert_equal nil, I18n.inflector.strict.true_token(:f,       nil,      :xx )
+    assert_equal nil, I18n.inflector.strict.true_token(:faafaffa)
   end
 
-  test "inflector has_true_token?: tests if true token exists for a given token name" do
-    assert_equal false, I18n.inflector.has_true_token?(:neuter, :xx)
-    assert_equal true,  I18n.inflector.has_true_token?(:f, :xx)
+  test "inflector has_true_token?: tests if true token exists for the given token name" do
+    assert_equal false, I18n.inflector.has_true_token?(:neuter, :xx         )
+    assert_equal true,  I18n.inflector.has_true_token?(:f,      :xx         )
     I18n.locale = :xx
-    assert_equal false, I18n.inflector.has_true_token?(:neuter)
-    assert_equal true,  I18n.inflector.has_true_token?(:f)
-    assert_equal true,  I18n.inflector.has_true_token?(:f, :xx)
-    assert_equal false, I18n.inflector.has_true_token?(:f, :person, :xx)
-    assert_equal false, I18n.inflector.has_true_token?(:f, :nokind, :xx)
-    assert_equal false, I18n.inflector.has_true_token?(:faafaffafafa)
+    assert_equal false, I18n.inflector.has_true_token?(:neuter              )
+    assert_equal true,  I18n.inflector.has_true_token?(:f                   )
+    assert_equal true,  I18n.inflector.has_true_token?(:f,      :xx         )
+    assert_equal false, I18n.inflector.has_true_token?(:f,      :person, :xx)
+    assert_equal false, I18n.inflector.has_true_token?(:f,      :nokind, :xx)
+    assert_equal false, I18n.inflector.has_true_token?(:faafaff)
+  end
+
+  test "inflector strict markers: tests if named markers in kinds are working for API calls" do
+    tt= {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange"}
+    t = tt.merge({:masculine=>"male",:feminine=>"female",:neuter=>"neuter",:neutral=>"neuter"})
+    al= {:masculine=>:m,:feminine=>:f,:neuter=>:n,:neutral=>:n}
+    tr= tt.merge(al)
+    assert_equal [:xx],   I18n.inflector.inflected_locales(           :@gender      )
+    assert_equal t,       I18n.inflector.tokens(                      :@gender, :xx )
+    assert_equal tt,      I18n.inflector.true_tokens(                 :@gender, :xx )
+    assert_equal tr,      I18n.inflector.raw_tokens(                  :@gender, :xx )
+    assert_equal :n,      I18n.inflector.default_token(               :@gender, :xx )
+    assert_equal al,      I18n.inflector.aliases(                     :@gender, :xx )
+    assert_equal true,    I18n.inflector.has_kind?(                   :@gender, :xx )
+    assert_equal true,    I18n.inflector.has_alias?(        :neuter,  :@gender, :xx )
+    assert_equal true,    I18n.inflector.has_token?(        :n,       :@gender, :xx )
+    assert_equal false,   I18n.inflector.has_true_token?(   :neuter,  :@gender, :xx )
+    assert_equal true,    I18n.inflector.has_true_token?(   :n,       :@gender, :xx )
+    assert_equal :n,      I18n.inflector.true_token(        :neuter,  :@gender, :xx )
+    assert_equal "neuter",I18n.inflector.token_description( :neuter,  :@gender, :xx )
+    assert_equal "neuter",I18n.inflector.token_description( :n,       :@gender, :xx )
+    I18n.locale = :xx
+    assert_equal t,       I18n.inflector.tokens(                      :@gender      )
+    assert_equal tt,      I18n.inflector.true_tokens(                 :@gender      )
+    assert_equal tr,      I18n.inflector.raw_tokens(                  :@gender      )
+    assert_equal :n,      I18n.inflector.default_token(               :@gender      )
+    assert_equal al,      I18n.inflector.aliases(                     :@gender      )
+    assert_equal true,    I18n.inflector.has_kind?(                   :@gender      )
+    assert_equal true,    I18n.inflector.has_alias?(        :neuter,  :@gender      )
+    assert_equal true,    I18n.inflector.has_token?(        :n,       :@gender      )
+    assert_equal false,   I18n.inflector.has_true_token?(   :neuter,  :@gender      )
+    assert_equal true,    I18n.inflector.has_true_token?(   :n,       :@gender      )
+    assert_equal :n,      I18n.inflector.true_token(        :neuter,  :@gender      )
+    assert_equal "neuter",I18n.inflector.token_description( :neuter,  :@gender      )
+    assert_equal "neuter",I18n.inflector.token_description( :n,       :@gender      )
+  end
+
+  test "inflector.strict has_true_token?: tests if true token exists for the given token name" do
+    assert_equal false, I18n.inflector.strict.has_true_token?(:neuter, :gender,  :xx )
+    assert_equal true,  I18n.inflector.strict.has_true_token?(:f,      :gender,  :xx )
+    I18n.locale = :xx
+    assert_equal false, I18n.inflector.strict.has_true_token?(:neuter, :gender       )
+    assert_equal true,  I18n.inflector.strict.has_true_token?(:f,      :gender       )
+    assert_equal true,  I18n.inflector.strict.has_true_token?(:f,      :gender,  :xx )
+    assert_equal false, I18n.inflector.strict.has_true_token?(:f,      :person,  :xx )
+    assert_equal false, I18n.inflector.strict.has_true_token?(:f,      nil,      :xx )
+    assert_equal false, I18n.inflector.strict.has_true_token?(:faafaff)
   end
 
   test "inflector kinds: lists inflection kinds" do
@@ -315,6 +550,13 @@ class I18nInflectorTest < Test::Unit::TestCase
     assert_equal [:gender,:person], I18n.inflector.kinds.sort{|k,v| k.to_s<=>v.to_s}
   end
 
+  test "inflector.strict kinds: lists inflection kinds" do
+    assert_not_nil I18n.inflector.strict.kinds(:xx)
+    assert_equal [:gender], I18n.inflector.strict.kinds(:xx)
+    I18n.locale = :xx
+    assert_equal [:gender], I18n.inflector.strict.kinds
+  end
+
   test "inflector tokens: lists all inflection tokens including aliases" do
     h = {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange",
          :masculine=>"male",:feminine=>"female",:neuter=>"neuter",
@@ -326,6 +568,16 @@ class I18nInflectorTest < Test::Unit::TestCase
     assert_equal ha,  I18n.inflector.tokens
   end
 
+  test "inflector.strict tokens: lists all inflection tokens including aliases" do
+    h = {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange",
+         :masculine=>"male",:feminine=>"female",:neuter=>"neuter",
+         :neutral=>"neuter"}
+    assert_equal h,   I18n.inflector.strict.tokens(:gender, :xx)
+    I18n.locale = :xx
+    assert_equal h,   I18n.inflector.strict.tokens(:gender)
+    assert_equal Hash.new, I18n.inflector.strict.tokens
+  end
+
   test "inflector true_tokens: lists true tokens" do
     h  = {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange"}
     ha = h.merge(:i=>"I",:you=>"You")
@@ -335,6 +587,14 @@ class I18nInflectorTest < Test::Unit::TestCase
     assert_equal ha,  I18n.inflector.true_tokens
   end
 
+  test "inflector.strict true_tokens: lists true tokens" do
+    h  = {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange"}
+    assert_equal h,   I18n.inflector.strict.true_tokens(:gender, :xx)
+    I18n.locale = :xx
+    assert_equal h,   I18n.inflector.strict.true_tokens(:gender)
+    assert_equal Hash.new, I18n.inflector.strict.true_tokens
+  end
+
   test "inflector raw_tokens: lists tokens in a so called raw format" do
     h = {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange",
          :masculine=>:m,:feminine=>:f,:neuter=>:n,
@@ -346,12 +606,28 @@ class I18nInflectorTest < Test::Unit::TestCase
     assert_equal ha,  I18n.inflector.raw_tokens    
   end
 
+  test "inflector.strict raw_tokens: lists tokens in a so called raw format" do
+    h = {:m=>"male",:f=>"female",:n=>"neuter",:s=>"strange",
+         :masculine=>:m,:feminine=>:f,:neuter=>:n,
+         :neutral=>:n}
+    assert_equal h,   I18n.inflector.strict.raw_tokens(:gender, :xx)
+    I18n.locale = :xx
+    assert_equal h,   I18n.inflector.strict.raw_tokens(:gender)
+    assert_equal Hash.new, I18n.inflector.strict.raw_tokens    
+  end
+
   test "inflector default_token: returns a default token for a kind" do
     assert_equal :n, I18n.inflector.default_token(:gender, :xx)
     I18n.locale = :xx
     assert_equal :n, I18n.inflector.default_token(:gender)
   end
 
+  test "inflector.strict default_token: returns a default token for a kind" do
+    assert_equal :n, I18n.inflector.strict.default_token(:gender, :xx)
+    I18n.locale = :xx
+    assert_equal :n, I18n.inflector.strict.default_token(:gender)
+  end
+
   test "inflector aliases: lists aliases" do
     a = {:masculine=>:m, :feminine=>:f, :neuter=>:n, :neutral=>:n}
     assert_equal a, I18n.inflector.aliases(:gender, :xx)
@@ -360,22 +636,46 @@ class I18nInflectorTest < Test::Unit::TestCase
     assert_equal a, I18n.inflector.aliases
   end
 
+  test "inflector.strict aliases: lists aliases" do
+    a = {:masculine=>:m, :feminine=>:f, :neuter=>:n, :neutral=>:n}
+    assert_equal a, I18n.inflector.strict.aliases(:gender, :xx)
+    I18n.locale = :xx
+    assert_equal a, I18n.inflector.strict.aliases(:gender)
+    assert_equal Hash.new, I18n.inflector.strict.aliases
+  end
+
   test "inflector token_description: returns token's description" do
     assert_equal "male",    I18n.inflector.token_description(:m, :xx)
     I18n.locale = :xx
     assert_equal "male",    I18n.inflector.token_description(:m)
-    assert_equal nil,       I18n.inflector.token_description(:nonexistent, :xx)
-    assert_equal "neuter",  I18n.inflector.token_description(:neutral, :xx)
+    assert_equal nil,       I18n.inflector.token_description(:nonexistent,  :xx)
+    assert_equal "neuter",  I18n.inflector.token_description(:neutral,      :xx)
+  end
+
+  test "inflector.strict token_description: returns token's description" do
+    assert_equal "male",    I18n.inflector.strict.token_description(:m, :gender, :xx)
+    I18n.locale = :xx
+    assert_equal "male",    I18n.inflector.strict.token_description(:m,            :gender)
+    assert_equal nil,       I18n.inflector.strict.token_description(:nonexistent,  :gender, :xx)
+    assert_equal "neuter",  I18n.inflector.strict.token_description(:neutral,      :gender, :xx)
   end
 
   test "inflector has_alias?: tests whether a token is an alias" do
       assert_equal true,  I18n.inflector.has_alias?(:neutral, :xx)
-      assert_equal false, I18n.inflector.has_alias?(:you, :xx)
+      assert_equal false, I18n.inflector.has_alias?(:you,     :xx)
       assert_equal true,  I18n.inflector.has_alias?(:neutral, :gender, :xx)
-      assert_equal false, I18n.inflector.has_alias?(:you, :gender, :xx)
+      assert_equal false, I18n.inflector.has_alias?(:you,     :gender, :xx)
       assert_equal false, I18n.inflector.has_alias?(:neutral, :nokind, :xx)
       I18n.locale = :xx
       assert_equal true,  I18n.inflector.has_alias?(:neutral)
   end
 
+  test "inflector.strict has_alias?: tests whether a token is an alias" do
+      assert_equal true,  I18n.inflector.strict.has_alias?(:neutral, :gender, :xx)
+      assert_equal false, I18n.inflector.strict.has_alias?(:you,     :person, :xx)
+      assert_equal false, I18n.inflector.strict.has_alias?(:you,     :gender, :xx)
+      I18n.locale = :xx
+      assert_equal true,  I18n.inflector.strict.has_alias?(:neutral, :gender)
+  end
+
 end

data/test/test_helper.rb

@@ -9,7 +9,7 @@ class Test::Unit::TestCase
     I18n.load_path          = []
     I18n.available_locales  = nil
     I18n.backend            = nil
-  end
+  end if not method_defined?(:teardown)
 
   def translations
     I18n.backend.instance_variable_get(:@translations)

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 2
-  - 0
   - 1
-  version: 2.0.1
+  - 0
+  version: 2.1.0
 platform: ruby
 authors: 
 - "Pawe\xC5\x82 Wilk"
@@ -34,7 +34,7 @@ cert_chain:
   NK3TIZaPCh1S2/ES6wXNvjQ+5EnEEL9j/pSEop9DYEBPaM2WDVR5i0jJTAaRWw==
   -----END CERTIFICATE-----
 
-date: 2011-01-15 00:00:00 +01:00
+date: 2011-01-27 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -160,7 +160,9 @@ files:
 - README.rdoc
 - Rakefile
 - ci/i18n-inflector.gemspec
+- ci/i18nv4-Gemfile
 - docs/COPYING
+- docs/EXAMPLES
 - docs/HISTORY
 - docs/LEGAL
 - docs/LGPL
@@ -168,13 +170,16 @@ files:
 - docs/TODO
 - docs/rdoc.css
 - lib/i18n-inflector.rb
+- lib/i18n-inflector/api.rb
+- lib/i18n-inflector/api_strict.rb
 - lib/i18n-inflector/backend.rb
 - lib/i18n-inflector/errors.rb
 - lib/i18n-inflector/inflection_data.rb
+- lib/i18n-inflector/inflection_data_strict.rb
 - lib/i18n-inflector/inflector.rb
+- lib/i18n-inflector/lazy_enum.rb
 - lib/i18n-inflector/long_comments.rb
 - lib/i18n-inflector/options.rb
-- lib/i18n-inflector/util.rb
 - lib/i18n-inflector/version.rb
 - test/inflector_test.rb
 - test/test_helper.rb
@@ -194,7 +199,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -2908677002477829649
+      hash: 3836781751216313437
       segments: 
       - 0
       version: "0"
@@ -203,7 +208,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -2908677002477829649
       segments: 
       - 0
       version: "0"

data/lib/i18n-inflector/util.rb

@@ -1,67 +0,0 @@
-# encoding: utf-8
-#
-# Author::    Paweł Wilk (mailto:pw@gnu.org)
-# Copyright:: (c) 2011 by Paweł Wilk
-# License::   This program is licensed under the terms of {file:LGPL GNU Lesser General Public License} or {file:COPYING Ruby License}.
-# 
-# This file contains utility methods,
-# that are used by I18n::Inflector.
-
-module I18n
-  module Inflector
-
-    # This module contains some methods that are helpful.
-    module Util
-
-      protected
-
-      # Processes +locale+ name and validates
-      # if it's correct (not empty and not +nil+).
-      # 
-      # @note If the +locale+ is not correct, it
-      #   tries to use locale from {I18n.locale} and validates it
-      #   as well.
-      # @param [Symbol,String] locale the locale identifier
-      # @raise [I18n::InvalidLocale] if there is no proper locale name
-      # @return [Symbol] the given locale or the global locale
-      def prep_locale(locale=nil)
-        locale ||= I18n.locale
-        raise I18n::InvalidLocale.new(locale) if locale.to_s.empty?
-        locale.to_sym
-      end
-
-      # This method is the internal helper that prepares arguments
-      # containing +token+, +kind+ and +locale+.
-      # 
-      # @note This method leaves +kind+ as is when it's +nil+ or empty. It sets
-      #   +token+ to +nil+ when it's empty.
-      # @raise [I18n::InvalidLocale] if there is no proper locale name
-      # @raise [ArgumentError] if the count of arguments is invalid
-      # @return [Array<Symbol,Symbol,Symbol>] the array containing
-      #   cleaned and validated +token+, +kind+ and +locale+
-      # @overload tkl_args(token, kind, locale)
-      #   Prepares arguments containing +token+, +kind+ and +locale+.
-      #   @param [String,Hash] token the token
-      #   @param [String,Hash] kind the inflection kind
-      #   @param [String,Hash] locale the locale identifier
-      #   @return [Array<Symbol,Symbol,Symbol>] the array containing
-      #     cleaned and validated +token+, +kind+ and +locale+
-      # @overload tkl_args(token, locale)
-      #   Prepares arguments containing +token+ and +locale+.
-      #   @param [String,Hash] token the token
-      #   @param [String,Hash] locale the locale identifier
-      #   @return [Array<Symbol,Symbol,Symbol>] the array containing
-      #     cleaned and validated +token+, +kind+ and +locale+
-      def tkl_args(args)
-        token, kind, locale = case args.count
-        when 1 then [args[0], nil, nil]
-        when 2 then [args[0], nil, args[1]]
-        when 3 then args
-        else raise ArgumentError.new("wrong number of arguments: #{args.count} for (1..3)")
-        end
-        [token,kind,locale]
-      end
-
-    end
-  end
-end