zhongwen_tools 0.16.5 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ac66e188ca858118d965d4b3084019dfe35b1a2
-  data.tar.gz: c23a65934093fb6e03a5028663c62fecbeb610aa
+  metadata.gz: 5253f60895b1fcdea86c8f43061cd5f8c647f854
+  data.tar.gz: 75afec0bbf2e89ccbf22fbbffb76222496745805
 SHA512:
-  metadata.gz: 53034fdf1f368e673b69ce021c390bafe94589d0619439d09f42bd7c0c168d82c06da4df01ebc741950788f48bd2ad6960434de56f74bfa292aff1bdd3c52d1b
-  data.tar.gz: 7c8d3a72c20333adb510d26502715638fa8ad189a2e580d4ec55c7d90d871e51cec06d00a3248a2a01ed6d3739e63b5286119a034feae5bed026d9322aa0b75c
+  metadata.gz: bf20813d7c304375d47ba1a4555d69f14364339f26f0b7afa51bca059775a1816f9cc7af4d4f91115f60b8e467346d31f049248b1cd501890805cfedb7d41627
+  data.tar.gz: 9cc3eb9986dd62767e0d51a8257d1f0f2525956862c80a8f81debfcbf650a258f45315570f17f45c94195593e2ecb47752c777c05df2d0e85babcd5781d8fa62

data/README.md

@@ -116,7 +116,6 @@ You can monkey patch the String class.
 
     '金枪鱼'.to_zhhk #=> '吞拿魚'
 
-
 #### Integer Extensions
 
 You can also monkey patch the Integer class!
@@ -150,11 +149,8 @@ The core functionality of ZhongwenTools excludes converting between
 simplified and traditional Chinese. You can use it by requiring
 'zhongwen_tools/core' instead of 'zhongwen_tools'
 
-    require 'zhongwen_tools/core' 
+    require 'zhongwen_tools/core'
     require 'zhongwen_tools/core_ext/string'
 
     'ni3 hao3'.to_pinyin #=> 'nǐ hǎo'
     '你們好'.to_zhs #=> NoMethodError
-
-##TODO:
- 1. create a generic ZhongwenTools::Romanization.split method for convenience

data/lib/zhongwen_tools/regex.rb

@@ -33,11 +33,11 @@ module ZhongwenTools
     end
 
     def self.zh
-      /[\u2E80-\u2E99]|[\u2E9B-\u2EF3]|[\u2F00-\u2FD5]|[\u3005|\u3007]|[\u3021-\u3029]|[\u3038-\u303B]|[\u3400-\u4DB5]|[\u4E00-\u9FCC]|[\uF900-\uFA6D]|[\uFA70-\uFAD9]/
+      /\p{Han}/
     end
 
     def self.punc
-      /[\u0021-\u0023]|[\u0025-\u002A]|[\u002C-\u002F]|[\u003A\u003B\u003F\u0040]|[\u005B-\u005D\u005F\u007B\u007D\u00A1\u00A7\u00AB\u00B6\u00B7\u00BB\u00BF\u037E\u0387]/
+      /\p{Punct}/
     end
 
     def self.zh_punc
@@ -74,7 +74,7 @@ module ZhongwenTools
     #
     # Returns a Regex.
     def self.bopomofo
-      /[ㄅㄆㄇㄈㄉㄊㄋㄌㄍㄎㄏㄐㄑㄒㄓㄔㄕㄖㄗㄘㄙㄚㄛㄜㄝㄞㄟㄠㄡㄢㄣㄤㄥㄦㄧㄨㄩ]/
+      /\p{Bopomofo}/
     end
 
     private
