arnebrasseur-pinyin 0.1.5

data/lib/pinyin/exception.rb

@@ -0,0 +1,14 @@
+module Pinyin
+  # All exceptions arising from this module inherit from Pinyin::Error
+  Error = Class.new StandardError
+
+  class ParseError < Error
+    attr_reader :input, :position
+
+    def initialize(input, position)
+      @input=input
+      @position=position
+    end
+  end
+end
+  

data/lib/pinyin/groundwork.rb

@@ -0,0 +1,183 @@
+# Classes and constants used throughout the module
+#  * Initial
+#  * Final
+#  * TonelessSyllable
+#  * Syllable
+#  * ILLEGAL_COMBINATIONS
+
+module Pinyin
+
+  #
+  # A Chinese initial (start of a syllable)
+  #
+
+  class Initial
+    attr :name
+    def initialize(n)
+      @name=n
+    end
+
+    All = %w(
+      Empty Bo Po Mo Fo De Te Ne Le Ge Ke He
+      Ji Qi Xi Zhi Chi Shi Ri Zi Ci Si
+      ).map{|c| const_set c, Initial.new(c)}
+
+    class <<self
+      private :new
+    end
+
+    Groups=[
+            Group_0=[ Empty ],
+            Group_1=[ Bo,Po,Mo,Fo],     #Bilabial and Labio-dental
+            Group_2=[ De,Te,Ne,Le ],    #Plosive, nasal and lateral approximant alveolar
+            Group_3=[ Ge,Ke,He ],       #Velar
+            Group_4=[ Ji,Qi,Xi ],       #Alveolo-palatal
+            Group_5=[ Zhi,Chi,Shi,Ri ], #Retroflex
+            Group_6=[ Zi,Ci,Si ],       #Fricative and affricate alveolar
+           ]
+    
+    def +(f)
+      TonelessSyllable.new(self,f)
+    end
+
+    def inspect()
+      "<#{self.class.name}::#{@name}>"
+    end
+  end
+
+  #
+  # A Chinese final (end of a syllable)
+  #
+  
+  class Final
+    attr :name
+    def initialize(n)
+      @name=n
+    end
+
+    All=%w(
+      Empty A O E Ee Ai Ei Ao Ou An En Ang Eng Ong Er 
+      I Ia Io Ie Iai Iao Iu Ian In Iang Ing 
+      U Ua Uo Uai Ui Uan Un Uang Ueng V Ue Van Vn Iong
+    ).map{|c| const_set c, Final.new(c)}
+    
+    class <<self
+      private :new
+    end
+    
+    Groups=[
+            Group_0=[ Empty ],
+            Group_A=[ A,O,E,Ee,Ai,Ei,Ao,Ou,An,En,Ang,Eng,Ong,Er ],
+            Group_I=[ I,Ia,Io,Ie,Iai,Iao,Iu,Ian,In,Iang,Ing ],
+            Group_U=[ U,Ua,Uo,Uai,Ui,Uan,Un,Uang,Ueng ],
+            Group_V=[ V,Ue,Van,Vn,Iong]
+           ]
+    def inspect()
+      "<#{self.class.name}::#{name}>"
+    end
+  end
+
+
+  #
+  # Combination of an initial and a final
+  # Not to be confused with a syllable that has the neutral tone
+  #
+
+  class TonelessSyllable
+    attr_accessor :initial, :final
+
+    def initialize(initial, final)
+      self.initial = initial
+      self.final   = final
+    end
+
+    def +(tone)
+      Syllable.new(initial, final, tone)
+    end
+
+    def inspect
+      "<#{self.class.name} <initial=#{initial.name}, final=#{final.name}>>"
+    end
+
+    def self.illegal?(i,f)
+      ILLEGAL_COMBINATIONS.any? {|in_gr, fin_gr| in_gr.include?(i) && fin_gr.include?(f)}
+    end
+
+    alias :to_s :inspect
+  end
+
+
+  #
+  # Syllable : initial, final and tone
+  #
+
+  class Syllable < TonelessSyllable
+    attr_accessor :tone
+
+    def initialize(initial, final, tone)
+      super(initial, final)
+      self.tone = tone
+    end
+
+    def inspect
+      "<#{self.class.name} <initial=#{initial.name}, final=#{final.name}, tone=#{tone}>>"
+    end
+
+    alias :to_s :inspect
+  end
+
+  #
+  # Some groups of initials and finals may not be combined
+  # This list is not exhaustive but is sufficient to resolve ambiguity
+  #
+
+  ILLEGAL_COMBINATIONS=
+    [               
+     [Initial::Group_0, Final::Group_0],
+     [Initial::Group_1, Final::Group_0],
+     [Initial::Group_2, Final::Group_0],
+     [Initial::Group_3, Final::Group_0],
+     [Initial::Group_4, Final::Group_0],
+
+     [Initial::Group_4, Final::Group_U],
+     [Initial::Group_4, Final::Group_A],
+
+     [Initial::Group_3, Final::Group_I],
+     [Initial::Group_5, Final::Group_I],
+     [Initial::Group_6, Final::Group_I],
+
+     [Initial::Group_1, Final::Group_V],
+     [Initial::Group_3, Final::Group_V],
+
+     #2008.05.26 lo is also valid!
+     #[Initial::Group_2, [Final::O]],  #Only bo, po, mo and fo are valid -o combinations
+     [Initial::Group_3, [Final::O]],
+     [Initial::Group_4, [Final::O]],
+     [Initial::Group_5, [Final::O]],
+     [Initial::Group_6, [Final::O]],
+
+     [[Initial::Empty], [Final::Ong]] 
+       # TODO: Ong is actually the same as Ueng, in Hanyu Pinyin : -ong or weng
+    ]
+
+  class <<self
+
+
+    #
+    # Yields a block for any valid initial/final pair
+    #
+
+    def valid_combinations
+      require 'yaml'
+      inp = YAML::load(IO.read(File.join(File.dirname(__FILE__), 'data', 'valid_pinyin.yaml')))
+      inp.each do |final, initials|
+        final = Final.const_get(final)
+        initials.each do |initial, pinyin|
+          initial = Initial.const_get(initial)
+          yield(initial, final)
+        end
+      end
+    end
+  end
+                       
+end

