gimchi 0.1.9 → 0.2.0

data/lib/gimchi/char.rb

@@ -1,8 +1,7 @@
 # encoding: UTF-8
 
-module Gimchi
-class Korean
-  # Class representing each Korean character. Its three components, 
+class Gimchi
+  # Class representing each Korean character. Its three components,
   # `chosung', `jungsung' and `jongsung' can be get and set.
   #
   # `to_s' merges components into a String. `to_a' returns the three components.
@@ -14,13 +13,13 @@ class Korean
     # @return [String] Jongsung component of this character.
     attr_reader :jongsung
 
-    # @param [Gimchi::Korean] kor Gimchi::Korean instance
+    # @param [Gimchi] gimchi Gimchi instance
     # @param [String] kchar Korean character string
-    def initialize kor, kchar
-      raise ArgumentError.new('Not a korean character') unless kor.korean_char? kchar
+    def initialize gimchi, kchar
+      raise ArgumentError.new('Not a korean character') unless gimchi.korean_char? kchar
 
-      @kor = kor
-      if @kor.complete_korean_char? kchar
+      @gimchi = gimchi
+      if @gimchi.complete_korean_char? kchar
         c = kchar.unpack('U').first
         n = c - 0xAC00
         # '가' ~ '깋' -> 'ㄱ'
@@ -29,14 +28,14 @@ class Korean
         n = n % (21 * 28)
         n2 = n / 28;
         n3 = n % 28;
-        self.chosung = @kor.chosungs[n1]
-        self.jungsung = @kor.jungsungs[n2]
-        self.jongsung = ([nil] + @kor.jongsungs)[n3]
-      elsif @kor.chosungs.include? kchar
+        self.chosung = @gimchi.chosungs[n1]
+        self.jungsung = @gimchi.jungsungs[n2]
+        self.jongsung = ([nil] + @gimchi.jongsungs)[n3]
+      elsif @gimchi.chosung? kchar
         self.chosung = kchar
-      elsif @kor.jungsungs.include? kchar
+      elsif @gimchi.jungsung? kchar
         self.jungsung = kchar
-      elsif @kor.jongsungs.include? kchar
+      elsif @gimchi.jongsung? kchar
         self.jongsung = kchar
       end
     end
@@ -44,42 +43,32 @@ class Korean
     # Recombines components into a korean character.
     # @return [String] Combined korean character
     def to_s
-      if chosung.nil? && jungsung.nil?
-        ""
-      elsif chosung && jungsung
-        n1, n2, n3 = 
-        n1 = @kor.chosungs.index(chosung) || 0
-        n2 = @kor.jungsungs.index(jungsung) || 0
-        n3 = ([nil] + @kor.jongsungs).index(jongsung) || 0
-        [ 0xAC00 + n1 * (21 * 28) + n2 * 28 + n3 ].pack('U')
-      else
-        chosung || jungsung
-      end
+      @gimchi.compose chosung, jungsung, jongsung
     end
 
     # Sets the chosung component.
-    # @param [String] 
+    # @param [String]
     def chosung= c
       raise ArgumentError.new('Invalid chosung component') if
-          c && @kor.chosungs.include?(c) == false
-      @chosung = c && c.dup.extend(Component).tap { |e| e.kor = @kor }
+          c && @gimchi.chosung?(c) == false
+      @chosung = c && c.dup.extend(Component).tap { |e| e.kor = @gimchi }
     end
 
     # Sets the jungsung component
-    # @param [String] 
+    # @param [String]
     def jungsung= c
       raise ArgumentError.new('Invalid jungsung component') if
-          c && @kor.jungsungs.include?(c) == false
-      @jungsung = c && c.dup.extend(Component).tap { |e| e.kor = @kor }
+          c && @gimchi.jungsung?(c) == false
+      @jungsung = c && c.dup.extend(Component).tap { |e| e.kor = @gimchi }
     end
 
     # Sets the jongsung component
     #
-    # @param [String] 
+    # @param [String]
     def jongsung= c
       raise ArgumentError.new('Invalid jongsung component') if
-          c && @kor.jongsungs.include?(c) == false
-      @jongsung = c && c.dup.extend(Component).tap { |e| e.kor = @kor }
+          c && @gimchi.jongsung?(c) == false
+      @jongsung = c && c.dup.extend(Component).tap { |e| e.kor = @gimchi }
     end
 
     # Returns Array of three components.
