zhongwen_tools 0.12.4 → 0.15.1

data/lib/zhongwen_tools/uri.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require 'uri'
+
+module ZhongwenTools
+  module URI
+    def self.encode(str)
+      ::URI.encode str
+    end
+
+    def self.escape(str)
+      ::URI.escape(str, Regexp.new("[^#{ ::URI::PATTERN::UNRESERVED }]"))
+    end
+  end
+end

data/lib/zhongwen_tools/version.rb

@@ -1,3 +1,3 @@
 module ZhongwenTools
-  VERSION = '0.12.4'
+  VERSION = '0.15.1'
 end

data/lib/zhongwen_tools/zhongwen.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'zhongwen_tools/regex'
+module ZhongwenTools
+  module Zhongwen
+    def self.has_zh?(str)
+      return false unless str.class == String
+
+      regex = /(#{ ZhongwenTools::Regex.zh }|#{ ZhongwenTools::Regex.zh_punc })/
+      !str[regex].nil?
+    end
+
+    def self.zh?(str)
+      return false unless str.class == String
+
+      regex = /(#{ ZhongwenTools::Regex.zh }+|#{ ZhongwenTools::Regex.zh_punc }+|\s+)/
+      str.scan(regex).join == str
+    end
+
+    def self.has_zh_punctuation?(str)
+      return false unless str.class == String
+
+      !str[ZhongwenTools::Regex.zh_punc].nil?
+    end
+
+    def self.strip_zh_punctuation(str)
+      str.gsub(ZhongwenTools::Regex.zh_punc, '')
+    end
+  end
+end

data/lib/zhongwen_tools.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
-require 'zhongwen_tools/string'
-require 'zhongwen_tools/numbers'
-require 'zhongwen_tools/version'
+require 'zhongwen_tools/script'
+require 'zhongwen_tools/core'
 
 module ZhongwenTools
 end

data/test/test_caps.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require './test/test_helper'
+require 'zhongwen_tools/caps'
+
+class TestCaps < Minitest::Test
+  def test_downcase
+    assert_equal @caps[:d], ZhongwenTools::Caps.downcase(@caps[:u])
+    assert_equal @caps[:d], ZhongwenTools::Caps.downcase(@caps[:c])
+  end
+
+  def test_upcase
+    assert_equal @caps[:u], ZhongwenTools::Caps.upcase(@caps[:d])
+    assert_equal @caps[:u], ZhongwenTools::Caps.upcase(@caps[:c])
+  end
+
+  def test_capitalize
+    assert_equal @caps[:c], ZhongwenTools::Caps.capitalize(@caps[:d])
+  end
+
+  def setup
+    @caps = { u: 'ĀLĀBÓ', d: 'ālābó', c: 'Ālābó' }
+  end
+end
+

data/test/test_core.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require './test/test_helper'
+
+class TestCore < Minitest::Test
+  def test_core_ext_does_not_have_script_functions
+    load 'test_helpers/unload_zhongwen_tools_script.rb'
+    require 'zhongwen_tools/core'
+    require 'zhongwen_tools/core_ext/string'
+    assert_raises(NoMethodError){ '你们'.to_zht }
+  end
+end

data/test/test_fullwidth.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require './test/test_helper'
+require 'zhongwen_tools/fullwidth'
+class TestFullwidth < Minitest::Test
+  def setup
+    @hw = 'hello'
+    @fw = 'ｈeｌｌｏ'
+    @mixed = 'hellｏ'
+  end
+
+  def test_halfwidth?
+    assert ZhongwenTools::Fullwidth.halfwidth? @hw
+    refute ZhongwenTools::Fullwidth.halfwidth? @fw
+    refute ZhongwenTools::Fullwidth.halfwidth? @mixed
+  end
+
+  def test_fullwidth?
+    refute ZhongwenTools::Fullwidth.fullwidth? @hw
+    assert ZhongwenTools::Fullwidth.fullwidth? @fw
+    assert ZhongwenTools::Fullwidth.fullwidth? @mixed
+  end
+
+  def test_to_halfwidth
+    assert_equal @hw, ZhongwenTools::Fullwidth.to_halfwidth(@fw)
+    assert_equal @hw, ZhongwenTools::Fullwidth.to_halfwidth(@mixed)
+  end
+end
+

data/test/test_helper.rb

@@ -12,17 +12,9 @@ rescue LoadError
 end
 
 gem 'minitest'
-require 'minitest/autorun'
-#require 'test/unit'
+gem 'minitest-reporters'
 
-if RUBY_VERSION < '1.9'
-  class Minitest::Test
-    def refute(statement, message = '')
-      assert !statement, message
-    end
+require 'minitest/autorun'
+require "minitest/reporters"
 
-    def skip
-      return
-    end
-  end
-end
+Minitest::Reporters.use!  [Minitest::Reporters::SpecReporter.new]

data/test/test_helpers/unload_zhongwen_tools_script.rb

@@ -0,0 +1,5 @@
+module ZhongwenTools
+  [:Script].each do |sub_module|
+    remove_const(sub_module)  if const_defined?(sub_module)
+  end
+end

data/test/test_integer_extension.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require './test/test_helper'
+require 'zhongwen_tools/integer_extension'
+
+if RUBY_VERSION < '2.0.0'
+  Integer.send(:include, ZhongwenTools::IntegerExtension)
+else
+  using ZhongwenTools
+end
+
+class TestIntegerExtention < Minitest::Test
+  def test_to_zh
+    assert_equal @yi[:zhs], @yi[:i].to_zh(:zhs)
+    assert_equal @yi[:zht], @yi[:i].to_zh(:zht)
+  end
+
+  def test_to_zht
+    assert_equal @yi[:zht], @yi[:i].to_zht
+  end
+
+  def test_to_zhs
+    assert_equal @yi[:zhs], @yi[:i].to_zhs
+  end
+
+  def test_to_pyn
+    assert_equal @yi[:pyn], @yi[:i].to_pyn
+  end
+
+  def setup
+    @yi = { i: 10_000, zhs: '一万', zht: '一萬', pyn: 'yi1-wan4' }
+  end
+end

data/test/test_number.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require './test/test_helper'
+require 'zhongwen_tools/number'
+class TestNumber < Minitest::Test
+  def setup
+    @numbers = [
+      { zhs: '一万二千七', zht: '一萬二千七', i: 12_007, pyn: 'yi1-wan4-er4-qian1-qi1' },
+      { zhs: '三千六十三', zht: '三千六十三', i: 3_063, pyn: 'san1-qian1-liu4-shi2-san1' },
+      { zhs: '一百五十',   zht: '一百五十', i: 150, pyn: 'yi1-bai2-wu3-shi2' },
+      #{ zhs: '三千亿', i: 300_000_000_000, pyn: '' },
+    ]
+
+    @liang_number = { zhs: '一万两千七', i: 12_007, pyn: '' }
+    @date_numbers = [
+      { zhs: '一九六六', i: 1966, pyn: '' },
+      { zhs: '二零零八', i: 2008, pyn: '' },
+    ]
+  end
+
+  def test_number?
+    assert ZhongwenTools::Number.number? '一'
+    assert ZhongwenTools::Number.number? 1
+
+    @numbers.map{ |n| n[:zhs]}.each do |zh|
+      assert ZhongwenTools::Number.number?(zh), "#{zh}"
+    end
+  end
+
+  def test_to_pyn
+    # same tests
+    @numbers.each do |n|
+      [:i, :pyn, :zhs, :zht].each do |type|
+        assert_equal n[:pyn], ZhongwenTools::Number.to_pyn(n[type])
+      end
+    end
+
+  end
+
+  def test_to_zhs
+    @numbers.each do |n|
+      [:i, :pyn, :zht, :zhs].each do |type|
+        assert_equal n[:zhs], ZhongwenTools::Number.to_zhs(n[type])
+      end
+    end
+  end
+
+  def test_to_zht
+    @numbers.each do |n|
+      [:i, :pyn, :zhs, :zht].each do |type|
+        assert_equal n[:zht], ZhongwenTools::Number.to_zht(n[type])
+      end
+    end
+  end
+
+  def test_to_zh
+    @numbers.each do |n|
+      [:i, :pyn, :zhs, :zht].each do |type|
+        assert_equal n[:zhs], ZhongwenTools::Number.to_zh(n[type], :zhs)
+        assert_equal n[:zht], ZhongwenTools::Number.to_zh(n[type], :zht)
+      end
+    end
+  end
+
+  def test_to_i
+    assert_equal @liang_number[:i], ZhongwenTools::Number.to_i(@liang_number[:zhs])
+
+    @numbers.each do |n|
+      [:pyn, :zhs, :zht].each do |type|
+        assert_equal n[:i], ZhongwenTools::Number.to_i(n[type])
+      end
+    end
+
+    @date_numbers.each do |n|
+        assert_equal n[:i], ZhongwenTools::Number.to_i(n[:zhs])
+    end
+  end
+end

data/test/test_pinyin.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require './test/test_helper'
+require 'zhongwen_tools/romanization/pinyin'
+class TestPinyin < Minitest::Test
+  def test_split_pyn
+     @split_words.each do |w|
+      assert_equal w[:split], ZhongwenTools::Romanization::Pinyin.split_pyn(w[:pyn])
+    end
+  end
+
+  def test_split_py
+    @split_words.each do |w|
+      assert_equal w[:split_py], ZhongwenTools::Romanization::Pinyin.split_py(w[:py])
+    end
+  end
+
+  def test_py?
+    @words.each do |w|
+      assert ZhongwenTools::Romanization::Pinyin.py?(w[:py]), w.inspect
+      refute ZhongwenTools::Romanization::Pinyin.py?(w[:pyn]), w.inspect
+    end
+  end
+
+  def test_pyn?
+    @words.each do |w|
+      refute ZhongwenTools::Romanization::Pinyin.pyn?(w[:py]), w.inspect
+      assert ZhongwenTools::Romanization::Pinyin.pyn?(w[:pyn]), w.inspect
+    end
+  end
+
+  def test_pyn_to_pinyin
+    [@hyphenated_words, @words].flatten.each do |word|
+      assert_equal word[:py], ZhongwenTools::Romanization::Pinyin.to_pinyin(word[:pyn])
+      assert_equal word[:py], ZhongwenTools::Romanization::Pinyin.to_py(word[:pyn])
+    end
+  end
+
+  def test_pinyin_to_pyn
+    @words.each do |word|
+      assert_equal word[:pyn], ZhongwenTools::Romanization::Pinyin.to_pyn(word[:py])
+    end
+  end
+
+  def setup
+    @hyphenated_words = [
+      {:pyn => 'A1-la1-bo2', :py => 'Ālābó'},
+      { :pyn => 'Mao2 Ze2-dong1', :py => 'Máo Zédōng' }
+    ]
+
+    @split_words = [
+      {:pyn => 'A1-la1-bo2',  :py => 'Ālābó', :split => %w(A1 la1 bo2), split_py: %w(Ā lā bó) },
+      { :pyn => 'Mao2 Ze2-dong1',  :py => 'Máo Zédōng', :split => %w(Mao2 Ze2 dong1), :split_py =>  %w(Máo Zé dōng) }
+    ]
+
+
+    @words = [
+      {:pyn => 'A1la1bo2', :py => 'Ālābó'},
+      { :pyn => 'ni3 hao3', :py => 'nǐ hǎo' },
+      { :pyn => 'Zhong1guo2', :py => 'Zhōngguó' },
+      { :pyn => 'chui1 niu3', :py => "chuī niǔ" },
+      { :pyn => 'Mao2 Ze2dong1', :py => 'Máo Zédōng' },
+    ]
+
+    @r =  { :pyn => 'r5', :py => 'r' }
+  end
+end

data/test/test_regex.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require './test/test_helper'
+require 'zhongwen_tools/regex'
+class TestRegex < Minitest::Test
+
+  def test_pyn_regexes
+    assert 'hao3'[ZhongwenTools::Regex.pyn]
+  end
+
+  def test_py_regexes
+    assert 'hǎo'[ZhongwenTools::Regex.py ]
+  end
+
+  def test_numbers
+    str = '二'
+    assert str, str[ZhongwenTools::Regex.zh_numbers]
+
+    str = '两'
+    assert str[ZhongwenTools::Regex.zhs_numbers]
+    refute str[ZhongwenTools::Regex.zht_numbers]
+
+    str = '兩'
+    refute str[ZhongwenTools::Regex.zhs_numbers]
+    assert str[ZhongwenTools::Regex.zht_numbers]
+  end
+
+  def test_punctuation
+    refute '.'[ZhongwenTools::Regex.zh_punc]
+    assert '.'[ZhongwenTools::Regex.punc]
+    assert '。'[ZhongwenTools::Regex.zh_punc]
+    refute '。'[ZhongwenTools::Regex.punc]
+  end
+
+  def test_zh
+    assert '中'[ZhongwenTools::Regex.zh]
+    refute 'a'[ZhongwenTools::Regex.zh]
+    refute 'ご'[ZhongwenTools::Regex.zh]
+  end
+end

data/test/test_romanization.rb

@@ -1,168 +1,145 @@
-#encoding: utf-8
+# encoding: utf-8
 $:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
 require './test/test_helper'
-require 'zhongwen_tools/string'
 require 'zhongwen_tools/romanization'
-
-class String
-  include ZhongwenTools::Romanization
-end
-
 class TestRomanization < Minitest::Test
 
-  def test_pinyin
-    assert_equal 'Zhōng wén','Zhong1 wen2'.to_pinyin
-    assert_equal 'Zhōngwén', 'Zhong1-wen2'.to_pinyin
-    assert_equal "Tiān'ānmén",'Tian1an1men2'.to_pinyin
-    assert_equal @alabo[:py], @alabo[:pyn].to_pinyin
-    assert_equal 'r', 'r5'.to_pinyin
-    #wg -> py not yet implemented
-    #mzd = "Mao Tse-tung"
-    #assert_equal "Mao Zedong", mzd.to_pinyin(:wg)
-    assert @alabo[:py].py?
-    assert 'Ā-lā-bó'.py?
-    assert 'Zhong1 wen2'.to_pinyin.py?
+  def test_romanization_modules
+    [:Pinyin, :ZhuyinFuhao, :WadeGiles, :Yale, :TongyongPinyin, :MPS2].each do |module_name|
+      assert ZhongwenTools::Romanization.const_defined?(module_name)
+    end
+  end
 
-    @romanizations.each do |rom|
-      rom.each do |type, entry|
-        if type == :bopomofo
-        assert_equal rom[:py].downcase, entry.to_pinyin(type).downcase, "to_pinyin(#{type}) should convert to pinyin." 
-        assert_equal rom[:py].downcase, entry.to_pinyin.downcase, "to_pinyin(#{type}) should convert to pinyin, but it isn't detected properly"
-        else
-        assert_equal rom[:py], entry.to_pinyin(type), "to_pinyin(#{type}) should convert to pinyin." 
-        assert_equal rom[:py], entry.to_pinyin, "to_pinyin(#{type}) should convert to pinyin, but it isn't detected properly" unless type == :typy
-        end
+  def test_zhuyin_fuhao_method_names
+    @romanization_hashes.each do |module_name, method_names|
+      rom_module =  ZhongwenTools::Romanization.const_get(module_name)
+      singleton_methods = rom_module.singleton_methods
+      method_names.map{ |x| "to_#{x}".to_sym }.each do |method_name|
+        message = "#{rom_module} should have method called #{ method_name }"
+        assert singleton_methods.include?(method_name), message
       end
     end
   end
 
-  def test_pyn
-    assert_equal 'ni3 hao3', @py.to_pyn(:py)
-    assert_equal 'tian1an1men2', 'tian1an1men2'.to_py.to_pyn(:py)
-
-    assert_equal 'yi4', 'yì'.to_pyn(:py)
+  def test_split_methods
+    @romanizations.each do |romanization|
+      length = romanization == @romanizations.last ? 3 : 2
 
-    assert_equal 'ni3 hao3', 'ㄋㄧ3 ㄏㄠ3'.to_pyn(:bpmf)
-    assert_equal 'ni3 hao3', 'ㄋㄧ3 ㄏㄠ3'.to_pyn
-    assert_equal 'zhong1 guo2', 'chung1 kuo2'.to_pyn(:wg)
-    assert_equal 'zhong1 guo2', 'chung1 kuo2'.to_pyn
-    assert_equal 'chui1 niu3', 'chuei1 niou3'.to_pyn(:typy)
-    assert_equal 'cao3 di4', 'tsau3 di4'.to_pyn(:mspy2)
-    assert_equal 'cao3 di4', 'tsau3 di4'.to_pyn
-    assert_equal 'cao3 di4', 'tsau3 di4'.to_pyn(:yale)
-    assert_equal 'cao3 di4', 'tsau3 di4'.to_pyn
-
-
-    assert_equal 'Wo3men5', "Wǒmen".to_pyn(:py)
-    assert_equal 'hao3xue2', 'hǎoxué'.to_pyn(:py)
-    assert_equal 'tai4re4', 'tàirè'.to_pyn(:py)
-    assert_equal 'tai4tai5', "tàitai".to_pyn(:py)
-    #assert_equal 'Wu1-lu2-ha1-nuo4-fu1', 'Wūlúhānuòfū'.to_pyn(:py)
-    #"007：Dàpò Liàngzǐ Wēijī", "007: Da4po4 Liang4zi3 Wei1ji1"
+      assert_equal length, ZhongwenTools::Romanization::ZhuyinFuhao.split(romanization[:bpmf]).length
+      assert_equal length, ZhongwenTools::Romanization::WadeGiles.split(romanization[:wg]).length
+      assert_equal length, ZhongwenTools::Romanization::Yale.split(romanization[:yale]).length
+      assert_equal length, ZhongwenTools::Romanization::TongyongPinyin.split(romanization[:typy]).length
+      assert_equal length, ZhongwenTools::Romanization::MPS2.split(romanization[:mps2]).length
+    end
   end
 
   def test_zhuyin_fuhao
-     assert_equal 'ㄋㄧ3 ㄏㄠ3', @str.to_bpmf
-     assert_equal 'ㄋㄧ3 ㄏㄠ3', @str.to_bopomofo
-     assert_equal 'ㄋㄧ3 ㄏㄠ3', @str.to_zhuyin
-     assert_equal 'ㄇㄠ2 ㄗㄜ2 ㄉㄨㄥ1', @mzd.to_zhuyin_fuhao
-     assert_equal 'ㄑㄧㄥ3 ㄏㄨㄟ2ㄉㄚ2 ㄨㄛ3 ㄉㄜ5 ㄨㄣ4ㄊㄧ2 .', @sent.to_zhuyin
-     assert_equal 'ㄇㄠ2 ㄗㄜ2ㄉㄨㄥ1', @mzd2.to_zhuyin_fuhao
-     assert 'ㄋㄧ3 ㄏㄠ3'.zyfh?
-
-     assert_equal 'ㄋㄧ3 ㄏㄠ3', 'ni3 hau3'.to_bpmf(:yale)
-
-     t = :bopomofo
-    @romanizations.each do |rom|
-      rom.each do |type, entry|
-        #if type == :bopomofo
-        assert_equal rom[t].downcase, entry.send("to_#{t}", type).downcase, "to_#{t}(#{type}) should convert to #{t}." 
-        assert_equal rom[t].downcase, entry.send("to_#{t}").downcase, "to_#{t}(#{type}) should convert to #{t}, but it isn't detected properly"
-        #else
-        #assert_equal rom[:t], entry.to_pinyin(type), "to_pinyin(#{type}) should convert to pinyin." 
-        #assert_equal rom[:t], entry.to_pinyin, "to_pinyin(#{type}) should convert to pinyin, but it isn't detected properly" unless type == :typy
-        #end
-      end
+    type = :bpmf
+    @romanizations.each do |romanization|
+      assert_equal type, ZhongwenTools::Romanization.romanization?(romanization[type])
+      assert_equal romanization[type], ZhongwenTools::Romanization::ZhuyinFuhao.to_bpmf(romanization[:pyn])
+      # NOTE: Zhuyin Fuhao doesn't encode capitilization information.
+      expected_result = romanization[:pyn].downcase.gsub('-', '')
+      py_result = romanization[:py].downcase
+      assert_equal expected_result, ZhongwenTools::Romanization::Pinyin::to_pyn(romanization[type])
+      assert_equal py_result, ZhongwenTools::Romanization::Pinyin::to_py(romanization[type])
     end
   end
 
   def test_wade_giles
-    assert_equal 'kuo1', 'guo1'.to_wg
-    assert_equal 'chung1 kuo2', 'zhong1 guo2'.to_wg
-    assert_equal 'Mao2 Tse2 tung1', @mzd.to_wg
-    assert_equal 'Mao2 Tse2-tung1', @mzd2.to_wade_giles
-    assert_equal 'Mao2 Tse2-tung1 te5 mao2', 'Mao2 Ze2-dong1 de5 mao2'.to_wade_giles
-
-    assert_equal 'ni3 hao3', 'ni3 hau3'.to_wg(:yale)
-  end
-
-  #def test_mspy2
-    #skip
-    #assert_equal '', @str.to_mspy2
-  #end
-
-  def test_typy
-    #skip
-    pyn = 'chui1 niu3'
-    typy = 'chuei1 niou3'
-    assert_equal typy, pyn.to_typy
-    # FIXME: to_typy doesn't work with non-spaced pinyin.
-    #assert_equal typy, typy.to_pyn(:typy)
-    assert typy.typy?
-    refute pyn.typy?
+    type = :wg
+    @romanizations.each do |romanization|
+      assert ZhongwenTools::Romanization::WadeGiles.wg?(romanization[type])
+      assert_equal romanization[type], ZhongwenTools::Romanization::WadeGiles.to_wg(romanization[:pyn])
+      expected_result = romanization[:pyn]
+      assert_equal expected_result, ZhongwenTools::Romanization::Pinyin::to_pyn(romanization[type], type)
+      assert_equal romanization[:py], ZhongwenTools::Romanization::Pinyin::to_py(romanization[type])
+    end
   end
 
   def test_yale
-    assert_equal 'ni3 hau3', @str.to_yale
-
-    assert_equal 'chwei1 nyou3', 'chuei1 niou3'.to_yale(:typy)
+    type = :yale
+    @romanizations.each do |romanization|
+      assert_equal type, ZhongwenTools::Romanization.romanization?(romanization[type])
+      assert_equal romanization[type], ZhongwenTools::Romanization::Yale.to_yale(romanization[:pyn])
+      expected_result = romanization[:pyn]
+      assert_equal expected_result, ZhongwenTools::Romanization::Pinyin::to_pyn(romanization[type])
+      assert_equal romanization[:py], ZhongwenTools::Romanization::Pinyin::to_py(romanization[type])
+    end
   end
 
-  def test_romanization?
-    assert_equal :pyn, @alabo[:pyn].romanization?
-    assert_equal :py, @alabo[:py].romanization?
-    assert_equal :zyfh, 'ㄋㄧ3 ㄏㄠ3'.romanization?
-    assert_equal :wg, @mzd.to_wg(:pyn).romanization?
+  def test_tongyong_pinyin
+    type = :typy
+    @romanizations.each do |romanization|
+      assert ZhongwenTools::Romanization::TongyongPinyin.typy?(romanization[type])
+      assert_equal romanization[type], ZhongwenTools::Romanization::TongyongPinyin.to_typy(romanization[:pyn])
+      expected_result = romanization[:pyn]
+      assert_equal expected_result, ZhongwenTools::Romanization::Pinyin::to_pyn(romanization[type], type)
+      assert_equal romanization[:py], ZhongwenTools::Romanization::Pinyin::to_py(romanization[type], type)
+    end
   end
 
-  def test_detect
-    assert @str.pyn?
-    assert " #{@str}".pyn?
-    refute 'Ardanz'.pyn?
-    refute @py.pyn?
+  def test_mps2
+    type = :mps2
 
-    assert 'chung1 kuo2'.wg?
-
-    assert @py.py?, "#{@py} should be pinyin. (#{@py.py?})" unless RUBY_VERSION < '1.9'
-    assert 'chuei1 niou3'.typy?
-    assert 'ㄋㄧ3 ㄏㄠ3'.bpmf?
-    assert 'ni3 hau3'.yale?
-    assert 'tsuen'.mps2?
-  end
-
-  def test_split_pyn
-    assert_equal 'zhong1guo2'.split_pyn, %w(zhong1 guo2)
-    assert_equal 'dong1xi'.split_pyn, %w(dong1 xi)
-    assert_equal 'zhongguo'.split_pyn, %w(zhong guo)
-    assert_equal 'dong1 xi1 '.split_pyn, %w(dong1 xi1)
-    assert_equal @mzd2.split_pyn, %w(Mao2 Ze2 dong1)
+    @romanizations.each do |romanization|
+      assert ZhongwenTools::Romanization::MPS2.mps2?(romanization[type])
+      assert_equal romanization[type], ZhongwenTools::Romanization::MPS2.to_mps2(romanization[:pyn])
+      expected_result = romanization[:pyn]
+      assert_equal expected_result, ZhongwenTools::Romanization::Pinyin::to_pyn(romanization[type], type)
+      assert_equal romanization[:py], ZhongwenTools::Romanization::Pinyin::to_py(romanization[type], type)
+    end
   end
 
   def setup
+    @romanization_hashes = {
+      ZhuyinFuhao: %w(bpmf zhuyin_fuhao zhuyinfuhao zyfh zhyfh),
+      WadeGiles: %w(wg wade_giles),
+      Yale: ['yale'],
+      TongyongPinyin: %w(typy tongyong tongyong_pinyin),
+      MPS2: ['mps2']
+    }
+
     @romanizations = [
       # FIXME: bopomofo, tongyong pinyin, wade-giles tones are all wrong.
       # TODO: test IPA
-      { :pyn => 'ni3 hao3', :py => 'nǐ hǎo', :bopomofo => 'ㄋㄧ3 ㄏㄠ3', :yale => 'ni3 hau3', :typy => 'ni3 hao3', :wg => 'ni3 hao3'},#, :ipa => ''}
-      { :pyn => 'Zhong1guo2', :py => 'Zhōngguó', :bopomofo => 'ㄓㄨㄥ1ㄍㄨㄛ2', :yale => 'Jung1gwo2', :typy => 'Jhong1guo2', :wg => 'Chung1kuo2'},#, :ipa => ''}
-      { :pyn => 'chui1 niu3', :py => "chuī niǔ", :bopomofo =>  "ㄔㄨㄟ1 ㄋㄧㄡ3", :yale => "chwei1 nyou3", :typy => "chuei1 niou3", :wg => "ch`ui1 niu3"},#, :ipa => ''}
-      { :pyn => 'Mao2 Ze2-dong1', :py => 'Máo Zédōng', :bopomofo => 'ㄇㄠ2 ㄗㄜ2ㄉㄨㄥ1', :yale => 'Mau2 Dze2-dung1', :typy => 'Mao2 Ze2-dong1', :wg => 'Mao2 Tse2-tung1'},#, :ipa => ''}
+      {
+        pyn: 'ni3 hao3',
+        py: 'nǐ hǎo',
+        bpmf: 'ㄋㄧ3 ㄏㄠ3',
+        yale: 'ni3 hau3',
+        typy: 'ni3 hao3',
+        wg: 'ni3 hao3',
+        mps2: 'ni3 hau3'
+      },
+      {
+        pyn: 'Zhong1guo2',
+        py: 'Zhōngguó',
+        bpmf: 'ㄓㄨㄥ1ㄍㄨㄛ2',
+        yale: 'Jung1gwo2',
+        typy: 'Jhong1guo2',
+        wg: 'Chung1kuo2',
+        mps2: 'Jung1guo2',
+      },
+      {
+        pyn: 'chui1 niu3',
+        py: 'chuī niǔ',
+        bpmf:  "ㄔㄨㄟ1 ㄋㄧㄡ3",
+        yale: "chwei1 nyou3",
+        typy: "chuei1 niou3",
+        wg: "ch`ui1 niu3",
+        mps2: 'chuei1 niou3'
+      },
+      {
+        pyn: 'Mao2 Ze2-dong1',
+        py: 'Máo Zédōng',
+        bpmf: 'ㄇㄠ2 ㄗㄜ2ㄉㄨㄥ1',
+        yale: 'Mau2 Dze2-dung1',
+        typy: 'Mao2 Ze2-dong1',
+        wg: 'Mao2 Tse2-tung1',
+        mps2: 'Mau2 Tze2-dung1'
+      }
     ]
-
-    @str = 'ni3 hao3'
-    @mzd = 'Mao2 Ze2 dong1'
-    @mzd2 = 'Mao2 Ze2-dong1'
-    @py = 'nǐ hǎo'
-    @sent = 'Qing3 hui2-da2 wo3 de5 wen4-ti2 .'
-    @alabo = {:pyn => 'A1-la1-bo2', :py => 'Ālābó'}
   end
 end