data/lib/pinyin/string.rb

@@ -0,0 +1,16 @@
+class String
+  PINYIN_CACHE={}
+  def pretty_tones
+    self.gsub('u:','ü').gsub(/[A-Za-züÜ]{1,5}\d/) do |m|
+      m.downcase!
+      PINYIN_CACHE[m] || PINYIN_CACHE[m]=(Pinyin.HanyuWriter(:accents) << Pinyin.HanyuReader(:numbers).parse(m.downcase))
+    end
+  end
+
+  def bpmf
+    self.gsub('u:','ü').scan(/[A-Za-züÜ]{1,5}\d/).map do |m|
+      Pinyin.ZhuyinWriter(:marks) << 
+        (Pinyin.HanyuReader(:numbers) << m.downcase)
+    end.join(' ')
+  end
+end

data/lib/pinyin/support.rb

@@ -0,0 +1,12 @@
+class String
+  def chars
+    self.unpack('U*').map{|c| [c].pack('U')}
+  end
+end
+
+module Kernel
+  def returning(s)
+    yield(s)
+    s
+  end
+end

data/lib/pinyin/tones.rb

@@ -0,0 +1,47 @@
+module Pinyin
+  #
+  # Base class for Tone classes
+  #
+  class Tone
+    VALID_TONES  = 1..5
+    MAX_TONE = NEUTRAL_TONE = 5
+
+    class <<self
+    def add_tone(s,t)
+      s
+    end
+
+    def peek_tone(s)
+      NEUTRAL_TONE
+    end
+
+    def pop_tone(s)
+      [NEUTRAL_TONE, s]
+    end
+
+    private
+      def normalize(t)
+        if VALID_TONES === t
+          t
+        else
+          t %= MAX_TONE
+          t = NEUTRAL_TONE if t == 0
+        end
+      end
+
+    end
+  end
+end
+
+require "pinyin/tones/marks"
+require "pinyin/tones/numbers"
+require "pinyin/tones/accents"
+require "pinyin/tones/no_tones"
+
+module Pinyin
+  module Tones
+    All = [Numbers, Marks, Accents, NoTones]
+    MAX_TONE = NEUTRAL_TONE = 5
+    VALID_TONES  = 1..5
+  end
+end

data/lib/pinyin/tones/accents.rb

@@ -0,0 +1,62 @@
+module Pinyin
+  module Tones
+    class Accents < Tone
+      class <<self
+
+      UNICODE_TONE_GLYPHS={ 
+        :a=>[97, 257, 225, 462, 224],
+        :e=>[101, 275, 233, 283, 232],
+        :i=>[105, 299, 237, 464, 236],
+        :o=>[111, 333, 243, 466, 242],
+        :u=>[117, 363, 250, 468, 249],
+        :v=>[252, 470, 472, 474, 476]
+      }
+
+      def tone_glyph(letter,tone)
+        if (u=UNICODE_TONE_GLYPHS[letter.to_sym][tone%MAX_TONE])
+          [u].pack('U')
+        end
+      end
+
+      def add_tone(syll, tone)
+        syll.gsub!('ü','v')
+        tone %= MAX_TONE
+        case syll
+        when /a/ : syll.sub(/a/, tone_glyph(:a,tone))
+        when /e/ : syll.sub(/e/, tone_glyph(:e,tone))
+        when /o/ : syll.sub(/o/, tone_glyph(:o,tone))
+        when /(i|u|v)/ : syll.sub($1, tone_glyph($1,tone))
+        else syll
+        end  
+      end
+
+      def peek_tone(syll)
+        unpacked = syll.unpack('U*')
+        each_tone_glyph do |vowel, tones|
+          tone_glyph=unpacked.find {|t| tones.include?(t)}
+          normalize( tones.index(tone_glyph) ) if tone_glyph
+        end
+      end
+
+      def pop_tone(syll)
+        unpacked = syll.unpack('U*')
+        each_tone_glyph do |vowel, tones|
+          if tone_glyph = unpacked.find {|t| tones.include?(t)}
+            unpacked[unpacked.index(tone_glyph)]=vowel.to_s[0]
+            break [normalize(tones.index(tone_glyph)), unpacked.pack('U*')]
+          end
+        end
+      end
+
+      private
+        def each_tone_glyph
+          [:a,:e,:i,:o,:u,:v].each do |v|  #Order is significant
+            vowel, tones = v, UNICODE_TONE_GLYPHS[v]
+            yield vowel,tones
+          end
+        end
+
+    end
+    end
+  end
+end

