gimchi 0.1.9 → 0.2.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gimchi
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,33 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-20 00:00:00.000000000 Z
+date: 2013-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &2158357040 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :development
-  prerelease: false
-  version_requirements: *2158357040
-- !ruby/object:Gem::Dependency
-  name: jeweler
-  requirement: &2158358840 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.5.2
-  type: :development
-  prerelease: false
-  version_requirements: *2158358840
-- !ruby/object:Gem::Dependency
-  name: rcov
-  requirement: &2158315180 !ruby/object:Gem::Requirement
+  name: ansi
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,42 +21,39 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2158315180
-- !ruby/object:Gem::Dependency
-  name: ansi
-  requirement: &2154666280 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.2.2
-  type: :development
-  prerelease: false
-  version_requirements: *2154666280
-description: Gimchi knows how to pronounce Korean strings and how to write them in
-  roman alphabet.
-email: junegunn.c@gmail.com
+        version: '0'
+description: A Ruby gem for Korean characters
+email:
+- junegunn.c@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE.txt
-- README.ko.markdown
-- README.markdown
+extra_rdoc_files: []
 files:
+- .document
+- .gitignore
+- CHANGELOG.rdoc
+- Gemfile
+- LICENSE.txt
+- README.ko.md
+- README.md
+- Rakefile
 - config/default.yml
+- crawler/crawler.rb
+- gimchi.gemspec
 - lib/gimchi.rb
 - lib/gimchi/char.rb
-- lib/gimchi/korean.rb
 - lib/gimchi/patch_1.8.rb
 - lib/gimchi/pronouncer.rb
-- LICENSE.txt
-- README.ko.markdown
-- README.markdown
 - test/helper.rb
 - test/pronunciation.yml
 - test/romanization.yml
 - test/test_gimchi.rb
-homepage: http://github.com/junegunn/gimchi
+homepage: https://github.com/junegunn/gimchi
 licenses:
 - MIT
 post_install_message: 
@@ -91,9 +66,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4061568131035276090
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -102,10 +74,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
-summary: Gimchi reads Korean.
+summary: A Ruby gem for Korean characters
 test_files:
 - test/helper.rb
 - test/pronunciation.yml

data/README.markdown

@@ -1,155 +0,0 @@
-# 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
-
-# Shorthand of korean_char?
-ko.kchar? '가'                 # true
-```
-
-### Usage of Gimchi::Korean::Char
-```ruby
-kc = ko.kchar "한"
-kc.class                   # Gimchi::Korean::Char
-
-kc.chosung                 # "ㅎ"
-kc.jungsung                # "ㅏ"
-kc.jongsung                # "ㄴ"
-kc.to_a                    # ["ㅎ", "ㅏ", "ㄴ"]
-kc.to_s                    # "한"
-
-kc.complete?               # true
-kc.partial?                # false
-ko.kchar("ㅏ").partial?    # true
-
-# Modifying its elements
-kc.chosung = 'ㄷ'
-kc.jongsung = 'ㄹ'
-kc.to_s                    # "달"
-kc.complete?               # true
-kc.partial?                # false
-
-kc.chosung = nil
-kc.jongsung = nil
-kc.complete?               # false
-kc.partial?                # true
-
-# Alias of kchar
-kc = ko.korean_char "한"
-
-# Array of Gimchi::Korean::Char's
-arr = ko.convert '이것은 한글입니다.'
-  # [이, 것, 은, " ", 한, 글, 입, 니, 다, "."]
-
-arr[0].class               # Gimchi::Korean::Char
-
-# Dissects given String
-arr = ko.dissect '이것은 한글입니다.'
-  # ["ㅇ", "ㅣ", "ㄱ", "ㅓ", "ㅅ", "ㅇ", "ㅡ", "ㄴ", " ", 
-  #  "H", "a", "n", "g", "u", "l", " ", "ㅇ", "ㅣ", "ㅂ",
-  #  "ㄴ", "ㅣ", "ㄷ", "ㅏ", "."]
-```
-
-### 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/lib/gimchi/korean.rb

@@ -1,323 +0,0 @@
-# encoding: UTF-8
-
-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['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 str_length(ch) > 1
-
-    complete_korean_char?(ch) || 
-      (chosungs + jungsungs + jongsungs).include?(ch)
-  end
-  alias kchar? korean_char?
-
-  # 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 str_length(ch) > 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 convert str
-    str.each_char.map { |c| 
-      korean_char?(c) ? kchar(c) : c
-    }
-  end
-
-  # Splits the given string into an array of Korean character components
-  # @param [String] str Input string.
-  # @return [Array] Array of Korean character components
-  def dissect str
-    str.each_char.inject([]) { |arr, c| 
-      arr += korean_char?(c) ? kchar(c).to_a.compact : [c]
-    }
-  end
-
-  # Returns a Korean::Char object for the given Korean character.
-  # @param [String] ch Korean character in String
-  # @return [Korean::Char] Korean::Char instance
-  def kchar ch
-    Korean::Char.new(self, ch)
-  end
-  alias korean_char kchar
-
-  # 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 |
-      convert(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 str_length str
-    str.length
-  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
-
-