klookup 0.2

data/lib/klookup.rb

@@ -0,0 +1,27 @@
+=begin
+
+  lib/klookup.rb
+
+  Copyright © Tom Adams 2006
+
+  This programme is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby License.
+
+=end
+
+begin
+  require 'active_support'
+rescue LoadError
+  require 'runicode'
+end
+
+#This allows regular expressions to work on characters.
+$KCODE='u'
+require 'jcode'
+
+# Contains Lookup and Database.
+module KLookup
+  require 'klookup/database'
+  require 'klookup/lookup'
+end

data/lib/klookup/database.rb

@@ -0,0 +1,66 @@
+=begin
+
+  lib/klookup/database.rb
+
+  Copyright © Tom Adams 2006
+
+  This programme is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby License.
+
+=end
+
+# Database access modules:
+# - FlatFile
+# - Unihan
+class KLookup::Database
+
+  private
+
+  def undefined(*args)
+    raise NotImplementedError
+  end
+
+  public
+
+  # Opens a resource.
+  #
+  # Priority: LOOKUP_PATH environment variable, Gem load path.
+  def self.open_resource(path)
+    # Choose a directory
+    env=ENV['KLOOKUP_PATH']
+    if env and env != ''
+      dir=env+'/klookup'
+    else
+      dir=gem_path
+      begin
+        gem 'klookup'
+        dir=Gem.datadir 'klookup'
+      rescue NameError
+        raise IOError, 'Could not find resource %s' % path
+      end
+    end
+
+    # Open a file
+    file = open("#{dir}/#{path}")
+    if block_given?
+      yield file
+    else
+      return file
+    end
+  end
+
+  alias :stroke_count_list :undefined
+  alias :radicals_by_strokes :undefined
+  alias :get_kanji :undefined
+  alias :get_radical_strokes :undefined
+  alias :get_kanji_strokes :undefined
+  alias :get_radicals :undefined
+  alias :get_reading :undefined
+  alias :get_meaning :undefined
+  alias :is_kanji? :undefined
+  alias :is_radical? :undefined
+
+  require 'klookup/database_flatfile'
+  require 'klookup/database_unihan'
+end

data/lib/klookup/database_flatfile.rb

@@ -0,0 +1,52 @@
+=begin
+
+  lib/klookup/database_flatfile.rb
+
+  Copyright © Tom Adams 2006
+
+  This programme is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby License.
+
+=end
+
+# A singleton class to abstract RadK and KanjiDic.
+class KLookup::Database::FlatFile < KLookup::Database
+  require 'klookup/database_flatfile_radk'
+  require 'klookup/database_flatfile_kanjidic'
+
+  require 'singleton'
+  include Singleton
+
+  def stroke_count_list(*args)
+    RadK.instance.stroke_count_list(*args)
+  end
+  def radicals_by_strokes
+    RadK.instance.radicals_by_strokes
+  end
+  def get_kanji(strokes, *args)
+    RadK.instance.get_kanji(*args).delete_if {|k|
+      not strokes.nil? and not get_kanji_strokes(k) == strokes }
+  end
+  def get_radical_strokes(*args)
+    RadK.instance.get_strokes(*args)
+  end
+  def get_kanji_strokes(*args)
+    KanjiDic.instance.get_strokes(*args)
+  end
+  def get_radicals(*args)
+    RadK.instance.get_radicals(*args)
+  end
+  def get_reading(*args)
+    KanjiDic.instance.get_reading(*args)
+  end
+  def get_meaning(*args)
+    KanjiDic.instance.get_meaning(*args)
+  end
+  def is_kanji?(*args)
+    KanjiDic.instance.is_kanji?(*args)
+  end
+  def is_radical?(*args)
+    RadK.instance.is_radical?(*args)
+  end
+end

data/lib/klookup/database_flatfile_kanjidic.rb

