gimchi 0.1.6 → 0.1.7

data/README.markdown

@@ -0,0 +1,134 @@
+# gimchi
+
+Gimchi is a simple Ruby gem which knows how to handle Korean strings. It knows
+how to dissect Korean characters into its 3 components, namely chosung,
+jungsung and optional jongsung. It knows how Korean sentences are pronounced
+and how they're written in roman alphabet. 
+
+Gimchi (only partially) implements the following rules dictated by
+The National Institute of The Korean Language (http://www.korean.go.kr)
+* Korean Standard Pronunciation
+* Korean Romanization
+
+## Installation
+```
+gem install gimchi
+```
+
+## Usage
+
+### Creating Gimchi::Korean instance
+```ruby
+require 'gimchi'
+
+ko = Gimchi::Korean.new
+```
+
+### Checks if the given character is in Korean alphabet
+```ruby
+ko.korean_char? 'ㄱ'           # true
+ko.complete_korean_char? 'ㄱ'  # false
+
+ko.korean_char? 'ㅏ'           # true
+ko.complete_korean_char? 'ㅏ'  # false
+
+ko.korean_char? '가'           # true
+ko.complete_korean_char? '가'  # true
+```
+
+### Usage of Gimchi::Korean::Char
+```ruby
+arr = ko.dissect '이것은 한글입니다.'
+  # [이, 것, 은, " ", 한, 글, 입, 니, 다, "."]
+
+arr[4].class                   # Gimchi::Korean::Char
+
+arr[4].chosung                 # "ㅎ"
+arr[4].jungsung                # "ㅏ"
+arr[4].jongsung                # "ㄴ"
+arr[4].to_a                    # ["ㅎ", "ㅏ", "ㄴ"]
+arr[4].to_s                    # "한"
+
+arr[4].chosung = 'ㄷ'
+arr[4].jongsung = 'ㄹ'
+arr[4].to_s                    # "달"
+arr[4].complete?               # true
+arr[4].partial?                # false
+
+arr[4].chosung = nil
+arr[4].jongsung = nil
+arr[4].complete?               # false
+arr[4].partial?                # true
+```
+
+### Reading numbers in Korean
+```ruby
+ko.read_number(1999)         # "천 구백 구십 구"
+ko.read_number(- 100.123)    # "마이너스 백점일이삼"
+ko.read_number("153,191,100,678.3214")
+  	# "천 오백 삼십 일억 구천 백 십만 육백 칠십 팔점삼이일사"
+
+# Age, Time ( -살, -시 )
+ko.read_number("20살")       # "스무살"
+ko.read_number("13 살")      # "열세 살"
+ko.read_number("7시 30분")   # "일곱시 삼십분"
+```
+
+### Standard pronunciation (partially implemented)
+```ruby
+str = "됐어 됐어 이제 그런 가르침은 됐어 매일 아침 7 시 30 분까지 우릴 조그만 교실로 몰아넣고"
+ko.pronounce str
+  # "돼써 돼써 이제 그런 가르치믄 돼써 매일 아침 일곱 시 삼십 분까지 우릴 조그만 교실로 모라너코"
+
+ko.pronounce str, :slur => true
+  # "돼써 돼써 이제 그런 가르치믄 돼써 매이 라치 밀곱 씨 삼십 뿐까지 우릴 조그만 교실로 모라너코"
+
+ko.pronounce str, :pronounce_each_char => true
+  # "됃어 됃어 이제 그런 가르침은 됃어 매일 아침 일곱 시 삼십 분까지 우릴 조그만 교실로 몰아너고"
+
+ko.pronounce str, :number => false
+  # "돼써 돼써 이제 그런 가르치믄 돼써 매일 아침 7 시 30 분까지 우릴 조그만 교실로 모라너코"
+```
+
+### Romanization (partially implemented)
+```ruby
+str = "됐어 됐어 이제 그런 가르침은 됐어 매일 아침 7 시 30 분까지 우릴 조그만 교실로 몰아넣고"
+
+ko.romanize str
+  # "Dwaesseo dwaesseo ije geureon gareuchimeun dwaesseo mae-il achim ilgop si samsip bunkkaji uril jogeuman gyosillo moraneoko"
+ko.romanize str, :slur => true
+  # "Dwaesseo dwaesseo ije geureon gareuchimeun dwaesseo mae-i rachi milgop ssi samsip ppunkkaji uril jogeuman gyosillo moraneoko"
+ko.romanize str, :as_pronounced => false
+  # "Dwaet-eo dwaet-eo ije geureon gareuchim-eun dwaet-eo mae-il achim ilgop si samsip bunkkaji uril jogeuman gyosillo mol-aneogo"
+ko.romanize str, :number => false
+  # "Dwaesseo dwaesseo ije geureon gareuchimeun dwaesseo mae-il achim 7 si 30 bunkkaji uril jogeuman gyosillo moraneoko"
+```
+
+## Limitation of the implementation
+
+Unfortunately in order to implement the complete specification of Korean
+pronunciation and romanization, we need NLP, huge Korean dictionaries and even
+semantic analysis of the given string. And even with all those complex
+processing, we cannot guarantee 100% accuracy of the output. So yes, that is
+definitely not what this gem tries to achieve. Gimchi tries to achieve "some"
+level of accuracy with relatively simple code.
+
+Currently, Gimchi code contains a lot of ad-hoc (possibly invalid) patches
+that try to improve the quality of the output, which should better be
+refactored anytime soon.
+
+## Contributing to gimchi
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011 Junegunn Choi. See LICENSE.txt for
+further details.
+

data/config/default.yml

@@ -90,8 +90,7 @@ number:
     units: ["", 만, 억, 조, 경, 해, 자, 양, 구, 간, 정, 재, 극, 항하사, 아승기, 나유타, 불가사의, 무량대수]
     digits: [영, 일, 이, 삼, 사, 오, 육, 칠, 팔, 구]
     post substitution:
-        ? !ruby/regexp /^일만/
-        : 만
+        "^일만": 만
 
     # 정수형일 때 또다른 표현법 (나이, 시간)
     alt notation:
@@ -107,8 +106,7 @@ number:
         tenfolds: [열, 스물, 서른, 마흔, 쉰, 예순, 일흔, 여든, 아흔, 백]
         digits: ["", 한, 두, 세, 네, 다섯, 여섯, 일곱, 여덟, 아홉]
         post substitution:
-            ? !ruby/regexp /스물$/
-            : 스무
+            "스물$": 스무
 
 romanization:
     chosung:
@@ -171,9 +169,6 @@ romanization:
         ttt: t-tt
         ppp: p-pp
         "--": "-"
-        ? !ruby/regexp /n-([^gaeiou])/
-        : "n\\1"
-        ? !ruby/regexp /-(\s)/
-        : "\\1"
-        ? !ruby/regexp /-$/
-        : ""
+        "n-([^gaeiou])": "n\\1"
+        "-(\\s)": "\\1"
+        "-$": ""

data/lib/gimchi/char.rb

@@ -2,122 +2,122 @@
 
 module Gimchi
 class Korean
-	# 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.
-	class Char
-		# @return [String] Chosung component of this character.
-		attr_reader :chosung
-		# @return [String] Jungsung component of this character.
-		attr_reader :jungsung
-		# @return [String] Jongsung component of this character.
-		attr_reader :jongsung
+  # 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.
+  class Char
+    # @return [String] Chosung component of this character.
+    attr_reader :chosung
+    # @return [String] Jungsung component of this character.
+    attr_reader :jungsung
+    # @return [String] Jongsung component of this character.
+    attr_reader :jongsung
 
-		# @param [Gimchi::Korean] kor Gimchi::Korean instance
-		# @param [String] kchar Korean character string
-		def initialize kor, kchar
-			raise ArgumentError('Not a korean character') unless kor.korean_char? kchar
+    # @param [Gimchi::Korean] kor Gimchi::Korean instance
+    # @param [String] kchar Korean character string
+    def initialize kor, kchar
+      raise ArgumentError('Not a korean character') unless kor.korean_char? kchar
 
-			@kor = kor
-			@cur = []
-			if @kor.complete_korean_char? kchar
-				c = kchar.unpack('U').first
-				n = c - 0xAC00
-				# '가' ~ '깋' -> 'ㄱ'
-				n1 = n / (21 * 28)
-				# '가' ~ '깋'에서의 순서
-				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 = kchar
-			elsif @kor.jungsungs.include? kchar
-				self.jungsung = kchar
-			elsif @kor.jongsungs.include? kchar
-				self.jongsung = kchar
-			end
-		end
+      @kor = kor
+      @cur = []
+      if @kor.complete_korean_char? kchar
+        c = kchar.unpack('U').first
+        n = c - 0xAC00
+        # '가' ~ '깋' -> 'ㄱ'
+        n1 = n / (21 * 28)
+        # '가' ~ '깋'에서의 순서
+        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 = kchar
+      elsif @kor.jungsungs.include? kchar
+        self.jungsung = kchar
+      elsif @kor.jongsungs.include? kchar
+        self.jongsung = kchar
+      end
+    end
 
-		# 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
-		end
+    # 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
+    end
 
-		# Sets the chosung component.
-		# @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 }
-		end
+    # Sets the chosung component.
+    # @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 }
+    end
 
-		# Sets the jungsung component
-		# @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 }
-		end
+    # Sets the jungsung component
+    # @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 }
+    end
 
-		# Sets the jongsung component
-		#
-		# @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 }
-		end
+    # Sets the jongsung component
+    #
+    # @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 }
+    end
 
-		# Returns Array of three components.
-		#
-		# @return [Array] Array of three components
-		def to_a
-			[chosung, jungsung, jongsung]
-		end
+    # Returns Array of three components.
+    #
+    # @return [Array] Array of three components
+    def to_a
+      [chosung, jungsung, jongsung]
+    end
 
-		# Checks if this is a complete Korean character.
-		def complete?
-			chosung.nil? == false && jungsung.nil? == false
-		end
+    # Checks if this is a complete Korean character.
+    def complete?
+      chosung.nil? == false && jungsung.nil? == false
+    end
 
-		# Checks if this is a non-complete Korean character.
-		# e.g. ㅇ, ㅏ
-		def partial?
-			chosung.nil? || jungsung.nil?
-		end
+    # Checks if this is a non-complete Korean character.
+    # e.g. ㅇ, ㅏ
+    def partial?
+      chosung.nil? || jungsung.nil?
+    end
 
-	private
-		# Three components of Korean::Char are extended to support #vowel? and #consonant? method.
-		module Component
-			# @return [Korean] Hosting Korean instance
-			attr_accessor :kor
+  private
+    # Three components of Korean::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
-			end
+      # Is this component a vowel?
+      def vowel?
+        kor.jungsungs.include? self
+      end
 
-			# Is this component a consonant?
-			def consonant?
-				self != 'ㅇ' && kor.chosungs.include?(self)
-			end
-		end#Component
-	end#Char
+      # Is this component a consonant?
+      def consonant?
+        self != 'ㅇ' && kor.chosungs.include?(self)
+      end
+    end#Component
+  end#Char
 end#Korean
 end#Gimchi
 

data/lib/gimchi/korean.rb

@@ -2,285 +2,299 @@
 
 module Gimchi
 class Korean
-	DEFAULT_CONFIG_FILE_PATH = 
-		File.dirname(__FILE__) + '/../../config/default.yml'
-
-	# Returns the YAML configuration used by this Korean instance.
-	# @return [String]
-	attr_reader   :config
-
-	# Initialize Gimchi::Korean.
-	# @param [String] config_file You can override many parts of the implementation by customizing config file
-	def initialize config_file = DEFAULT_CONFIG_FILE_PATH
-		require 'yaml'
-		@config = YAML.load(File.read config_file)
-		@config.freeze
-
-		@pronouncer = Korean::Pronouncer.send :new, self
-	end
-
-	# Array of chosung's.
-	#
-	# @return [Array] Array of chosung strings
-	def chosungs
-		config['structure']['chosung']
-	end
-
-	# Array of jungsung's.
-	# @return [Array] Array of jungsung strings
-	def jungsungs
-		config['structure']['jungsung']
-	end
-
-	# Array of jongsung's.
-	# @return [Array] Array of jongsung strings
-	def jongsungs
-		config['structure']['jongsung']
-	end
-
-	# Checks if the given character is a korean character.
-	# @param [String] ch A string of size 1
-	def korean_char? ch
-		raise ArgumentError.new('Lengthy input') if ch.length > 1
-
-		complete_korean_char?(ch) || 
-			(chosungs + jungsungs + jongsungs).include?(ch)
-	end
-
-	# Checks if the given character is a "complete" korean character.
-	# "Complete" Korean character must have chosung and jungsung, with optional jongsung.
-	# @param [String] ch A string of size 1
-	def complete_korean_char? ch
-		raise ArgumentError.new('Lengthy input') if ch.length > 1
-
-		# Range of Korean chracters in Unicode 2.0: AC00(가) ~ D7A3(힣)
-		ch.unpack('U').all? { | c | c >= 0xAC00 && c <= 0xD7A3 }
-	end
-
-	# Splits the given string into an array of Korean::Char's and Strings of length 1.
-	# @param [String] str Input string.
-	# @return [Array] Mixed array of Korean::Char instances and Strings of length 1 (for non-korean characters)
-	def dissect str
-		str.each_char.map { |c| 
-			korean_char?(c) ? Korean::Char.new(self, c) : c
-		}
-	end
-
-	# Reads numeric expressions in Korean way.
-	# @param [String, Number] str Numeric type or String containing numeric expressions
-	# @return [String] Output string
-	def read_number str
-		nconfig = config['number']
-		
-		str.to_s.gsub(/(([+-]\s*)?[0-9,]*,*[0-9]+(\.[0-9]+(e[+-][0-9]+)?)?)(\s*.)?/) { 
-			read_number_sub($1, $5)
-		}
-	end
-
-	# Returns the pronunciation of the given string containing Korean characters.
-	# Takes optional options hash.
-	#
-	# @param [String] Input string
-	# @param [Boolean] options[:pronounce_each_char] Each character of the string is pronounced respectively.
-	# @param [Boolean] options[:slur] Strings separated by whitespaces are processed again as if they were contiguous.
-	# @param [Boolean] options[:number] Numberic parts of the string is also pronounced in Korean.
-	# @param [Array] options[:except] Allows you to skip certain transformations.
-	# @return [String] Output string
-	def pronounce str, options = {}
-		options = {
-			:pronounce_each_char => false,
-			:slur => false,
-			:number => true,
-			:except => [],
-			:debug => false
-		}.merge options
-
-		str = read_number(str) if options[:number]
-
-		result, transforms = @pronouncer.send :pronounce!, str, options
-
-		if options[:debug]
-			return result, transforms
-		else
-			return result
-		end
-	end
-
-	# Returns the romanization (alphabetical notation) of the given Korean string.
-	# http://en.wikipedia.org/wiki/Korean_romanization
-	# @param [String] str Input Korean string
-	# @param [Boolean] options[:as_pronounced] If true, #pronounce is internally called before romanize
-	# @param [Boolean] options[:number] Whether to read numeric expressions in the string
-	# @param [Boolean] options[:slur] Same as :slur in #pronounce 
-	# @return [String] Output string in Roman Alphabet
-	# @see Korean#pronounce
-	def romanize str, options = {}
-		options = {
-			:as_pronounced => true,
-			:number => true,
-			:slur => false
-		}.merge options
-
-		require 'yaml'
-		rdata = config['romanization']
-		post_subs = rdata["post substitution"]
-		rdata = [rdata["chosung"], rdata["jungsung"], rdata["jongsung"]]
-
-		str = pronounce str,
-				:pronounce_each_char => !options[:as_pronounced],
-				:number => options[:number],
-				:slur => options[:slur],
-				# 제1항 [붙임 1] ‘ㅢ’는 ‘ㅣ’로 소리 나더라도 ‘ui’로 적는다.
-				:except => %w[rule_5_3]
-		dash = rdata[0]["ㅇ"]
-		romanization = ""
-
-		romanize_chunk = lambda do | chunk |
-			dissect(chunk).each do | kc |
-				kc.to_a.each_with_index do | comp, idx |
-					next if comp.nil?
-					comp = rdata[idx][comp] || comp
-					comp = comp[1..-1] if comp[0, 1] == dash &&
-							(romanization.empty? || romanization[-1, 1] =~ /\s/)
-					romanization += comp
-				end
-			end
-
-			return post_subs.keys.inject(romanization) { | output, pattern |
-				output.gsub(pattern, post_subs[pattern])
-			}
-		end
-
-		k_chunk = ""
-		str.each_char do | c |
-			if korean_char? c
-				k_chunk += c
-			else
-				unless k_chunk.empty?
-					romanization = romanize_chunk.call k_chunk
-					k_chunk = ""
-				end
-				romanization += c
-			end
-		end
-		romanization = romanize_chunk.call k_chunk unless k_chunk.empty?
-		romanization
-	end
+  DEFAULT_CONFIG_FILE_PATH = 
+    File.dirname(__FILE__) + '/../../config/default.yml'
+
+  # Returns the YAML configuration used by this Korean instance.
+  # @return [String]
+  attr_reader   :config
+
+  # Initialize Gimchi::Korean.
+  # @param [String] config_file You can override many parts of the implementation by customizing config file
+  def initialize config_file = DEFAULT_CONFIG_FILE_PATH
+    require 'yaml'
+    @config = YAML.load(File.read config_file)
+
+    [
+      @config['romanization']['post substitution'],
+      @config['number']['post substitution'],
+      @config['number']['alt notation']['post substitution']
+    ].each do |r|
+      r.keys.each do |k|
+        r[Regexp.compile k] = r.delete k
+      end
+    end
+    @config.freeze
+
+    @pronouncer = Korean::Pronouncer.send :new, self
+  end
+
+  # Array of chosung's.
+  #
+  # @return [Array] Array of chosung strings
+  def chosungs
+    config['structure']['chosung']
+  end
+
+  # Array of jungsung's.
+  # @return [Array] Array of jungsung strings
+  def jungsungs
+    config['structure']['jungsung']
+  end
+
+  # Array of jongsung's.
+  # @return [Array] Array of jongsung strings
+  def jongsungs
+    config['structure']['jongsung']
+  end
+
+  # Checks if the given character is a korean character.
+  # @param [String] ch A string of size 1
+  def korean_char? ch
+    raise ArgumentError.new('Lengthy input') if ch.length > 1
+
+    complete_korean_char?(ch) || 
+      (chosungs + jungsungs + jongsungs).include?(ch)
+  end
+
+  # Checks if the given character is a "complete" korean character.
+  # "Complete" Korean character must have chosung and jungsung, with optional jongsung.
+  # @param [String] ch A string of size 1
+  def complete_korean_char? ch
+    raise ArgumentError.new('Lengthy input') if ch.length > 1
+
+    # Range of Korean chracters in Unicode 2.0: AC00(가) ~ D7A3(힣)
+    ch.unpack('U').all? { | c | c >= 0xAC00 && c <= 0xD7A3 }
+  end
+
+  # Splits the given string into an array of Korean::Char's and Strings of length 1.
+  # @param [String] str Input string.
+  # @return [Array] Mixed array of Korean::Char instances and Strings of length 1 (for non-korean characters)
+  def dissect str
+    str.each_char.map { |c| 
+      korean_char?(c) ? Korean::Char.new(self, c) : c
+    }
+  end
+
+  # Reads numeric expressions in Korean way.
+  # @param [String, Number] str Numeric type or String containing numeric expressions
+  # @return [String] Output string
+  def read_number str
+    nconfig = config['number']
+
+    str.to_s.gsub(/(([+-]\s*)?[0-9,]*,*[0-9]+(\.[0-9]+(e[+-][0-9]+)?)?)(\s*.)?/) { 
+      read_number_sub($1, $5)
+    }
+  end
+
+  # Returns the pronunciation of the given string containing Korean characters.
+  # Takes optional options hash.
+  #
+  # @param [String] Input string
+  # @param [Boolean] options[:pronounce_each_char] Each character of the string is pronounced respectively.
+  # @param [Boolean] options[:slur] Strings separated by whitespaces are processed again as if they were contiguous.
+  # @param [Boolean] options[:number] Numberic parts of the string is also pronounced in Korean.
+  # @param [Array] options[:except] Allows you to skip certain transformations.
+  # @return [String] Output string
+  def pronounce str, options = {}
+    options = {
+      :pronounce_each_char => false,
+      :slur => false,
+      :number => true,
+      :except => [],
+      :debug => false
+    }.merge options
+
+    str = read_number(str) if options[:number]
+
+    result, transforms = @pronouncer.send :pronounce!, str, options
+
+    if options[:debug]
+      return result, transforms
+    else
+      return result
+    end
+  end
+
+  # Returns the romanization (alphabetical notation) of the given Korean string.
+  # http://en.wikipedia.org/wiki/Korean_romanization
+  # @param [String] str Input Korean string
+  # @param [Boolean] options[:as_pronounced] If true, #pronounce is internally called before romanize
+  # @param [Boolean] options[:number] Whether to read numeric expressions in the string
+  # @param [Boolean] options[:slur] Same as :slur in #pronounce 
+  # @return [String] Output string in Roman Alphabet
+  # @see Korean#pronounce
+  def romanize str, options = {}
+    options = {
+      :as_pronounced => true,
+      :number => true,
+      :slur => false
+    }.merge options
+
+    require 'yaml'
+    rdata = config['romanization']
+    post_subs = rdata["post substitution"]
+    rdata = [rdata["chosung"], rdata["jungsung"], rdata["jongsung"]]
+
+    str = pronounce str,
+      :pronounce_each_char => !options[:as_pronounced],
+      :number => options[:number],
+      :slur => options[:slur],
+      # 제1항 [붙임 1] ‘ㅢ’는 ‘ㅣ’로 소리 나더라도 ‘ui’로 적는다.
+      :except => %w[rule_5_3]
+    dash = rdata[0]["ㅇ"]
+    romanization = ""
+
+    romanize_chunk = lambda do | chunk |
+      dissect(chunk).each do | kc |
+        kc.to_a.each_with_index do | comp, idx |
+          next if comp.nil?
+          comp = rdata[idx][comp] || comp
+          comp = comp[1..-1] if comp[0, 1] == dash &&
+              (romanization.empty? || romanization[-1, 1] =~ /\s/)
+          romanization += comp
+        end
+      end
+
+      return post_subs.keys.inject(romanization) { | output, pattern |
+        output.gsub(pattern, post_subs[pattern])
+      }
+    end
+
+    k_chunk = ""
+    str.each_char do | c |
+      if korean_char? c
+        k_chunk += c
+      else
+        unless k_chunk.empty?
+          romanization = romanize_chunk.call k_chunk
+          k_chunk = ""
+        end
+        romanization += c
+      end
+    end
+    romanization = romanize_chunk.call k_chunk unless k_chunk.empty?
+    romanization
+  end
 
 private
-	def read_number_sub num, next_char
-		nconfig = config['number']
-
-		num = num.gsub(',', '')
-		next_char = next_char.to_s
-		is_float = num.match(/[\.e]/) != nil
-
-		# Alternative notation for integers with proper suffix
-		alt = false
-		if is_float == false && 
-				nconfig['alt notation']['when suffix'].keys.include?(next_char.strip)
-			max = nconfig['alt notation']['when suffix'][next_char.strip]['max']
-
-			if max.nil? || num.to_i <= max
-				alt = true
-			end
-		end
-
-		# Sign
-		sign = []
-		negative = false
-		if num =~ /^-/
-			num = num.sub(/^-\s*/, '')
-			sign << nconfig['negative']
-			negative = true
-		elsif num =~ /^\+/
-			num = num.sub(/^\+\s*/, '')
-			sign << nconfig['positive']
-		end
-
-		if is_float
-			below = nconfig['decimal point']
-			below = nconfig['digits'][0] + below if num.to_f < 1
-
-			if md = num.match(/(.*)e(.*)/)
-				dp = md[1].index('.')
-				num = md[1].tr '.', ''
-				exp = md[2].to_i
-
-				dp += exp
-				if dp > num.length
-					num = num.ljust(dp, '0')
-					num = num.sub(/^0+([1-9])/, "\\1")
-
-					below = ""
-				elsif dp < 0
-					num = '0.' + '0' * (-dp) + num
-				else
-					num[dp] = '.' + num[dp]
-				end
-			end
-			num.sub(/.*\./, '').each_char do | char |
-				below += nconfig['digits'][char.to_i]
-			end if num.include? '.'
-			num = num.sub(/\..*/, '')
-		else
-			below = ""
-		end
-
-		tokens = []
-		unit_idx = -1
-		num = num.to_i
-		while num > 0
-			v = num % 10000
-
-			unit_idx += 1
-			if v > 0
-				if alt == false || unit_idx >= 1
-					str = ""
-					# Cannot use hash as they're unordered in 1.8
-					[[1000, '천'],
-					 [100,  '백'],
-					 [10,   '십']].each do | arr |
-						u, sub_unit = arr
-						str += (nconfig['digits'][v/u] if v/u != 1).to_s + sub_unit + ' ' if v / u > 0
-						v %= u
-					end
-					str += nconfig['digits'][v] if v > 0
-
-					tokens << str.sub(/ $/, '') + nconfig['units'][unit_idx]
-				else
-					str = ""
-					tenfolds = nconfig['alt notation']['tenfolds']
-					digits = nconfig['alt notation']['digits']
-					alt_post_subs = nconfig['alt notation']['post substitution']
-
-					# Likewise.
-					[[1000, '천'],
-					 [100,  '백']].each do | u, sub_unit |
-						str += (nconfig['digits'][v/u] if v/u != 1).to_s + sub_unit + ' ' if v / u > 0
-						v %= u
-					end
-
-					str += tenfolds[(v / 10) - 1] if v / 10 > 0
-					v %= 10
-					str += digits[v] if v > 0
-
-					alt_post_subs.each do | k, v |
-						str.gsub!(k, v)
-					end if alt
-					tokens << str.sub(/ $/, '') + nconfig['units'][unit_idx]
-				end
-			end
-			num /= 10000
-		end
-
-		tokens += sign unless sign.empty?
-		ret = tokens.reverse.join(' ') + below + next_char
-		nconfig['post substitution'].each do | k, v |
-			ret.gsub!(k, v)
-		end
-		ret
-	end
+  def read_number_sub num, next_char
+    nconfig = config['number']
+
+    if num == '0'
+      return nconfig['digits'].first
+    end
+
+    num = num.gsub(',', '')
+    next_char = next_char.to_s
+    is_float = num.match(/[\.e]/) != nil
+
+    # Alternative notation for integers with proper suffix
+    alt = false
+    if is_float == false && 
+        nconfig['alt notation']['when suffix'].keys.include?(next_char.strip)
+      max = nconfig['alt notation']['when suffix'][next_char.strip]['max']
+
+      if max.nil? || num.to_i <= max
+        alt = true
+      end
+    end
+
+    # Sign
+    sign = []
+    negative = false
+    if num =~ /^-/
+      num = num.sub(/^-\s*/, '')
+      sign << nconfig['negative']
+      negative = true
+    elsif num =~ /^\+/
+      num = num.sub(/^\+\s*/, '')
+      sign << nconfig['positive']
+    end
+
+    if is_float
+      below = nconfig['decimal point']
+      below = nconfig['digits'][0] + below if num.to_f < 1
+
+      if md = num.match(/(.*)e(.*)/)
+        dp = md[1].index('.')
+        num = md[1].tr '.', ''
+        exp = md[2].to_i
+
+        dp += exp
+        if dp > num.length
+          num = num.ljust(dp, '0')
+          num = num.sub(/^0+([1-9])/, "\\1")
+
+          below = ""
+        elsif dp < 0
+          num = '0.' + '0' * (-dp) + num
+        else
+          num[dp, 1] = '.' + num[dp, 1]
+        end
+      end
+      num.sub(/.*\./, '').each_char do | char |
+        below += nconfig['digits'][char.to_i]
+      end if num.include? '.'
+      num = num.sub(/\..*/, '')
+    else
+      below = ""
+    end
+
+    tokens = []
+    unit_idx = -1
+    num = num.to_i
+    while num > 0
+      v = num % 10000
+
+      unit_idx += 1
+      if v > 0
+        if alt == false || unit_idx >= 1
+          str = ""
+          # Cannot use hash as they're unordered in 1.8
+          [[1000, '천'],
+           [100,  '백'],
+           [10,   '십']].each do | arr |
+            u, sub_unit = arr
+            str += (nconfig['digits'][v/u] if v/u != 1).to_s + sub_unit + ' ' if v / u > 0
+            v %= u
+          end
+          str += nconfig['digits'][v] if v > 0
+
+          tokens << str.sub(/ $/, '') + nconfig['units'][unit_idx]
+        else
+          str = ""
+          tenfolds = nconfig['alt notation']['tenfolds']
+          digits = nconfig['alt notation']['digits']
+          alt_post_subs = nconfig['alt notation']['post substitution']
+
+          # Likewise.
+          [[1000, '천'],
+           [100,  '백']].each do | u, sub_unit |
+            str += (nconfig['digits'][v/u] if v/u != 1).to_s + sub_unit + ' ' if v / u > 0
+            v %= u
+          end
+
+          str += tenfolds[(v / 10) - 1] if v / 10 > 0
+          v %= 10
+          str += digits[v] if v > 0
+
+          alt_post_subs.each do | k, v |
+            str.gsub!(k, v)
+          end if alt
+          tokens << str.sub(/ $/, '') + nconfig['units'][unit_idx]
+        end
+      end
+      num /= 10000
+    end
+
+    tokens += sign unless sign.empty?
+    ret = tokens.reverse.join(' ') + below + next_char
+    nconfig['post substitution'].each do | k, v |
+      ret.gsub!(k, v)
+    end
+    ret
+  end
 end#Korean
 end#Gimchi