@@ -86,6 +86,7 @@ module ZhongwenTools
       {
         nl_regex: /([nN]eng?|[lnLN](a(i|ng?|o)?|e(i|ng)?|i(ang|a[on]?|e|ng?|u)?|o(ng?|u)|u(o|i|an?|n)?|ve?))/,
         bpm_regex: /([mM]iu|[pmPM]ou|[bpmBPM](o|e(i|ng?)?|a(ng?|i|o)?|i(e|ng?|a[no])?|u))/,
+        y_regex: /[yY](a(o|ng?)?|e|i(n|ng)?|o(u|ng)?|u(e|a?n)?)/,
         f_regex: /([fF](ou?|[ae](ng?|i)?|u))/,
         dt_regex: /([dD](e(i|ng?)|i(a[on]?|u))|[dtDT](a(i|ng?|o)?|e(i|ng)?|i(a[on]?|e|ng|u)?|o(ng?|u)|u(o|i|an?|n)?))/,
         gkh_regex: /([ghkGHK](a(i|ng?|o)?|e(i|ng?)?|o(u|ng)|u(a(i|ng?)?|i|n|o)?))/,
@@ -94,8 +95,7 @@ module ZhongwenTools
         r_regex: /([rR]([ae]ng?|i|e|ao|ou|ong|u[oin]|ua?n?))/,
         jqx_regex: /([jqxJQX](i(a(o|ng?)?|[eu]|ong|ng?)?|u(e|a?n)?))/,
         aeo_regex: /(([aA](i|o|ng?)?|[oO]u?|[eE](i|ng?|r)?))/,
-        w_regex: /([wW](a(i|ng?)?|o|e(i|ng?)?|u))/,
-        y_regex: /[yY](a(o|ng?)?|e|in?g?|o(u|ng)?|u(e|a?n)?)/
+        w_regex: /([wW](a(i|ng?)?|o|e(i|ng?)?|u))/
       }
     end
 

data/lib/zhongwen_tools/romanization/mps2.rb