@@ -105,22 +94,21 @@ class Korean
     end
 
   private
-    # Three components of Korean::Char are extended to support #vowel? and #consonant? method.
+    # Three components of Gimchi::Char are extended to support #vowel? and #consonant? method.
     module Component
       # @return [Korean] Hosting Korean instance
       attr_accessor :kor
 
       # Is this component a vowel?
       def vowel?
-        kor.jungsungs.include? self
+        kor.jungsung? self
       end
 
       # Is this component a consonant?
       def consonant?
-        self != 'ㅇ' && kor.chosungs.include?(self)
+        self != 'ㅇ' && kor.chosung?(self)
       end
     end#Component
   end#Char
-end#Korean
 end#Gimchi
 

data/lib/gimchi/patch_1.8.rb

@@ -1,10 +1,10 @@
-$KCODE = 'U'
+if RUBY_VERSION =~ /^1\.8\./
+  $KCODE = 'U'
 
-module Gimchi
-class Korean
-private
-  def str_length str
-    str.scan(/./mu).length
-  end
-end#Korean
-end#Gimchi
+  class Gimchi
+  private
+    def str_length str
+      str.scan(/./mu).length
+    end
+  end#Gimchi
+end

data/lib/gimchi/pronouncer.rb

@@ -1,23 +1,23 @@
 # encoding: UTF-8
 
-module Gimchi
-class Korean
+class Gimchi
   # Private class.
   # Partial implementation of Korean pronouncement pronunciation rules specified in
   # http://http://www.korean.go.kr/
+  # @private
   class Pronouncer
   private
-    def initialize korean
-      @korean = korean
-      @pconfig = korean.config['pronouncer']
+    def initialize gimchi
+      @gimchi = gimchi
+      @pconfig = gimchi.config[:pronouncer]
     end
 
     def pronounce! str, options = {}
-      @sequence = @pconfig['transformation']['sequence for ' +
-              (options[:pronounce_each_char] ? '1' : '2')] - options[:except]
+      @sequence = @pconfig[:transformation][
+        "sequence_for_#{options[:each_char] ? '1' : '2'}".to_sym] - options[:except]
 
       # Dissecting
-      @chars = @korean.convert str
+      @chars = str.each_char.map { |c| @gimchi.kchar(c) rescue c }
       @orig_chars = @chars.dup
 
       # Padding
@@ -35,9 +35,9 @@ class Korean
         # Transform one by one
         applied += (0...@chars.length).inject([]) { | arr, i | arr + transform(i); }
 
-        # Post-processing (actually just for :pronounce_each_char option)
-        @chars.select { |c| c.is_a?(Korean::Char) && c.jongsung }.each do | c |
-          c.jongsung = @pconfig['jongsung sound'][c.jongsung]
+        # Post-processing (actually just for :each_char option)
+        @chars.select { |c| c.is_a?(Gimchi::Char) && c.jongsung }.each do | c |
+          c.jongsung = @pconfig[:jongsung_sound][c.jongsung]
         end
 
         break unless options[:slur]
@@ -52,20 +52,20 @@ class Korean
       kc = @chars[@cursor]
 
       # Not korean
-      return [] unless kc.is_a? Korean::Char
+      return [] unless kc.is_a? Gimchi::Char
 
       # Setting up variables for fast lookup
       @kc = kc
-      @next_kc = (nkc = @chars[@cursor + 1]).is_a?(Korean::Char) ? nkc : nil
+      @next_kc = (nkc = @chars[@cursor + 1]).is_a?(Gimchi::Char) ? nkc : nil
       @kc_org = @initial_chars[@cursor]
-      @next_kc_org = (nkco = @initial_chars[@cursor + 1]).is_a?(Korean::Char) ? nkco : nil
+      @next_kc_org = (nkco = @initial_chars[@cursor + 1]).is_a?(Gimchi::Char) ? nkco : nil
 
       # Cannot properly pronounce
       return [] if @kc.chosung.nil? && @kc.jungsung.nil? && @kc.jongsung.nil?
 
       applied = []
       not_todo = []
