ting 0.2.0

data/lib/ting/exception.rb

@@ -0,0 +1,17 @@
+module Ting
+
+  # All exceptions arising from this module inherit from Ting::Error
+
+  class Error < StandardError ; end
+
+  class ParseError < Error
+    attr_reader :input, :position
+
+    def initialize(input, position)
+      @input=input
+      @position=position
+    end
+  end
+
+end
+  

data/lib/ting/groundwork.rb

@@ -0,0 +1,177 @@
+# Classes and constants used throughout the module
+#  * Initial
+#  * Final
+#  * TonelessSyllable
+#  * Syllable
+#  * ILLEGAL_COMBINATIONS
+
+module Ting
+
+  #
+  # 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/ting/string.rb

@@ -0,0 +1,17 @@
+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]=(Ting.writer(:hanyu, :accents) << Ting.reader(:hanyu, :numbers).parse(m.downcase))
+    end
+  end
+
+  def bpmf
+    self.gsub('u:','ü').scan(/[A-Za-züÜ]{1,5}\d/).map do |m|
+      Ting.writer(:zhuyin, :marks) << 
+        (Ting.reader(:hanyu, :numbers) << m.downcase)
+    end.join(' ')
+  end
+end

data/lib/ting/support.rb

@@ -0,0 +1,19 @@
+class String
+  def chars
+    self.unpack('U*').map{|c| [c].pack('U')}
+  end
+
+  def camelcase
+    str = dup
+    str.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
+    str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+    str
+  end
+end
+
+module Kernel
+  def returning(s)
+    yield(s)
+    s
+  end
+end

data/lib/ting/tones.rb

@@ -0,0 +1,65 @@
+module Ting
+  #
+  # Base class for Tone classes
+  #
+  class Tone
+    VALID_TONES  = 1..5
+    MAX_TONE = NEUTRAL_TONE = 5
+
+    class <<self
+      # Add a tone to a syllable
+      def add_tone(s,t)
+        s
+      end
+
+      # Determine the tone of a syllable
+      def peek_tone(s)
+        NEUTRAL_TONE
+      end
+
+      # Remove the tone from a syllable
+      def pop_tone(s)
+        [NEUTRAL_TONE, s]
+      end
+
+    private
+      # Make sure the tone number is in the valid range.
+      # Neutral tone is always represented as NEUTRAL_TONE (5), and not 0.
+      def normalize(t)
+        if VALID_TONES === t
+          t
+        else
+          t %= MAX_TONE
+          t = NEUTRAL_TONE if t == 0
+        end
+      end
+
+    end
+  end
+end
+
+# Tone marks as a separate glyph, e.g. for Bopomofo
+require "ting/tones/marks"
+
+# Tone numbers added after the syllable
+require "ting/tones/numbers"
+
+# Tone accents, for Hanyu pinyin
+require "ting/tones/accents"
+
+# Superscript numerals, for Wade-Giles
+require "ting/tones/supernum"
+
+# IPA tone symbols
+require "ting/tones/ipa"
+
+# No tones
+require "ting/tones/no_tones"
+
+module Ting
+  module Tones
+    All = [Numbers, Marks, Accents, NoTones]
+    VALID_TONES  = 1..5
+    MAX_TONE = NEUTRAL_TONE = 5
+  end
+end

data/lib/ting/tones/accents.rb

@@ -0,0 +1,62 @@
+module Ting
+  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/ting/tones/ipa.rb

@@ -0,0 +1,24 @@
+module Ting
+  module Tones
+    class Ipa < Tone
+      class <<self
+
+        GLYPHS=['', '˥˥', '˧˥', '˧˩˧', '˥˩',] #http://wapedia.mobi/en/Wikipedia:IPA_for_Mandarin
+
+        def add_tone(syll,tone)
+          syll + GLYPHS[normalize(tone) % 5]
+        end
+
+        def peek_tone(syll)
+          return t if t = GLYPHS.index(syll.chars[-1])
+          return NEUTRAL_TONE
+        end
+
+        def pop_tone(syll)
+          [ peek_tone(syll), syll[/\A[^#{GLYPHS.join}]+/] ]
+        end
+
+      end
+    end
+  end
+end

data/lib/ting/tones/marks.rb

@@ -0,0 +1,30 @@
+module Ting
+  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/ting/tones/no_tones.rb

@@ -0,0 +1,7 @@
+module Ting
+  module Tones
+    class NoTones < Tone
+    end
+  end
+end
+      

data/lib/ting/tones/numbers.rb

@@ -0,0 +1,25 @@
+module Ting
+  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