@@ -0,0 +1,128 @@
+=begin
+
+  lib/klookup/database_flatfile_kanjidic.rb
+
+  Copyright © Tom Adams 2006
+
+  This programme is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby License.
+
+=end
+
+# Access to the KANJIDIC (additional information about kanji).
+class KLookup::Database::FlatFile::KanjiDic
+  require 'singleton'
+  include Singleton
+
+  private
+
+  def initialize(path='kanjidic')
+    @records={}
+    KLookup::Database.open_resource(path) {|kanjidic|
+      extract_records kanjidic
+    }
+  end
+
+  # Runs process_line on each line of +file+.
+  def extract_records(file)
+    file.each_line { |line|
+      if line =~ /^\s*#/ or line =~ /^\s*$/
+        next # No content, so skip
+      else
+        process_line line
+      end
+    }
+  end
+
+  # Sets +@records+.
+  def process_line(line)
+    items = line.split(/ /)
+    kanji = items.delete_at 0
+
+    # Set the record
+    @records[kanji] = {:items=>items}
+  end
+
+  #Returns true if there is kana in the string.
+  def include_kana?(str)
+    kana = (0x3040..0x30FF)
+    str.split(//).each {|i|
+      return true if kana.include? i.chars[0]
+    }
+    false
+  end
+
+  public
+
+  # Returns true if a kanji exists in the database.
+  def is_kanji?(kanji)
+    return false unless kanji.respond_to?(:to_s)
+    return false if kanji.to_s.chars.length != 1
+    return false if @records[kanji.to_s].nil?
+    return true
+  end
+
+  # Returns the number of strokes needed to write a given kanji.
+  def get_strokes(kanji)
+    @records[kanji][:items].select {|i|
+      i =~ /^S\d+$/}.first.sub(/^S(\d+)$/, '\1').to_i
+  end
+
+  #Returns a Struct of arrays of Japanese readings.
+  #
+  # KLookup::Database::FlatFile::KanjiDic.instance.get_reading('富')
+  # #=> #<struct #<Class:0xb7d3b5dc> reading=["フ", "フウ", "と.む", "とみ"],
+  #                                  name_reading=["と", "とん", "ふっ"]>
+  def get_reading(kanji)
+    items = @records[kanji][:items]
+    # Set readings
+    name_flag = false
+    reading = []
+    name_reading = []
+    items.each {|i|
+      name_flag = true if i=='T1'
+      if include_kana?(i)
+        if name_flag
+          name_reading << i
+        else
+          reading << i
+        end
+      end
+    }
+
+    return Struct.new(:reading,:name_reading).new(reading, name_reading)
+  end
+
+  # Returns an array of English meanings of kanji.
+  def get_meaning(kanji)
+    items = @records[kanji][:items]
+    # Select the items with the meaning
+    flag=false
+    temp_meaning = items.select {|i|
+      if i =~ /^\{|\}$/ or flag
+        flag=true
+      end
+    }
+    temp_meaning.map! {|i| i.sub(/^\{(.*)\}$/, '\1') }
+    temp_meaning.delete_if {|i| i=~/^\s*$/}
+
+    # Stick the meanings together
+    finish=true
+    meaning=[]
+    temp_meaning.each {|m|
+      if m =~ /^\{(.*)$/ # {one
+        meaning << $1
+        finish = false
+      elsif finish # there are no strings being constructed
+        meaning << m
+      elsif m =~ /^(.*)\}$/ # three}
+        meaning.last<< ' ' + $1
+        finish = true
+      else # two (when there are strings being finished)
+        meaning.last<< ' ' + m.dup
+      end
+    }
+    meaning
+  end
+end

data/lib/klookup/database_flatfile_radk.rb