-      blocking_rule = @pconfig['transformation']['blocking rule']
+      blocking_rule = @pconfig[:transformation][:blocking_rule]
       @sequence.each do | rule |
         next if not_todo.include?(rule)
 
@@ -78,7 +78,7 @@ class Korean
     end
 
     def pad c
-      return unless c.is_a? Korean::Char
+      return unless c.is_a? Gimchi::Char
 
       c.chosung = 'ㅇ'  if c.chosung.nil?
       c.jungsung = 'ㅡ' if c.jungsung.nil?
@@ -86,12 +86,12 @@ class Korean
 
     # shortcut
     def fortis_map
-      @korean.config['structure']['fortis map']
+      @gimchi.config[:structure][:fortis_map]
     end
 
     # shortcut
     def double_consonant_map
-      @korean.config['structure']['double consonant map']
+      @gimchi.config[:structure][:double_consonant_map]
     end
 
     # 제5항: ‘ㅑ ㅒ ㅕ ㅖ ㅘ ㅙ ㅛ ㅝ ㅞ ㅠ ㅢ’는 이중 모음으로 발음한다.
@@ -193,7 +193,7 @@ class Korean
         'ㄱ' => 'ㅋ',
         'ㄷ' => 'ㅌ',
         'ㅈ' => 'ㅊ' }
-        if %w[ㅎ ㄶ ㅀ].include?(@kc.jongsung) 
+        if %w[ㅎ ㄶ ㅀ].include?(@kc.jongsung)
           # 12-1
           if map_12_1.keys.include?(@next_kc.chosung)
             @next_kc.chosung = map_12_1[@next_kc.chosung]
@@ -277,7 +277,7 @@ class Korean
 
       if false && %w[ㅏ ㅓ ㅗ ㅜ ㅟ].include?(@next_kc.jungsung) &&
           %[ㅆ ㄲ ㅈ ㅊ ㄵ ㄻ ㄾ ㄿ ㄺ].include?(@kc.jongsung) == false # PATCH
-        @next_kc.chosung = @pconfig['jongsung sound'][ @kc.jongsung ]
+        @next_kc.chosung = @pconfig[:jongsung_sound][ @kc.jongsung ]
         @kc.jongsung = nil
 
         true
@@ -299,7 +299,7 @@ class Korean
 
       word = @kc.to_s + @next_kc.to_s
       if map.keys.include? word
-        new_char = @korean.kchar(map[word].scan(/./mu)[1])
+        new_char = @gimchi.kchar(map[word].scan(/./mu)[1])
         @next_kc.chosung = new_char.chosung
         @next_kc.jongsung = new_char.jongsung
 
@@ -331,8 +331,8 @@ class Korean
     # ㄿ, ㅄ)’은 ‘ㄴ, ㅁ’ 앞에서 [ㅇ, ㄴ, ㅁ]으로 발음한다.
     def rule_18
       map = {
-        %w[ㄱ ㄲ ㅋ ㄳ ㄺ] => 'ㅇ', 
-        %w[ㄷ ㅅ ㅆ ㅈ ㅊ ㅌ ㅎ] => 'ㄴ', 
+        %w[ㄱ ㄲ ㅋ ㄳ ㄺ] => 'ㅇ',
+        %w[ㄷ ㅅ ㅆ ㅈ ㅊ ㅌ ㅎ] => 'ㄴ',
         %w[ㅂ ㅍ ㄼ ㄿ ㅄ] => 'ㅁ'
       }
       if @next_kc && map.keys.flatten.include?(@kc.jongsung) && %w[ㄴ ㅁ].include?(@next_kc.chosung)
@@ -395,7 +395,7 @@ class Korean
     # 다만, 피동, 사동의 접미사 ‘-기-’는 된소리로 발음하지 않는다.
     # 용언 어간에만 적용.
     def rule_24
-      return if @next_kc.nil? || 
+      return if @next_kc.nil? ||
         @next_kc.to_s == '기' # FIXME 피동/사동 여부 판단 불가. e.g. 줄넘기
 
       # FIXME 용언 여부를 판단. 정확한 판단 불가.
@@ -441,7 +441,7 @@ class Korean
       return if @next_kc.nil?
 
       # 비교적 확률이 높은 경우들에 대해서만 처리. "일" 은 제외.
