klookup 0.2.2 → 0.2.4

data/bin/cklookup

@@ -64,7 +64,7 @@ DOC
       puts radicals
       puts radicals.size
     elsif str.match /^\s*kanji\s+with\s+(.+)$/
-      kanji = Kanji.lookup(nil, $1.split(//))
+      kanji = Kanji.lookup(:radical=>$1.split(//))
       puts kanji
       puts kanji.size
     elsif str.match /^\s*meaning\s+of\s+(.)\s*$/

data/bin/klookup.cgi

@@ -102,6 +102,24 @@ def put_list(items)
   puts "<p>Total: " + items.size.to_s
 end
 
+def show_radicals(params)
+    puts "<p><a href=\"?"+query_string(params.merge({'show_radicals'=>['false']}))+'">'+_('Hide radicals')+'</a>'
+    puts '<table>'
+    tparams = params.dup
+    tparams.delete 'kanji'
+    Radical.strokes.each { |strokes|
+      puts '<tr>'
+      puts '<td>' + strokes.to_s + ':'
+      Radical.list(strokes).each { |rad|
+        puts '<td>'
+        put_link rad.to_s, '?'+query_string(tparams.merge({'radicals'=>[params['radicals'].join+rad.to_s]}))
+        puts '</td>'
+      }
+      puts '</tr>'
+    }
+    puts '</table>'
+end
+
 def run
   cgi = CGI.new
   params = cgi.params
@@ -110,7 +128,14 @@ def run
   puts '<style type="text/css">'
   puts 'a {text-decoration: none}'
   puts '</style>' # This could be external
-  puts '<title>' + _('klookup %s') + '</title>'
+  puts '<title>' + _('klookup') + '</title>'
+
+  if not params['show_radicals'].empty? and params['show_radicals'].first=='true'
+    show_radicals(params)
+  else
+    puts "<p><a href=\"?"+query_string(params.merge({'show_radicals'=>['true']}))+'">'+_('Show radicals')+'</a>'
+  end
+  puts '<hr>'
 
   if not params['radicals'].empty?
     radicals = []
@@ -130,7 +155,7 @@ def run
       problem = true unless Radical.exist?(r) }
 
     unless problem
-      kanji = Kanji.lookup(nil, radicals)
+      kanji = Kanji.lookup(:radical=>radicals)
       kanji.collect! { |k|
         get_kanji(k, params)
       }
@@ -168,27 +193,6 @@ def run
     puts '<p>' + _('Hello there. This is the greatest kanji lookup tool in existence!')
   end
 
-  puts '<hr>'
-  if not params['show_radicals'].empty? and params['show_radicals'].first=='true'
-    puts "<p><a href=\"?"+query_string(params.merge({'show_radicals'=>['false']}))+'">'+_('Hide radicals')+'</a>'
-    puts '<table>'
-    tparams = params.dup
-    tparams.delete 'kanji'
-    Radical.strokes.each { |strokes|
-      puts '<tr>'
-      puts '<td>' + strokes.to_s + ':'
-      Radical.list(strokes).each { |rad|
-        puts '<td>'
-        put_link rad.to_s, '?'+query_string(tparams.merge({'radicals'=>[params['radicals'].join+rad.to_s]}))
-        puts '</td>'
-      }
-      puts '</tr>'
-    }
-    puts '</table>'
-  else
-    puts "<p><a href=\"?"+query_string(params.merge({'show_radicals'=>['true']}))+'">'+_('Show radicals')+'</a>'
-  end
-
   puts <<DOC
 <hr>
 <p><a href="?">Start over</a>

data/lib/klookup.rb

@@ -13,7 +13,12 @@
 begin
   require 'active_support'
 rescue LoadError
+#   begin
+#     require 'rubygems'
+#     require 'active_support'
+#   rescue LoadError
   require 'runicode'
+#   end
 end
 
 #This allows regular expressions to work on characters.

data/lib/klookup/database.rb

@@ -26,15 +26,15 @@ class KLookup::Database
   # Opens a resource.
   #
   # Priority: LOOKUP_PATH environment variable, Gem load path.
-  def self.open_resource(path)
+  def self.open_resource(path, mod='klookup')
     # Choose a directory
     env=ENV['KLOOKUP_PATH']
     if env and env != ''
-      dir=env+'/klookup'
+      dir=env+"/#{mod}"
     else
       begin
-        gem 'klookup'
-        dir=Gem.datadir 'klookup'
+        gem mod
+        dir=Gem.datadir(mod)
       rescue NameError
         raise IOError, 'Could not find resource %s' % path
       end
@@ -49,17 +49,17 @@ class KLookup::Database
     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 :radical_stroke_count :undefined
+  alias :find_radical :undefined
+  alias :find_kanji :undefined
+  alias :get_stroke_count :undefined
+  alias :get_radical :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'
+#  require 'klookup/database_quickfile'
+#  require 'klookup/database_unihan'
 end

data/lib/klookup/database_flatfile.rb

@@ -18,23 +18,60 @@ class KLookup::Database::FlatFile < KLookup::Database
   require 'singleton'
   include Singleton
 
-  def stroke_count_list(*args)
+  def radical_stroke_count(*args)
     RadK.instance.stroke_count_list(*args)
   end
+
+  private
   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 }
+  public
+
+  def find_radical(args={})
+    raise ArgumentError, 'a hash or nothing' unless args.kind_of?(Hash)
+    if not args[:stroke]
+      RadK.instance.radicals_by_strokes.values.flatten
+    elsif not args[:stroke].kind_of?(Integer)
+      raise ArgumentError, ':stroke must be an Integer'
+    elsif radical_stroke_count.include?(args[:stroke])
+      RadK.instance.radicals_by_strokes[args[:stroke]]
+    else
+      []
+    end
+  end
+  private
+  # If *args is nil, returns all kanji.
+  def get_kanji(strokes=nil, *args)
+    radicals = *args
+    if radicals.nil? or radicals.length == 0 or radicals.all? {|r| r.nil?}
+      kanji = KanjiDic.instance.get_all_kanji
+    else
+      kanji = RadK.instance.get_kanji(*args)
+    end
+    unless strokes.nil?
+        return kanji.select {|k| get_kanji_strokes(k) == strokes }
+    end
+    return kanji
+  end
+  public
+  def find_kanji(args)
+    get_kanji(args[:stroke], args[:radical])
   end
   def get_radical_strokes(*args)
     RadK.instance.get_strokes(*args)
   end
+  def get_stroke_count
+    begin
+      RadK.instance.get_strokes(*args)
+    rescue
+      KanjiDic.instance.get_strokes(*args)
+    end
+  end
   def get_kanji_strokes(*args)
     KanjiDic.instance.get_strokes(*args)
   end
-  def get_radicals(*args)
+  def get_radical(*args)
     RadK.instance.get_radicals(*args)
   end
   def get_reading(*args)

data/lib/klookup/database_flatfile_kanjidic.rb

@@ -69,6 +69,11 @@ class KLookup::Database::FlatFile::KanjiDic
       i =~ /^S\d+$/}.first.sub(/^S(\d+)$/, '\1').to_i
   end
 
+  # Returns an array of all kanji
+  def get_all_kanji
+    @records.keys
+  end
+
   #Returns a Struct of arrays of Japanese readings.
   #
   # KLookup::Database::FlatFile::KanjiDic.instance.get_reading('富')

data/lib/klookup/database_flatfile_radk.rb

@@ -106,10 +106,13 @@ class KLookup::Database::FlatFile::RadK
   # Returns a list of kanji corresponding to given radicals.
   def get_kanji(*radicals)
     kanji = nil
+    if radicals.nil? or radicals.length == 0 or radicals.all? {|r| r.nil?}
+      raise ArgumentError, "This method doesn't do that sort of thing."
+    end
     radicals.flatten.each { |rad|
-      raise ArgumentError unless @records[rad.to_s]
+      raise ArgumentError, 'Radical does not exist' unless @records[rad.to_s]
       current_kanji = @records[rad.to_s][:kanji]
-      if kanji==nil
+      if kanji.nil?
         kanji = current_kanji
       else
         kanji &= current_kanji

data/lib/klookup/database_quickfile.rb

@@ -0,0 +1,38 @@
+=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::QuickFile < KLookup::Database
+
+  require 'singleton'
+  include Singleton
+
+  def radical_stroke_count
+  end
+  def find_radical(opts)
+  end
+  def find_kanji(opts)
+  end
+  def get_stroke_count(character)
+  end
+  def get_radical(character)
+  end
+  def get_reading(character)
+  end
+  def get_meaning(character)
+  end
+  def is_kanji?(character)
+  end
+  def is_radical?(character)
+  end
+
+end

data/lib/klookup/database_unihan.rb

@@ -35,7 +35,7 @@ class KLookup::Database::Unihan < KLookup::Database
   private
 
   def initialize
-    @unihan = KLookup::Database::Unihan.open_resource('Unihan.txt')
+    @unihan = KLookup::Database.open_resource('Unihan.txt','unihan')
   end
 
   # Returns the numeric codepoint of the first codepoint in +str+.
@@ -51,33 +51,6 @@ class KLookup::Database::Unihan < KLookup::Database
 
   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

data/lib/klookup/lookup_kanji.rb

@@ -10,11 +10,76 @@
 
 =end
 
-# An abstract representation of 漢字 (kanji).
+# An abstract representation of 漢字 (kanji/Chinese characters).
 class KLookup::Lookup::Kanji
-  # A class variable because we have class methods which need this.
+  # A class variable because we have class methods which use this.
   @@data = KLookup::Lookup.default_handler
 
+  private
+  # Returns a string containing the UTF-8 encoded character represented by the
+  # receiver’s value.
+  #
+  # This should ideally be elsewhere - i.e. jcode or active_support
+  def self.int_to_utf8(val)
+    case val
+    when 0xD800..0xDFFF
+      raise RangeError, 'these values are surrogate pairs'
+    when 0x0000..0x007F
+      return "%c" % (val & 0b01111111) # 7
+    when 0x0080..0x07FF
+      byte = []
+      byte[0] = 0b11000000 + ((val >> 6) & 0b11111) # 5
+      byte[1] = 0b10000000 + (val & 0b111111) # 6
+      return "%c%c" % byte
+    when 0x0800..0xFFFF
+      byte = []
+      byte[0] = 0b11100000 + ((val >> 12) & 0b1111) # 4
+      byte[1] = 0b10000000 + ((val >> 6) & 0b111111) # 6
+      byte[2] = 0b10000000 + (val & 0b111111) # 6
+      return "%c%c%c" % byte
+    when 0x00010000..0x0010FFFF
+      byte = []
+      byte[0] = 0b11110000 + ((val >> 18) & 0b11111) # 5
+      byte[1] = 0b10000000 + ((val >> 12) & 0b111111) # 6
+      byte[2] = 0b10000000 + ((val >> 6) & 0b111111) # 6
+      byte[3] = 0b10000000 + (val & 0b111111) # 6
+      return "%c%c%c%c" % byte
+    else
+      raise RangeError, 'out of Unicode range'
+    end
+  end
+
+  # Returns a regular expression that matches strings in a kana-insensitive
+  # manner.
+  def self.norm_kana(str)
+    # Relevant codepoints:
+    #    ひらがな == カタカナ
+    # 3041 - 3096 == 30A1 - 30F6  -  ァ-ヶ
+    # 309D - 309E == 30FD - 30FE  -  ヽ-ヾ
+    hiragana = (0x3041..0x3096).to_a + (0x309D..0x309E).to_a
+    katakana = (0x30A1..0x30F6).to_a + (0x30FD..0x30FE).to_a
+    hkhash = {}
+    khhash = {}
+    i=0
+    hiragana.each {|c|
+      hkhash[c] = katakana[i]
+      khhash[katakana[i]] = c
+      i+=1
+    }
+    re=''
+    str.each_char {|c|
+      if hiragana.include?(c.chars.first)
+        re << "[#{c}#{int_to_utf8(hkhash[c.chars.first])}]"
+      elsif katakana.include?(c.chars.first)
+        re << "[#{c}#{int_to_utf8(khhash[c.chars.first])}]"
+      else
+        re << c
+      end
+    }
+    Regexp.new("^#{re}$")
+  end
+  public
+
   def initialize(kanji)
     unless @@data.instance.is_kanji?(kanji)
       raise ArgumentError
@@ -34,24 +99,60 @@ class KLookup::Lookup::Kanji
     @@data = h
   end
 
-  # Returns an array of Kanji that are made up of these +radicals+ which have
-  # +strokes+ strokes.
-  def self.lookup(strokes=nil, *radicals)
-    unless strokes.nil?
-      raise ArgumentError unless strokes.respond_to?(:to_i)
-      strokes=strokes.to_i
+  # Returns an array of Kanji made up of :radicals, with a particular :meaning,
+  # with a particular :reading, or with a particular number of :strokes.
+  # A block can also be used which yields to Kanji objects. With no arguments
+  # and no block, all characters in the database are returned (you have been
+  # warned!).
+  #
+  # Note that :meaning and :reading are slow.
+  def self.lookup(hash=nil)
+    # Check values of the hash
+    unless hash.respond_to?(:to_hash) or hash.nil?
+      raise ArgumentError, 'Requires a hash or a block.'
     end
+    hash = {} if hash.nil?
 
-    raise ArgumentError unless radicals.respond_to?(:to_a)
-    radicals = radicals.to_a.flatten
-    raise ArgumentError unless radicals.size > 0
-    radicals.collect! { |r|
-      raise ArgumentError unless r.respond_to?(:to_s)
-      r.to_s
-    }
-    return @@data.instance.get_kanji(strokes, radicals).collect {|k|
+    meaning = hash[:meaning]
+    meaning = [meaning] unless meaning.kind_of?(Array) or meaning.nil?
+
+    reading = hash[:reading]
+    reading = [reading] unless reading.kind_of?(Array) or reading.nil?
+
+    radical = hash[:radical]
+    unless radical.nil?
+      radical = [radical] unless radical.kind_of?(Array)
+      radical.map {|r| r.to_s }
+    end
+
+    stroke = hash[:stroke]
+    stroke = stroke.to_i unless stroke.nil?
+
+    kanji = @@data.instance.find_kanji(:stroke=>stroke, :radical=>radical).collect {|k|
       KLookup::Lookup::Kanji.new(k)
     }
+
+    # Don't filter
+    if reading.nil? and meaning.nil? and (not block_given?)
+      return kanji
+    end
+
+    truths = 0
+    # Filter according to hash and block
+    kanji = kanji.select {|k|
+      unless reading.nil?
+        next unless reading.any? {|r|
+          k.reading.reading.any?{|s| norm_kana(r) === s } or
+          k.reading.name_reading.any?{|s| norm_kana(r) === s } }
+      end
+      unless meaning.nil?
+        next unless meaning.any? {|m| k.meaning.include?(m) }
+      end
+      next if block_given? and not yield k
+      true
+    }
+
+    return kanji
   end
 
   # Returns true if kanji exists in database.
@@ -73,11 +174,12 @@ class KLookup::Lookup::Kanji
   end
 
   # Returns an array of radicals that make up a kanji.
-  def radicals
-    return @@data.instance.get_radicals(to_s).collect {|r|
+  def radical
+    return @@data.instance.get_radical(to_s).collect {|r|
       KLookup::Lookup::Radical.new(r)
     }
   end
+  alias :radicals :radical
 
   # Returns a textual representation of a radical.
   def to_s

data/lib/klookup/lookup_radical.rb

@@ -34,18 +34,18 @@ class KLookup::Lookup::Radical
 
   # Return an array of how many strokes radicals can be made up of.
   def self.strokes
-    @@data.instance.stroke_count_list
+    @@data.instance.radical_stroke_count
   end
 
   # Returns an array of radicals with +strokes+ strokes. Without an argument,
   # all radicals are returned.
   def self.list(strokes=nil)
     if strokes.nil?
-      @@data.instance.radicals_by_strokes.values.flatten
+      @@data.instance.find_radical
     else
       raise ArgumentError unless strokes.respond_to?(:to_i)
 
-      @@data.instance.radicals_by_strokes[strokes.to_i]
+      @@data.instance.find_radical(:stroke=>strokes.to_i)
     end
   end
 

data/test/database_test.rb

@@ -0,0 +1,127 @@
+require 'klookup'
+require 'test/unit'
+
+class Database_Test < Test::Unit::TestCase
+
+  def self.set_handler(cl)
+    @@dbc = cl
+    @@db = @@dbc.instance
+  end
+
+  # Asserts false with message +msg+ if +exception+ is not raised within
+  # the given block.
+  def must_except(exception=Exception, msg=nil)
+    raise LocalJumpError unless block_given?
+    begin
+      yield
+    rescue exception
+    else
+      assert false, msg
+    end
+  end
+
+
+  def test_open_resource
+    f = @@dbc.open_resource('newradkfile')
+    assert f.respond_to?(:each_line), 'valid path'
+
+    f = @@dbc.open_resource('newradkfile', 'klookup')
+    assert f.respond_to?(:each_line), 'valid path and valid gem'
+
+    flag=false
+    @@dbc.open_resource('newradkfile') {|f|
+      assert f.respond_to?(:each_line)
+      flag=true
+    }
+    assert flag, 'using a block'
+
+    must_except(Errno::ENOENT, 'invalid path') {
+      @@dbc.open_resource('all your base are belong to us')
+    }
+    must_except(Errno::ENOENT, 'invalid gem') {
+      @@dbc.open_resource('newradkfile', 'cookies are yummy')
+    }
+  end
+
+  def test_methods_exist
+    [:radical_stroke_count,
+     :find_radical,
+     :find_kanji, #TODO
+     :get_stroke_count, #TODO
+     :get_radical, #TODO
+     :get_reading, #TODO
+     :get_meaning, #TODO
+     :is_kanji?, #TODO
+     :is_radical? #TODO
+    ].each {|m|
+      assert @@db.respond_to?(m), "#{m.to_s} exists"
+    }
+    assert @@dbc.respond_to?(:open_resource)
+  end
+
+  def test_radical_stroke_count
+    assert @@db.radical_stroke_count.kind_of?(Enumerable), 'an Enumerable'
+    assert (@@db.radical_stroke_count.size > 0), 'more than zero'
+    assert @@db.radical_stroke_count.each {|s|
+      assert s.kind_of?(Integer), 'an Integer'
+    }
+  end
+
+  def test_find_radical
+    test = @@db.find_radical(:stroke=>11)
+    assert test.include?('鳥')
+    assert (not test.include?('馬'))
+    test = @@db.find_radical(:stroke=>10)
+    assert test.include?('馬')
+    assert (not test.include?('鳥'))
+    test = @@db.find_radical
+    assert test.include?('鳥')
+    assert test.include?('馬')
+    newtest = @@db.find_radical(:stroke=>nil)
+    assert test==newtest, 'Sets are identical'
+    test = @@db.find_radical(:stroke=>0)
+    assert test.size == 0, 'Size is zero'
+
+    must_except(ArgumentError, 'not a hash (String)') {
+      @@db.find_radical('cats')
+    }
+    must_except(ArgumentError, 'not a hash (Integer)') {
+      @@db.find_radical(6)
+    }
+    must_except(ArgumentError, 'invalid :stroke') {
+      @@db.find_radical(:stroke=>'nobbly knees')
+    }
+    test = @@db.find_radical(:stroke=>10,:cats=>:dogs)
+    assert test.include?('馬')
+    assert (not test.include?('鳥'))
+  end
+
+  def test_find_kanji
+  end
+
+end
+
+
+
+require 'test/unit/ui/console/testrunner'
+results=[]
+db=KLookup::Database
+puts
+puts "= Database_Test"
+# Just use FlatFile for the moment
+#[:FlatFile].each {|h|
+db.constants.each {|h|
+  handler = "#{db.to_s}::#{h}"
+  next unless eval(handler).superclass == db
+  puts
+  puts "== Handler: #{handler}"
+  Database_Test.set_handler(eval(handler)) # Database class
+  results << [handler, Test::Unit::UI::Console::TestRunner.run(Database_Test)]
+  puts
+}
+
+results.each {|p|
+  h,r=p
+  puts "#{r.passed? ? 'PASS' : 'FAIL'} : #{h}"
+  puts ("       %s" % r.to_s) unless r.passed?
+}

data/test/suite.rb

@@ -15,11 +15,13 @@ begin
 rescue LoadError
 end
 
+require 'database_test.rb'
+
 require 'klookup'
 require 'test/unit'
 
-# KLookup::Lookup tests
-class KLookup_Test < Test::Unit::TestCase
+# Lookup::Lookup tests
+class Lookup_Test < Test::Unit::TestCase
 
   # Check classes
   def test_radical_type
@@ -46,24 +48,22 @@ class KLookup_Test < Test::Unit::TestCase
   # Lookups should work
   def test_kanji_lookup
     # Cat
-    assert KLookup::Lookup::Kanji.lookup(nil, KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')).include?(KLookup::Lookup::Kanji.new('猫')), 'Without stroke count. Grass, left-dog, field => cat'
-    assert KLookup::Lookup::Kanji.lookup(11, KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')).include?(KLookup::Lookup::Kanji.new('猫')), 'With stroke count. Grass, left-dog, field => cat'
-    assert KLookup::Lookup::Kanji.lookup(nil, [KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')]).include?(KLookup::Lookup::Kanji.new('猫')), 'Without stroke count. Arrayed grass, left-dog, field => cat'
-    assert KLookup::Lookup::Kanji.lookup(11, [KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')]).include?(KLookup::Lookup::Kanji.new('猫')), 'With stroke count. Arrayed grass, left-dog, field => cat'
+    assert KLookup::Lookup::Kanji.lookup(:radical=>[KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')]).include?(KLookup::Lookup::Kanji.new('猫')), 'Without stroke count. Arrayed grass, left-dog, field => cat'
+    assert KLookup::Lookup::Kanji.lookup(:stroke=>11, :radical=>[KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')]).include?(KLookup::Lookup::Kanji.new('猫')), 'With stroke count. Arrayed grass, left-dog, field => cat'
 
     # Chestnut
-    assert KLookup::Lookup::Kanji.lookup(nil, KLookup::Lookup::Radical.new('西'), KLookup::Lookup::Radical.new('木')).include?(KLookup::Lookup::Kanji.new('栗')), 'Without stroke count. West, tree => chestnut.'
-    assert KLookup::Lookup::Kanji.lookup(10, KLookup::Lookup::Radical.new('西'), KLookup::Lookup::Radical.new('木')).include?(KLookup::Lookup::Kanji.new('栗')), 'With stroke count. West, tree => chestnut.'
+    assert KLookup::Lookup::Kanji.lookup(:stroke=>nil, :radical=>[KLookup::Lookup::Radical.new('西'), KLookup::Lookup::Radical.new('木')]).include?(KLookup::Lookup::Kanji.new('栗')), 'Without stroke count. West, tree => chestnut.'
+    assert KLookup::Lookup::Kanji.lookup(:stroke=>10, :radical=>[KLookup::Lookup::Radical.new('西'), KLookup::Lookup::Radical.new('木')]).include?(KLookup::Lookup::Kanji.new('栗')), 'With stroke count. West, tree => chestnut.'
 
     # Test that radicals are using to_s
-    assert KLookup::Lookup::Kanji.lookup(10, '西'.to_sym, KLookup::Lookup::Radical.new('木'.to_sym)).include?(KLookup::Lookup::Kanji.new('栗'.to_sym)), 'With stroke count (and symbols). West, tree => chestnut.'
+    assert KLookup::Lookup::Kanji.lookup(:radical=>10, :radical=>['西'.to_sym, KLookup::Lookup::Radical.new('木'.to_sym)]).include?(KLookup::Lookup::Kanji.new('栗'.to_sym)), 'With stroke count (and symbols). West, tree => chestnut.'
   end
 
   # Checks stroke count works
   def test_kanji_lookup_stroke
     # Unmatching stroke counts should result in empty lists
-    assert KLookup::Lookup::Kanji.lookup(10, [KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')])==[], '10 strokes for grass, left-dog, and field is impossible.'
-    assert KLookup::Lookup::Kanji.lookup(12, [KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')])==[], '12 strokes for grass, left-dog, and field results in no characters.'
+    assert KLookup::Lookup::Kanji.lookup(:stroke=>10, :radical=>[KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')])==[], '10 strokes for grass, left-dog, and field is impossible.'
+    assert KLookup::Lookup::Kanji.lookup(:stroke=>12, :radical=>[KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')])==[], '12 strokes for grass, left-dog, and field results in no characters.'
   end
 
   def test_kanji_radicals
@@ -125,19 +125,89 @@ class KLookup_Test < Test::Unit::TestCase
     assert KLookup::Lookup::Radical.exist?('田')
     assert (not KLookup::Lookup::Radical.exist?('た'))
   end
+
+  def test_just_meaning_lookup
+    cat_m = KLookup::Lookup::Kanji.lookup(:meaning=>'cat')
+    cat = KLookup::Lookup::Kanji.new('猫')
+    dog = KLookup::Lookup::Kanji.new('犬')
+    assert (cat_m.include?(cat) and not cat_m.include?(dog)), ':meaning'
+  end
+
+  def test_meaning_lookup
+    cat_m = KLookup::Lookup::Kanji.lookup(:meaning=>'cat')
+    cat_ms = KLookup::Lookup::Kanji.lookup(:meaning=>'cat', :stroke=>11)
+    cat_mss = KLookup::Lookup::Kanji.lookup(:meaning=>'cat', :stroke=>12)
+    cat = KLookup::Lookup::Kanji.new('猫')
+    dog = KLookup::Lookup::Kanji.new('犬')
+    assert (cat_m.include?(cat) and not cat_m.include?(dog)), ':meaning'
+    assert (cat_ms.include?(cat) and not cat_ms.include?(dog)), ':meaning and valid :stroke'
+    assert (not cat_mss.include?(cat) and not cat_mss.include?(dog)), ':meaning and invalid :stroke'
+  end
+
+  def test_reading_lookup
+    cat_r = KLookup::Lookup::Kanji.lookup(:reading=>'ねこ')
+    cat_rs = KLookup::Lookup::Kanji.lookup(:reading=>'ねこ', :stroke=>11)
+    cat_rss = KLookup::Lookup::Kanji.lookup(:reading=>'ねこ', :stroke=>12)
+    cat = KLookup::Lookup::Kanji.new('猫')
+    dog = KLookup::Lookup::Kanji.new('犬')
+    assert (cat_r.include?(cat) and not cat_r.include?(dog)), ':reading'
+    assert (cat_rs.include?(cat) and not cat_rs.include?(dog)), ':reading and valid :stroke'
+    assert (not cat_rss.include?(cat) and not cat_rss.include?(dog)), ':reading and invalid :stroke'
+  end
+
+  def test_just_reading_lookup
+    cat = KLookup::Lookup::Kanji.new('猫')
+    dog = KLookup::Lookup::Kanji.new('犬')
+    cat_r = KLookup::Lookup::Kanji.lookup(:reading=>'ねこ')
+    assert (cat_r.include?(cat) and not cat_r.include?(dog)), ':reading in same kana'
+    cat_r = KLookup::Lookup::Kanji.lookup(:reading=>'ネコ')
+    assert (cat_r.include?(cat) and not cat_r.include?(dog)), ':reading in different kana'
+  end
+
+  def test_all_lookup
+    #TODO: this may not be a good test
+    assert KLookup::Lookup::Kanji.lookup.length > 1000
+  end
+
+  def test_just_block_lookup
+    cat = KLookup::Lookup::Kanji.new('猫')
+    dog = KLookup::Lookup::Kanji.new('犬')
+
+    look = KLookup::Lookup::Kanji.lookup {|k| k.meaning.include?('cat')}
+    assert (look.include?(cat) and not look.include?(dog)), 'meaning in block'
+  end
+
+  def test_block_lookup
+    cat = KLookup::Lookup::Kanji.new('猫')
+    dog = KLookup::Lookup::Kanji.new('犬')
+
+    look = KLookup::Lookup::Kanji.lookup(:reading=>'ねこ') {|k|
+      k.meaning.include?('cat')}
+    assert (look.include?(cat) and not look.include?(dog)),
+    'meaning in block and reading'
+
+    look = KLookup::Lookup::Kanji.lookup(:reading=>'ねこ') {|k|
+      true}
+    assert (look.include?(cat) and not look.include?(dog)),
+    'true in block and reading'
+  end
 end
 
 
 require 'test/unit/ui/console/testrunner'
 results=[]
 db=KLookup::Database
+puts
+puts "= Lookup_Test"
+# Just use FlatFile for the moment
+#[:FlatFile].each {|h|
 db.constants.each {|h|
   handler = "#{db.to_s}::#{h}"
   next unless eval(handler).superclass == db
   puts
   puts "== KLookup::Lookup.handler = #{handler}"
   KLookup::Lookup.handler = eval(handler)
-  results << [handler, Test::Unit::UI::Console::TestRunner.run(KLookup_Test)]
+  results << [handler, Test::Unit::UI::Console::TestRunner.run(Lookup_Test)]
   puts
 }
 

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.1
+rubygems_version: 0.9.2
 specification_version: 1
 name: klookup
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
-date: 2007-01-29 00:00:00 +00:00
+  version: 0.2.4
+date: 2007-02-18 00:00:00 +00:00
 summary: A set of kanji lookup tools and a library.
 require_paths: 
 - lib
@@ -36,6 +36,7 @@ files:
 - lib/klookup/lookup.rb
 - lib/klookup/lookup_radical.rb
 - lib/klookup/database.rb
+- lib/klookup/database_quickfile.rb
 - lib/klookup/database_flatfile_radk.rb
 - lib/klookup/database_unihan.rb
 - lib/klookup/database_flatfile_kanjidic.rb
@@ -43,6 +44,7 @@ files:
 - lib/klookup/lookup_kanji.rb
 test_files: 
 - test/suite.rb
+- test/database_test.rb
 rdoc_options: 
 - - --main
   - KLookup
@@ -67,12 +69,3 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.4.0
     version: 
-- !ruby/object:Gem::Dependency 
-  name: unihan
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 5.0.0.1.1
-    version: