Tibetan alphabet

tibetanalpha.rb

#!/usr/bin/env ruby

require 'optparse'

TibetanAlpha =
[%w[ཀ ཁ ག ང],
 %w[ཅ ཆ ཇ ཉ],
 %w[ཏ ཐ ད ན],
 %w[པ ཕ བ མ],
 %w[ཙ ཚ ཛ ཝ],
 %w[ཞ ཟ འ ཡ],
 %w[ར ལ ཤ ས],
 %w[ཧ ཨ]]

TibetanPhonoHu =
[%w[k kh g ng],
 %w[cs csh dzs ny],
 %w[t th d n],
 %w[p ph b m],
 %w[c ch dz v],
 %w[zs z a j],
 %w[r l s sz],
 %w[h A]]

TibetanPhonoEn =
[%w[k kh g ng],
 %w[c ch j ny],
 %w[t th d n],
 %w[p ph b m],
 %w[ts tsh dz w],
 %w[zh z ' y],
 %w[r l sh s],
 %w[h a]]


if __FILE__ == $0

  iter = false
  show = false
  lang = "en"
  OptionParser.new do |op|
    op.on("-n", "--iter N", Integer) { |n| iter = n }
    op.on("-s", "--show") { show = true }
    op.on("-l", "--lang L") { |l| lang = l }
  end.parse!

  TibetanPhono = self.class.const_get("TibetanPhono" + lang.capitalize)
  TibetanPhonoMap = [TibetanAlpha, TibetanPhono].map(&:flatten).transpose.to_h

  if show
    TibetanAlpha.zip(TibetanPhono).each do |ta,la|
      puts ta.zip(la).map { |t,l| "#{t}: #{l}" }.join(", ")
    end
    exit
  end

  # clear the terminal
  print "\33[H\33[J"
  results = %i[hits misses passes].instance_eval do
    zip(map{[]}).to_h
  end
  passes = []
  misses = []
  tmap = TibetanPhonoMap.dup
  puts (catch :done do
    (iter || TibetanPhonoMap.size).downto(1) do |i|
      l = tmap.keys.sample
      v = tmap.send(iter ? :fetch : :delete, l)
      puts "#{i}. #{l}"
      belongs_to = :hits
      loop {
        u = STDIN.gets.strip
        case u
        when "?"
          puts v
          belongs_to = :passes
          break
        when ""
          puts "press enter once more if you really want to exit."
          if STDIN.gets =~ /^$/
            throw :done
          else
            next
          end
        end
        unless TibetanPhonoMap.each_value.include? u
          puts "no such letter, I assume it's a typo."
          next
        end
        if p(u == v)
          break
        else
          belongs_to = :misses
        end
      }
      results[belongs_to] << l
      puts
    end
    "done!"
  end)

  puts "hits: #{results[:hits].size}/#{results.each_value.map(&:size).inject(&:+)}"
  %i[passes misses].each do |t|
    a = results[t]
    unless a.empty?
      puts "you had #{a.size} #{t}, namely: #{a.map { |l| "#{l}: #{TibetanPhonoMap[l]}" }.join ", "}"
    end
  end

end