-      if %w[할 갈 날 볼 을 앨 말 힐].include?(@kc.to_s) && # @kc.jongsung == 'ㄹ' && 
+      if %w[할 갈 날 볼 을 앨 말 힐].include?(@kc.to_s) && # @kc.jongsung == 'ㄹ' &&
           %w[ㄱ ㄷ ㅂ ㅅ ㅈ].include?(@next_kc.chosung)
         @next_kc.chosung = fortis_map[@next_kc.chosung]
         true
@@ -467,7 +467,7 @@ class Korean
     # 1. ‘ㄱ, ㄷ, ㅂ, ㅅ, ㅈ’으로 시작하는 단어 앞에 사이시옷이 올 때는 이들
     # 자음만을 된소리로 발음하는 것을 원칙으로 하되, 사이시옷을 [ㄷ]으로
     # 발음하는 것도 허용한다.
-    # 2. 사이시옷 뒤에 ‘ㄴ, ㅁ’이 결합되는 경우에는 [ㄴ]으로 발음한다. 
+    # 2. 사이시옷 뒤에 ‘ㄴ, ㅁ’이 결합되는 경우에는 [ㄴ]으로 발음한다.
     # 3. 사이시옷 뒤에 ‘이’ 음이 결합되는 경우에는 [ㄴㄴ]으로 발음한다.
     def rule_30
       return if @next_kc.nil? || @kc.jongsung != 'ㅅ'
@@ -490,5 +490,4 @@ class Korean
       end
     end
   end#Pronouncer
-end#Korean
 end#Gimchi

data/test/helper.rb

@@ -1,3 +1,4 @@
+$VERBOSE = true
 require 'rubygems'
 require 'bundler'
 begin

data/test/test_gimchi.rb

@@ -2,76 +2,75 @@
 
 $LOAD_PATH.unshift File.dirname(__FILE__)
 require 'helper'
+require 'yaml'
+require 'ansi'
+
 
 class TestGimchi < Test::Unit::TestCase
 	def test_korean_char
-		ko = Gimchi::Korean.new
-		assert_equal true, ko.korean_char?('ㄱ')  # true
-		assert_equal true, ko.kchar?('ㄱ')  # true
-		assert_equal true, ko.korean_char?('ㅏ')  # true
-		assert_equal true, ko.korean_char?('가')  # true
-		assert_equal true, ko.korean_char?('값')  # true
-		assert_equal true, ko.kchar?('값')  # true
-
-		assert_equal false, ko.korean_char?('a')   # false
-		assert_equal false, ko.korean_char?('1')   # false
-		assert_raise(ArgumentError) { ko.korean_char?('두자') }
-		assert_raise(ArgumentError) { ko.kchar?('두자') }
+		assert_equal true, Gimchi.korean_char?('ㄱ')  # true
+		assert_equal true, Gimchi.kchar?('ㄱ')  # true
+		assert_equal true, Gimchi.korean_char?('ㅏ')  # true
+		assert_equal true, Gimchi.korean_char?('가')  # true
+		assert_equal true, Gimchi.korean_char?('값')  # true
+		assert_equal true, Gimchi.kchar?('값')  # true
+
+		assert_equal false, Gimchi.korean_char?('a')   # false
+		assert_equal false, Gimchi.korean_char?('1')   # false
+		assert_raise(ArgumentError) { Gimchi.korean_char?('두자') }
+		assert_raise(ArgumentError) { Gimchi.kchar?('두자') }
 	end
 
   def test_kchar