@@ -0,0 +1,136 @@
+=begin
+
+  lib/klookup/database_flatfile_radk.rb
+
+  Copyright © Tom Adams 2006
+
+  This programme is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby License.
+
+=end
+
+# Access to RADKFILE (mappings from radicals to kanji).
+class KLookup::Database::FlatFile::RadK
+  require 'singleton'
+  include Singleton
+
+  attr_reader :stroke_count_list
+  attr_reader :radicals_by_strokes
+
+  private
+
+  class MalformedDatabaseException < Exception; end
+
+  def initialize(path='newradkfile')
+    @stroke_count_list = []
+    @radicals_by_strokes = {}
+
+    KLookup::Database.open_resource(path) {|radkfile|
+      extract_records radkfile
+    }
+  end
+
+  # Saves a record in the class variable +@records+.
+  def save_record(radical,strokes,kanji)
+    unless radical.respond_to?(:to_s) and
+        strokes.respond_to?(:to_i) and
+        kanji.respond_to?(:to_a)
+      raise ArgumentError
+    end
+    radical=radical.to_s
+    strokes=strokes.to_i
+    kanji=kanji.to_a
+
+    # @records is a hash of hashes:
+    # @records = {
+    #   ...
+    #   '龠' => {:strokes=>17, :kanji=>['籥', '鑰', '龠']}
+    # }
+    @records[radical]={:strokes=>strokes, :kanji=>kanji}
+    
+    (@stroke_count_list << strokes).sort!.uniq!
+
+    unless @radicals_by_strokes[strokes]
+      @radicals_by_strokes[strokes]=[]
+    end
+    @radicals_by_strokes[strokes] << radical
+  end
+
+  # Takes a string of data and interprets it.
+  def extract_records(radk)
+    @records = {}
+    @stroke_count_list = []
+    radical_line_passed=false
+    radical = nil
+    strokes = nil
+    kanji = nil
+
+    radk.each_line { |line|
+      if line.match(/^#/) or line.match(/^$/)
+        next # because it's a comment
+      elsif line.match(/^\$\s+([^\s])\s+(\d+)/)
+        # It's a radical line
+
+        # Save the previous record
+        save_record(radical,strokes,kanji) if radical_line_passed
+        radical_line_passed=true
+
+        radical = $1
+        strokes = $2
+        kanji = [] # Reset
+
+      elsif not radical_line_passed
+        raise MalformedDatabaseException
+      elsif
+        # It must be a line of kanji
+        kanji << line.split(//)
+        kanji.flatten!
+        kanji.delete("\n")
+      end
+    }
+    # And save the record at the end
+    save_record(radical,strokes,kanji) if radical_line_passed
+  end
+
+  public
+
+  # Tests if a radical exists.
+  def is_radical?(radical)
+    return false unless radical.respond_to?(:to_s)
+    return false if radical.to_s.chars.length != 1
+    return false if @records[radical.to_s].nil?
+    return true
+  end
+
+  # Returns a list of kanji corresponding to given radicals.
+  def get_kanji(*radicals)
+    kanji = nil
+    radicals.flatten.each { |rad|
+      raise ArgumentError unless @records[rad.to_s]
+      current_kanji = @records[rad.to_s][:kanji]
+      if kanji==nil
+        kanji = current_kanji
+      else
+        kanji &= current_kanji
+      end
+    }
+    kanji.to_a
+  end
+
+  # Returns the number of strokes corresponding to a radical.
+  def get_strokes(radical)
+    @records[radical][:strokes]
+  end
+
+  # Returns a list of radicals corresponding to a kanji.
+  def get_radicals(kanji)
+    radicals = []
+    @records.each { |radical,data|
+      if data[:kanji].include? kanji
+        radicals << radical
+      end
+    }
+    radicals
+  end
+end

data/lib/klookup/database_unihan.rb

@@ -0,0 +1,101 @@
+=begin
+
+  lib/klookup/database_unihan.rb
+
+  Copyright © Tom Adams 2006
+
+  This programme is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby License.
+
+=end
+
+# Properties:
+# - kJapaneseKun
+# - kJapaneseOn
+# - kDefinition (Chinese, with Japanese marked by '(J)')
+#   (contains radical number %d for radicals)
+# - kFrequency (not language-specific)
+# - kRSJapanese
+# - kTotalStrokes
+# Properties to find:
+# - alternate radical representation
+# - alternate kanji characters
+
+# Other:
+# - Add ability to lookup arbitrary Property for character
+# - It may be faster to re-open the file every time or keep a file descriptor
+#   than to keep it all in memory
+
+# A singleton class to access Unihan.txt.
+class KLookup::Database::Unihan < KLookup::Database
+  require 'singleton'
+  include Singleton
+
+  private
+
+  def initialize
+    @unihan = KLookup::Database::Unihan.open_resource('Unihan.txt')
+  end
+
+  # Returns the numeric codepoint of the first codepoint in +str+.
+  def get_codepoint(str)
+    str.chars[0]
+  end
+
+  # Returns the hexadecimal representation used by the Unicode Standard
+  # (+%04X+) of the first codepoint in +str+.
+  def get_hexcp(str)
+    "%04X" % get_codepoint(str)
+  end
+
+  public
+
+  # Opens a resource.
+  #
+  # Priority: LOOKUP_PATH environment variable, Gem load path.
+  def self.open_resource(path)
+    # Choose a directory
+    env=ENV['KLOOKUP_PATH']
+    if env and env != ''
+      dir=env+'/unihan'
+    else
+      dir=gem_path
+      begin
+        gem 'unihan'
+        dir=Gem.datadir 'unihan'
+      rescue NameError
+        raise IOError, 'Could not find resource %s' % path
+      end
+    end
+
+    # Open a file
+    file = open("#{dir}/#{path}")
+    if block_given?
+      yield file
+    else
+      return file
+    end
+  end
+
+  def stroke_count_list(*args)
+  end
+  def radicals_by_strokes
+  end
+  def get_kanji(strokes, *args)
+  end
+  def get_radical_strokes(*args)
+  end
+  def get_kanji_strokes(*args)
+  end
+  def get_radicals(*args)
+  end
+  def get_reading(*args)
+  end
+  def get_meaning(*args)
+  end
+  def is_kanji?(*args)
+  end
+  def is_radical?(*args)
+  end
+end