data/lib/pinyin/tones/marks.rb

@@ -0,0 +1,30 @@
+module Pinyin
+  module Tones
+    class Marks < Tone
+      class <<self
+
+      GLYPHS=['˙', '', 'ˊ', 'ˇ', 'ˋ']
+
+      def add_tone(syll,tone)
+        syll + GLYPHS[normalize(tone) % 5]
+      end
+
+      def peek_tone(syll)
+        case syll
+        when /ˊ/ : 2
+        when /ˇ/ : 3
+        when /ˋ/ : 4
+        when /˙/ : NEUTRAL_TONE
+        else 
+          1
+        end
+      end
+
+      def pop_tone(syll)
+        [ peek_tone(syll), syll[/\A[^#{GLYPHS.join}]+/] ]
+      end
+
+      end
+    end
+  end
+end

data/lib/pinyin/tones/no_tones.rb

@@ -0,0 +1,6 @@
+module Pinyin
+  module Tones
+    NoTones = Pinyin::Tone
+  end
+end
+      

data/lib/pinyin/tones/numbers.rb

@@ -0,0 +1,25 @@
+module Pinyin
+  module Tones
+    class Numbers < Tone
+      class <<self
+
+      def add_tone(syll, tone)
+        syll + normalize(tone).to_s
+      end
+
+      def peek_tone(syll)
+        if syll =~ /(\d)\Z/
+          normalize Integer($1)
+        else
+          NEUTRAL_TONE
+        end
+      end      
+
+      def pop_tone(syll)
+        [ peek_tone(syll), syll[/\A\D+/] ]
+      end
+
+      end
+    end
+  end
+end

data/rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'hoe'
+
+$:.unshift './lib'
+
+require 'pinyin'
+
+Hoe.new('pinyin', Pinyin::VERSION) do |p|
+  p.rubyforge_name = 'pinyin'
+  p.summary = 'A conversion library for Chinese transcription methods like Hanyu Pinyin, Bopomofo and Wade-Giles.'
+  p.description = p.paragraphs_of('README.txt', 2).join
+  p.url = 'http://rubyforge.org/projects/pinyin'
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.email = 'pinyin@arnebrasseur.net'
+  p.author = 'Arne Brasseur'
+  p.extra_deps << ['facets', '>= 2.4.0']
+  p.spec_extras = {
+    :extra_rdoc_files => ['README.txt', 'History.txt'],
+    :rdoc_options => ['--main', 'README.txt'],
+    :platform => Gem::Platform::RUBY
+  }
+end

data/script/update

@@ -0,0 +1,4 @@
+sudo gem uninstall pinyin 
+rake clean
+rake package
+sudo gem install pkg/pinyin -y

data/test/test_comparison.rb

@@ -0,0 +1,35 @@
+require 'pinyin'
+require 'test/unit'
+require 'csv'
+
+
+# This test uses the chart from piyin.info to compare all implemted conversion types
+# Since I can't find another reference of the hanyu pinyin 'lo', I have removed it from the table
+
+class TestCompare < Test::Unit::TestCase
+  CHART=CSV.parse(IO.read(File.dirname(__FILE__)+'/../lib/pinyin/data/comparison.csv'))
+  COMPARE=[:hanyu, :wadegiles, :zhuyin, :tongyong]
+
+
+  # Test all combinations, included parsing/unparsing the same type
+
+  def test_do_comparisons
+    COMPARE.each do |from|
+      COMPARE.each do |to|
+        compare(from,to)
+      end
+    end
+  end
+
+  def compare(from, to)
+    reader = Pinyin::Reader.new(from, :no_tones)
+    writer = Pinyin::Writer.new(to, :no_tones)
+
+    ifrom = CHART[0].index from.to_s
+    ito   = CHART[0].index to.to_s
+
+    CHART[1..-1].each do |vals|
+      assert_equal(vals[ito].strip, writer << (reader << vals[ifrom].strip), "Converting from #{from} to #{to} value #{vals[ito]}")
+    end
+  end
+end