-		ko = Gimchi::Korean.new
-    # Alias
-    [ko.kchar('한'), ko.korean_char('한')].each do |kc|
-      assert_equal Gimchi::Korean::Char, kc.class
-      assert_equal "ㅎ", kc.chosung
-      assert_equal "ㅏ", kc.jungsung
-      assert_equal "ㄴ", kc.jongsung
-      assert_equal ["ㅎ", "ㅏ", "ㄴ"], kc.to_a
-      assert_equal "한", kc.to_s
-      assert_equal true, kc.complete?
-      assert_equal false, kc.partial?
-    end
-
-		assert_raise(ArgumentError) { ko.kchar('한글') }
-		assert_raise(ArgumentError) { ko.kchar('A') }
-
-    assert_equal true, ko.kchar("ㅏ").partial?
+    kc = Gimchi::Char('한')
+    assert_equal Gimchi::Char, kc.class
+    assert_equal "ㅎ", kc.chosung
+    assert_equal "ㅏ", kc.jungsung
+    assert_equal "ㄴ", kc.jongsung
+    assert_equal ["ㅎ", "ㅏ", "ㄴ"], kc.to_a
+    assert_equal "한", kc.to_s
+    assert_equal true, kc.complete?
+    assert_equal false, kc.partial?
+
+		assert_raise(ArgumentError) { Gimchi::Char('한글') }
+		assert_raise(ArgumentError) { Gimchi::Char('A') }
+
+    assert_equal true, Gimchi::Char("ㅏ").partial?
   end
 
 	def test_complete_korean_char
-		ko = Gimchi::Korean.new
 
-		assert_equal false, ko.complete_korean_char?('ㄱ') # false
-		assert_equal false, ko.complete_korean_char?('ㅏ') # false
-		assert_equal true, ko.complete_korean_char?('가') # true
-		assert_equal true, ko.complete_korean_char?('값') # true
+		assert_equal false, Gimchi.complete_korean_char?('ㄱ') # false
+		assert_equal false, Gimchi.complete_korean_char?('ㅏ') # false
+		assert_equal true, Gimchi.complete_korean_char?('가') # true
+		assert_equal true, Gimchi.complete_korean_char?('값') # true
 
-		assert_equal false, ko.korean_char?('a')   # false
-		assert_equal false, ko.korean_char?('1')   # false
-		assert_raise(ArgumentError) { ko.korean_char?('두자') }
+		assert_equal false, Gimchi.korean_char?('a')   # false
+		assert_equal false, Gimchi.korean_char?('1')   # false
+		assert_raise(ArgumentError) { Gimchi.korean_char?('두자') }
 	end
 
   def test_dissect
-		ko = Gimchi::Korean.new
+		arr = '이것은 Hangul 입니다.'.each_char.map { |ch|
+      (Gimchi::Char(ch) rescue [ch]).to_a
+    }.flatten.compact
 