@@ -0,0 +1,22 @@
+module ZhongwenTools
+  module Romanization
+    module MPS2
+      def self.to_mps2(*args)
+        str, from = args
+        from ||= ZhongwenTools::Romanization.romanization?(str)
+
+        ZhongwenTools::Romanization.convert str, :mps2, from.to_sym
+      end
+
+      def self.mps2?(str)
+        regex = ZhongwenTools::Romanization.detect_regex(:mps2)
+        ZhongwenTools::Romanization.detect_romanization(str, regex)
+      end
+
+      def self.split(str)
+        regex = /(#{ ZhongwenTools::Romanization.detect_regex(:mps2) }*)/
+        ZhongwenTools::Romanization.split_romanization(str, regex)
+      end
+    end
+  end
+end

data/lib/zhongwen_tools/romanization/pinyin.rb

@@ -5,7 +5,6 @@ require 'zhongwen_tools/romanization'
 
 module ZhongwenTools
   module Romanization
-
     def self.convert_to_py(str, from)
       str =  convert_romanization(str, from, :pyn) if from != :pyn
       ZhongwenTools::Romanization::Pinyin.convert_pyn_to_pinyin(str)
@@ -31,7 +30,7 @@ module ZhongwenTools
           str, from = args
           from ||= ZhongwenTools::Romanization.romanization? str
 
-          #_convert_romanization str, _set_type(type.to_sym), _set_type(from)
+          # _convert_romanization str, _set_type(type.to_sym), _set_type(from)
           ZhongwenTools::Romanization.convert str, py_type(romanization), (py_type(from) || from)
         end
       end
@@ -40,7 +39,7 @@ module ZhongwenTools
         # FIXME: ignore punctuation
         regex = str[/[1-5]/].nil? ?  /(#{ZhongwenTools::Regex.pinyin_toneless})/ : /(#{ZhongwenTools::Regex.pyn}|#{ZhongwenTools::Regex.pinyin_toneless})/
 
-        str.scan(regex).map{ |arr| arr[0].strip.gsub('-','') }.flatten
+        str.scan(regex).map{ |arr| arr[0].strip.gsub('-', '') }.flatten
       end
 
       def self.split_py(str)
@@ -49,7 +48,9 @@ module ZhongwenTools
         results = words.map do |word|
           word, is_capitalized = normalize_pinyin(word)
           # NOTE: Special Case "fǎnguāng" should be "fǎn" + "guāng"
+          #       Special Case "yìnián" should be "yì" + "nián"
           word = word.gsub('ngu', 'n-gu')
+            .gsub(/([#{ ZhongwenTools::Regex.only_tones }])(ni[#{ ZhongwenTools::Regex.py_tones['a'] }])/){ "#{ $1 }-#{ $2 }" }
           result = word.split(/['\-]/).flatten.map do |x|
             find_py(x)
           end
@@ -89,7 +90,7 @@ module ZhongwenTools
       # Returns Boolean.
       def self.pyn?(str)
         # FIXME: use strip_punctuation method
-        normalized_str = ZhongwenTools::Caps.downcase(str.gsub(ZhongwenTools::Regex.punc,'').gsub(/[\s\-]/,''))
+        normalized_str = ZhongwenTools::Caps.downcase(str.gsub(ZhongwenTools::Regex.punc, '').gsub(/[\s\-]/, ''))
         pyn_arr = split_pyn(normalized_str).map{ |p| p }
 
         pyn_matches_properly?(pyn_arr, normalized_str) &&
@@ -126,7 +127,6 @@ module ZhongwenTools
         { pyn: :pyn, py: :py, pinyin: :py }[romanization]
       end
 
-
       def self.normalize_pinyin(pinyin)
         [ZhongwenTools::Caps.downcase(pinyin), capitalized?(pinyin)]
       end
@@ -180,9 +180,9 @@ module ZhongwenTools
           replace =  pinyin_replacement(pinyin)
           match = pinyin
           if replacements.size > 0
-            pyn = pyn.sub(/(#{replacements.join('.*')}.*)#{match}/){ $1 + replace }
+            pyn = pyn.sub(/(#{ replacements.join('.*') }.*)#{ match }/){ $1 + replace }
           else
-            pyn = pyn.sub(/#{match}/){ "#{$1}#{replace}"}
+            pyn = pyn.sub(/#{match}/){ "#{ $1 }#{ replace }" }
           end
           replacements << replace
         end
@@ -195,20 +195,19 @@ module ZhongwenTools
           py.include? x
         end
         match = select_pinyin_match(matches)
-        replace = PYN_PY.find{|k,v| k if v == match}[0]
+        replace = PYN_PY.find{ |k, v| k if v == match }[0]
 
-        py.gsub(match, replace).gsub(/([^\d ]*)(\d)([^\d ]*)/){$1 + $3 + $2}
+        py.gsub(match, replace).gsub(/([^\d ]*)(\d)([^\d ]*)/){ $1 + $3 + $2 }
       end
 
       def self.select_pinyin_match(matches)
         # take the longest pinyin match. Use bytes because 'è' is prefered over 'n' or 'r' or 'm'
-        match = matches.sort{|x,y| x.bytes.to_a.length <=> y.bytes.to_a.length}[-1]
+        match = matches.sort{ |x, y| x.bytes.to_a.length <=> y.bytes.to_a.length }[-1]
 
         # Edge case.. en/eng pyn -> py conversion is one way only.
         match[/^(ē|é|ě|è|e)n?g?/].nil? ? match : match.chars[0]
       end
 
-
       #  Internal: Replaces numbered pinyin with actual pinyin. Pinyin separated with hyphens are combined as one word.
       #
       #  str - A String to replace with actual pinyin
@@ -229,8 +228,8 @@ module ZhongwenTools
         #              And finally, correct those apostrophes at the very end.
         #              It's like magic.
         str.gsub(regex) do
-          ($3.nil? ? "#{PYN_PY[$1]}" : ($2 == '' && ['a','e','o'].include?($3[0,1]))? "'#{PYN_PY["#{$3}#{$6}"]}#{$4}#{$5}" : "#{$2}#{PYN_PY["#{$3}#{$6}"]}#{$4}#{$5}") + (($7.to_s.length > 1) ? '-' : '')
-        end.gsub("-'","-").sub(/^'/,'')
+          ($3.nil? ? "#{ PYN_PY[$1] }" : ($2 == '' && %w(a e o).include?($3[0,1]))? "'#{ PYN_PY["#{ $3 }#{ $6 }"]}#{ $4 }#{ $5 }" : "#{ $2 }#{ PYN_PY["#{ $3 }#{ $6 }"] }#{ $4 }#{ $5 }") + (($7.to_s.length > 1) ? '-' : '')
+        end.gsub("-'", '-').sub(/^'/, '')
       end
     end
   end

data/lib/zhongwen_tools/romanization/tongyong_pinyin.rb

@@ -0,0 +1,29 @@
+module ZhongwenTools
+  module Romanization
+    module TongyongPinyin
+      def self.to_typy(*args)
+        str, from = args
+        from ||= ZhongwenTools::Romanization.romanization?(str)
+
+        ZhongwenTools::Romanization.convert str, :typy, from.to_sym
+      end
+
+      def self.typy?(str)
+        regex = ZhongwenTools::Romanization.detect_regex(:typy)
+        ZhongwenTools::Romanization.detect_romanization(str, regex)
+      end
+
+      def self.split(str)
+        regex = /(#{ ZhongwenTools::Romanization.detect_regex(:typy) }*)/
+        ZhongwenTools::Romanization.split_romanization(str, regex)
+      end
+
+      class << self
+        [:tongyong, :tongyong_pinyin].each do |m|
+          alias_method "to_#{ m }".to_sym, :to_typy
+          alias_method "#{ m }?", :typy?
+        end
+      end
+    end
+  end
+end

data/lib/zhongwen_tools/romanization/wade_giles.rb

@@ -0,0 +1,29 @@
+module ZhongwenTools
+  module Romanization
+    module WadeGiles
+      def self.to_wg(*args)
+        str, from = args
+        from ||= ZhongwenTools::Romanization.romanization?(str)
+
+        ZhongwenTools::Romanization.convert str, :wg, from.to_sym
+      end
+
+      def self.wg?(str)
+        regex = ZhongwenTools::Romanization.detect_regex(:wg)
+        ZhongwenTools::Romanization.detect_romanization(str, regex)
+      end
+
+      def self.split(str)
+        regex = /(#{ ZhongwenTools::Romanization.detect_regex(:wg) }*)/
+        ZhongwenTools::Romanization.split_romanization(str, regex)
+      end
+
+      class << self
+        [:wade_giles, :wadegiles].each do |m|
+          alias_method "to_#{ m }".to_sym, :to_wg
+          alias_method "#{ m }?", :wg?
+        end
+      end
+    end
+  end
+end

data/lib/zhongwen_tools/romanization/yale.rb

@@ -0,0 +1,22 @@
+module ZhongwenTools
+  module Romanization
+    module Yale
+      def self.to_yale(*args)
+        str, from = args
+        from ||= ZhongwenTools::Romanization.romanization?(str)
+
+        ZhongwenTools::Romanization.convert str, :yale, from.to_sym
+      end
+
+      def self.yale?(str)
+        regex = ZhongwenTools::Romanization.detect_regex(:yale)
+        ZhongwenTools::Romanization.detect_romanization(str, regex)
+      end
+
+      def self.split(str)
+        regex = /(#{ ZhongwenTools::Romanization.detect_regex(:yale) }*)/
+        ZhongwenTools::Romanization.split_romanization(str, regex)
+      end
+    end
+  end
+end

data/lib/zhongwen_tools/romanization/zhuyin_fuhao.rb

@@ -0,0 +1,31 @@
+module ZhongwenTools
+  module Romanization
+    module ZhuyinFuhao
+      def self.to_bpmf(*args)
+        str, from = args
+        from ||= ZhongwenTools::Romanization.romanization?(str)
+
+        ZhongwenTools::Romanization.convert str, :bpmf, from.to_sym
+      end
+
+      def self.bpmf?(str)
+        regex = ZhongwenTools::Regex.bopomofo
+
+        ZhongwenTools::Romanization.detect_romanization(str, regex)
+      end
+
+      def self.split(str)
+        regex = /([#{ZhongwenTools::Regex.bopomofo}]*)/
+
+        ZhongwenTools::Romanization.split_romanization(str, regex)
+      end
+
+      class << self
+        [:zhuyin_fuhao, :zhuyinfuhao, :zyfh, :zhyfh, :bopomofo].each do |m|
+          alias_method "to_#{ m }".to_sym, :to_bpmf
+          alias_method "#{ m }?", :bpmf?
+        end
+      end
+    end
+  end
+end

data/lib/zhongwen_tools/romanization.rb

@@ -1,6 +1,11 @@
 # encoding: utf-8
 require 'zhongwen_tools/romanization/pinyin'
 require 'zhongwen_tools/romanization/pinyin_table'
+require 'zhongwen_tools/romanization/zhuyin_fuhao'
+require 'zhongwen_tools/romanization/tongyong_pinyin'
+require 'zhongwen_tools/romanization/wade_giles'
+require 'zhongwen_tools/romanization/yale'
+require 'zhongwen_tools/romanization/mps2'
 require 'zhongwen_tools/romanization/romanization_table'
 
 # NOTE: Creates several dynamic Modules and their associated methods.
@@ -29,7 +34,12 @@ module ZhongwenTools
     #         belongs to another romanization system p a romanization
     #         system, use the romanization modules specific function.
     #
-    # str - a String to test.
+    #         Zhuyin Fuhao, Tongyong Pinyin, Wade Giles, MSP2 or Yale.
+    #         http://en.wikipedia.org/wiki/Tongyong_Pinyin
+    #         http://pinyin.info/romanization/tongyong/
+    #         http://en.wikipedia.org/wiki/Wade%E2%80%93Giles
+    #         http://en.wikipedia.org/wiki/Bopomofo
+    #         http://pinyin.info/romanization/bopomofo/index.html  # str - a String to test.
     #
     # Examples
     #    romanization?('hao3') #=> :pyn
@@ -56,17 +66,44 @@ module ZhongwenTools
       end
     end
 
-    def split(str, type = nil)
+    def self.split(str, type = nil)
       type ||= romanization?(str)
 
       if type == :py
+         ZhongwenTools::Romanization::Pinyin.split_py(str)
       elsif type == :pyn
+         ZhongwenTools::Romanization::Pinyin.split_pyn(str)
+      elsif type == :bpmf
+         ZhongwenTools::Romanization::ZhuyinFuhao.split(str)
+      elsif type == :wg
+         ZhongwenTools::Romanization::WadeGiles.split(str)
+      elsif type == :typy
+         ZhongwenTools::Romanization::TongyongPinyin.split(str)
+      elsif type == :yale
+         ZhongwenTools::Romanization::Yale.split(str)
+      elsif type == :mps2
+         ZhongwenTools::Romanization::MPS2.split(str)
       end
-
     end
 
     private
 
+    def self.detect_romanization(str, regex)
+      normalized_str = str.downcase.gsub(ZhongwenTools::Regex.punc, '').gsub(/[1-5\s\-']/, '')
+      #TODO: ignore tonal marks from other systems wade giles, tongyong etc.
+
+      normalized_str.scan(regex).join == normalized_str
+    end
+
+    def self.split_romanization(str, regex)
+      # TODO: ignore tonal marks from other systems wade giles, tongyong etc.
+      results = str.scan(regex).map do |arr|
+        arr[0].strip.gsub('-','')
+      end
+
+      results.flatten - ['']
+    end
+
     def self.convert_romanization(str, from, to)
         # NOTE: extract/refactor tokens cause tests to fail.
         if from == :pyn
@@ -104,7 +141,6 @@ module ZhongwenTools
       replace = token_replacement(token, from).fetch(to){ search }
       replace = fix_capitalization(str, token, replace)
 
-
       [search, replace]
     end
 
@@ -127,82 +163,6 @@ module ZhongwenTools
       result || {}
     end
 
-
-    # <module_name>::<romanization_type>?(str)
-    #
-    # Public: Checks if a String is a romanization:
-    #         Zhuyin Fuhao, Tongyong Pinyin, Wade Giles, MSP2 or Yale.
-    #         http://en.wikipedia.org/wiki/Tongyong_Pinyin
-    #         http://pinyin.info/romanization/tongyong/
-    #         http://en.wikipedia.org/wiki/Wade%E2%80%93Giles
-    #         http://en.wikipedia.org/wiki/Bopomofo
-    #         http://pinyin.info/romanization/bopomofo/index.html
-    #
-    # str - a String. Optional if the object calling the method is a String.
-    #
-    # Examples
-    #
-    #   typy?('chuei niou')     #=> true
-    #   wg?('Mao2 Tse2 Tung1')  #=> true
-    #   bpmf?('ㄊㄥ')           #=> true
-    #
-    # Returns a boolean.
-    def self.create_detect_method(romanization_module, name)
-      romanization_module.define_singleton_method("#{name}?") do |str|
-
-        regex = romanization_module == :ZhuyinFuhao ? ZhongwenTools::Regex.bopomofo : ZhongwenTools::Romanization.detect_regex(name.to_sym)
-        normalized_str = str.downcase.gsub(ZhongwenTools::Regex.punc,'').gsub(/[1-5\s\-']/,'')
-        #TODO: ignore tonal marks from other systems wade giles, tongyong etc.
-        normalized_str.scan(regex).join == normalized_str
-      end
-    end
-
-    # <module_name>::to_<romanization_type>(str)
-    # Public: Converts to the given romanization from pyn (pinyin using numbers instead of tone marks.
-    #
-    # str = a String to be converted
-    #
-    # Examples:
-    #
-    #
-    #
-    #   ZhongwenTools::Romanization::ZhuyinFuhao.to_zyfh('Mao2 Ze2-dong1') # => 'ㄇㄠ2 ㄗㄜ2ㄉㄨㄥ1'
-    #
-    # Returns a String.
-    def self.create_convert_method(romanization_module, romanization_name, name)
-      romanization_module.define_singleton_method("to_#{ name }") do |*args|
-        str, from = args
-        from ||= ZhongwenTools::Romanization.romanization?(str)
-
-        ZhongwenTools::Romanization.convert str, romanization_name, from.to_sym
-      end
-    end
-
-    # <module_name>::split(str)
-    # Public: splits the romanization's string.
-    #
-    # str - a String to be split
-    #
-    # Examples
-    #
-    #
-    #   split('zhong1guo2')
-    #   # => ['zhong1', 'guo2']
-    #
-    # Returns an Array of Strings.
-    def self.create_split_method(romanization_module, name)
-      regex = romanization_module == :ZhuyinFuhao ? /([#{ZhongwenTools::Regex.bopomofo}]*)/ : /(#{ZhongwenTools::Romanization.detect_regex(name.to_sym)}*)/
-
-      romanization_module.define_singleton_method("split") do |str|
-        # TODO: ignore tonal marks from other systems wade giles, tongyong etc.
-        results = str.scan(regex).map do |arr|
-          arr[0].strip.gsub('-','')
-        end
-
-        results.flatten - ['']
-      end
-    end
-
     # Internal: Produces a Regexp for a romanization type.
     #
     # type - a Symbol for the romanization type.
@@ -252,19 +212,5 @@ module ZhongwenTools
       TongyongPinyin: %w(typy tongyong tongyong_pinyin),
       MPS2: ['mps2']
     }
-
-    RomanizationTypes.each do |module_name, names|
-      romanization_module = self.const_set(module_name, Module.new) unless self.const_defined?(module_name)
-      romanization_module ||= self.const_get(module_name)
-
-      romanization_name = names.first.to_sym
-
-      names.each do |name|
-        create_convert_method(romanization_module, romanization_name, name)
-      end
-
-      create_detect_method(romanization_module, romanization_name)
-      create_split_method(romanization_module, romanization_name)
-    end
   end
 end

data/lib/zhongwen_tools/ruby_19.rb

@@ -1,5 +1,6 @@
+# encoding: utf-8
 class String
   def chars
-    self.scan(/./mu).to_a
+    self.force_encoding('utf-8').scan(/./mu).to_a
   end
 end

data/lib/zhongwen_tools/string_extension.rb

@@ -137,6 +137,10 @@ module ZhongwenTools
       ZhongwenTools::Romanization.romanization?(self)
     end
 
+    def split_romanization
+      ZhongwenTools::romanization.split(self)
+    end
+
     def zhs?
       ZhongwenTools::Script.zhs?(self)
     end

data/lib/zhongwen_tools/version.rb

@@ -1,3 +1,3 @@
 module ZhongwenTools
-  VERSION = '0.16.5'
+  VERSION = '0.17.1'
 end

data/test/test_pinyin.rb

@@ -54,6 +54,8 @@ class TestPinyin < Minitest::Test
     @words.each do |word|
       assert_equal word[:pyn], ZhongwenTools::Romanization::Pinyin.to_pyn(word[:py])
     end
+    assert_equal 'yi2ge4', ZhongwenTools::Romanization::Pinyin.to_pyn('yígè')
+    assert_equal 'yi4nian2', ZhongwenTools::Romanization::Pinyin.to_pyn('yìnián', :py)
   end
 
   def setup

data/test/test_regex.rb

@@ -30,7 +30,12 @@ class TestRegex < Minitest::Test
     refute '.'[ZhongwenTools::Regex.zh_punc]
     assert '.'[ZhongwenTools::Regex.punc]
     assert '。'[ZhongwenTools::Regex.zh_punc]
-    refute '。'[ZhongwenTools::Regex.punc]
+    assert '。'[ZhongwenTools::Regex.punc]
+  end
+
+  def test_bopomofo
+    assert "ㄅ"[ZhongwenTools::Regex.bopomofo]
+  #  ㄆㄇㄈㄉㄊㄋㄌㄍㄎㄏㄐㄑㄒㄓㄔㄕㄖㄗㄘㄙㄚㄛㄜㄝㄞㄟㄠㄡㄢㄣㄤㄥㄦㄧㄨㄩ
   end
 
   def test_zh

data/zhongwen_tools.gemspec

@@ -27,4 +27,8 @@ Gem::Specification.new do |s|
     s.add_development_dependency('pry', '~> 0.9', '>= 0.9.12')
     s.add_development_dependency('minitest-reporters', '~> 1.0', '>= 1.0.4')
   end
+
+  if RUBY_VERSION >= '2.1'
+    s.add_development_dependency('memory_profiler', '0.0.4')
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zhongwen_tools
 version: !ruby/object:Gem::Version
-  version: 0.16.5
+  version: 0.17.1
 platform: ruby
 authors:
 - Steven Daniels
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-30 00:00:00.000000000 Z
+date: 2014-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -144,6 +144,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: memory_profiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
 description: Chinese tools for romanization conversions and other helpful string functions
   for Chinese.
 email:
@@ -167,9 +181,14 @@ files:
 - lib/zhongwen_tools/number/number_table.rb
 - lib/zhongwen_tools/regex.rb
 - lib/zhongwen_tools/romanization.rb
+- lib/zhongwen_tools/romanization/mps2.rb
 - lib/zhongwen_tools/romanization/pinyin.rb
 - lib/zhongwen_tools/romanization/pinyin_table.rb
 - lib/zhongwen_tools/romanization/romanization_table.rb
+- lib/zhongwen_tools/romanization/tongyong_pinyin.rb
+- lib/zhongwen_tools/romanization/wade_giles.rb
+- lib/zhongwen_tools/romanization/yale.rb
+- lib/zhongwen_tools/romanization/zhuyin_fuhao.rb
 - lib/zhongwen_tools/ruby_19.rb
 - lib/zhongwen_tools/script.rb
 - lib/zhongwen_tools/script/conversion_data