-		arr = ko.dissect '이것은 Hangul 입니다.'
-    assert_equal ["ㅇ", "ㅣ", "ㄱ", "ㅓ", "ㅅ", "ㅇ", "ㅡ", "ㄴ", " ", 
+    assert_equal ["ㅇ", "ㅣ", "ㄱ", "ㅓ", "ㅅ", "ㅇ", "ㅡ", "ㄴ", " ",
                   "H", "a", "n", "g", "u", "l", " ", "ㅇ", "ㅣ", "ㅂ",
                   "ㄴ", "ㅣ", "ㄷ", "ㅏ", "."], arr
   end
 
 	def test_convert
-		ko = Gimchi::Korean.new
-
-		arr = ko.convert '이것은 한글입니다.'
+		arr = '이것은 한글입니다.'.each_char.map { |ch|
+      Gimchi::Char(ch) rescue ch
+    }
 		# [이, 것, 은, " ", 한, 글, 입, 니, 다, "."]
 
 		assert_equal 10, arr.length
-		assert_equal Gimchi::Korean::Char, arr[0].class
-		assert_equal Gimchi::Korean::Char, arr[1].class
-		assert_equal Gimchi::Korean::Char, arr[2].class
-		
+		assert_equal Gimchi::Char, arr[0].class
+		assert_equal Gimchi::Char, arr[1].class
+		assert_equal Gimchi::Char, arr[2].class
+
 		ch = arr[2]
 		assert_equal 'ㅇ', ch.chosung
 		assert_equal 'ㅡ', ch.jungsung
@@ -108,43 +107,41 @@ class TestGimchi < Test::Unit::TestCase
 	end
 
 	def test_read_number
-		ko = Gimchi::Korean.new
-		assert_equal "영", ko.read_number(0)
-		assert_equal "일", ko.read_number(1)
-		assert_equal "구", ko.read_number(9)
-		assert_equal "천 구백 구십 구", ko.read_number(1999)
-		assert_equal "마이너스 백점일이삼", ko.read_number(- 100.123)
+		assert_equal "영", Gimchi.read_number(0)
+		assert_equal "일", Gimchi.read_number(1)
+		assert_equal "구", Gimchi.read_number(9)
+		assert_equal "천 구백 구십 구", Gimchi.read_number(1999)
+		assert_equal "마이너스 백점일이삼", Gimchi.read_number(- 100.123)
 		assert_equal "오백 삼십 일억 구천 백 십만 육백 칠십 팔점삼이일사오육칠",
-				ko.read_number("53,191,100,678.3214567")
-		assert_equal "영점영영영영영일이삼사오", ko.read_number("1.2345e-06")
-		assert_equal "일해 이천 삼백 사십 오경", ko.read_number("1.2345e+20")
-		assert_equal "플러스 일해 이천 삼백 사십 오경", ko.read_number("+ 1.2345e+20")
-		assert_equal "마이너스 일해 이천 삼백 사십 오경", ko.read_number("- 1.2345e+20")
-		assert_equal "만 십 이점삼", ko.read_number("100.123e+2")
-		assert_equal "십만 십 이점삼", ko.read_number("1000.123e+2")
-		assert_equal "백 일만 십 이점삼", ko.read_number("10100.123e+2")
-		assert_equal "천 십 이점삼", ko.read_number("10.123e+2")
-		assert_equal "십점영", ko.read_number("10.0")
-		assert_equal "플러스 십점영", ko.read_number("+ 10.0")
+				Gimchi.read_number("53,191,100,678.3214567")
+		assert_equal "영점영영영영영일이삼사오", Gimchi.read_number("1.2345e-06")
+		assert_equal "일해 이천 삼백 사십 오경", Gimchi.read_number("1.2345e+20")
+		assert_equal "플러스 일해 이천 삼백 사십 오경", Gimchi.read_number("+ 1.2345e+20")
+		assert_equal "마이너스 일해 이천 삼백 사십 오경", Gimchi.read_number("- 1.2345e+20")
+		assert_equal "만 십 이점삼", Gimchi.read_number("100.123e+2")
+		assert_equal "십만 십 이점삼", Gimchi.read_number("1000.123e+2")
+		assert_equal "백 일만 십 이점삼", Gimchi.read_number("10100.123e+2")
+		assert_equal "천 십 이점삼", Gimchi.read_number("10.123e+2")
+		assert_equal "십점영", Gimchi.read_number("10.0")
+		assert_equal "플러스 십점영", Gimchi.read_number("+ 10.0")
 
 		# 나이, 시간, 개수, 명 ( -살, -시, -개, -명 )
-		assert_equal "나는 이십", ko.read_number("나는 20")
-		assert_equal "나는 스무살", ko.read_number("나는 20살")
-		assert_equal "나는 스물네살", ko.read_number("나는 24살")
-		assert_equal "스무개", ko.read_number("20개")
-		assert_equal "스무 명", ko.read_number("20 명")
-		assert_equal "이십 칠점일살", ko.read_number("27.1살")
-		assert_equal "너는 열세 살", ko.read_number("너는 13 살")
-		assert_equal "백 서른두명", ko.read_number("132명")
-		assert_equal "이천 오백 아흔아홉개", ko.read_number("2,599개")
-		assert_equal "지금은 일곱시 삼십분", ko.read_number("지금은 7시 30분")
+		assert_equal "나는 이십", Gimchi.read_number("나는 20")
+		assert_equal "나는 스무살", Gimchi.read_number("나는 20살")
+		assert_equal "나는 스물네살", Gimchi.read_number("나는 24살")
+		assert_equal "스무개", Gimchi.read_number("20개")
+		assert_equal "스무 명", Gimchi.read_number("20 명")
+		assert_equal "이십 칠점일살", Gimchi.read_number("27.1살")
+		assert_equal "너는 열세 살", Gimchi.read_number("너는 13 살")
+		assert_equal "백 서른두명", Gimchi.read_number("132명")
+		assert_equal "이천 오백 아흔아홉개", Gimchi.read_number("2,599개")
+		assert_equal "지금은 일곱시 삼십분", Gimchi.read_number("지금은 7시 30분")
+
+    # No way!
+    assert_raise(RangeError) { Gimchi.read_number 10 ** 100 }
 	end
 
 	def test_pronounce
-		require 'yaml'
-		require 'ansi'
-
-		ko = Gimchi::Korean.new
 		cnt = 0
 		s = 0
 		test_set = YAML.load File.read(File.dirname(__FILE__) + '/pronunciation.yml')
@@ -152,8 +149,8 @@ class TestGimchi < Test::Unit::TestCase
 			cnt += 1
 			k = k.gsub(/[-]/, '')
 
-			t1, tfs1 = ko.pronounce(k, :pronounce_each_char => false, :slur => true, :debug => true)
-			t2, tfs2 = ko.pronounce(k, :pronounce_each_char => false, :slur => false, :debug => true)
+			t1, tfs1 = Gimchi.pronounce(k, :each_char => false, :slur => true, :debug => true)
+			t2, tfs2 = Gimchi.pronounce(k, :each_char => false, :slur => false, :debug => true)
 
 			path = ""
 			if (with_slur = v.include?(t1.gsub(/\s/, ''))) || v.include?(t2.gsub(/\s/, ''))
@@ -165,7 +162,7 @@ class TestGimchi < Test::Unit::TestCase
 				r = ANSI::Code::RED + ANSI::Code::BOLD + v.join(' / ') + ANSI::Code::RESET
 				t = [t1, t2].join ' | '
 			end
-			puts "#{k} => #{t} (#{ko.romanize t, :as_pronounced => false}) [#{path}] #{r}"
+			puts "#{k} => #{t} (#{Gimchi.romanize t, :as_pronounced => false}) [#{path}] #{r}"
 		end
 		puts "#{s} / #{cnt}"
 		# FIXME
@@ -173,19 +170,16 @@ class TestGimchi < Test::Unit::TestCase
 	end
 
 	def test_romanize_preserve_non_korean
-		ko = Gimchi::Korean.new
-		assert_equal 'ttok-kkateun kkk', ko.romanize('똑같은 kkk')
+		assert_equal 'ttok-kkateun kkk', Gimchi.romanize('똑같은 kkk')
 	end
 
 	def test_romanize
-		ko = Gimchi::Korean.new
-
 		cnt = 0
 		s = 0
 		test_set = YAML.load File.read(File.dirname(__FILE__) + '/romanization.yml')
 		test_set.each do | k, v |
 			cnt += 1
-			rom = ko.romanize k.sub(/\[.*/, '')
+			rom = Gimchi.romanize k.sub(/\[.*/, '')
 			if rom.downcase.gsub(/[\s-]/, '') == v.downcase.gsub(/\(.*\)/, '').gsub(/[\s-]/, '')
 				r = ANSI::Code::BLUE + ANSI::Code::BOLD + rom + ANSI::Code::RESET
 				s += 1
@@ -198,4 +192,38 @@ class TestGimchi < Test::Unit::TestCase
 		# FIXME
 		assert s >= 63
 	end
+
+  def test_cho_jung_jongsung?
+    c, j, jo = Gimchi::Char("달").to_a
+    assert Gimchi.chosung?(c)
+    assert Gimchi.jungsung?(j)
+    assert Gimchi.jongsung?(jo)
+
+    assert  Gimchi.chosung?( 'ㄱ')
+    assert !Gimchi.jungsung?('ㄱ')
+    assert  Gimchi.jongsung?('ㄱ')
+    assert !Gimchi.chosung?( 'ㅏ')
+    assert  Gimchi.jungsung?('ㅏ')
+    assert !Gimchi.jongsung?('ㅏ')
+    assert !Gimchi.chosung?( 'ㄺ')
+    assert !Gimchi.jungsung?('ㄺ')
+    assert  Gimchi.jongsung?('ㄺ')
+  end
+
+  def test_compose_decompose
+    ret = Gimchi.decompose("한")
+    assert ret.is_a?(Array)
+    assert_equal 'ㅎ', ret[0]
+    assert_equal 'ㅏ', ret[1]
+    assert_equal 'ㄴ', ret[2]
+
+    assert_equal '한', Gimchi.compose(*ret)
+
+    ret = Gimchi.decompose("ㅋ")
+    assert_equal 'ㅋ', ret[0]
+    assert_equal nil, ret[1]
+    assert_equal nil, ret[2]
+
+    assert_equal 'ㅋ', Gimchi.compose(*ret)
+  end
 end