klookup 0.2.4 → 0.3

data/bin/klookup.cgi

@@ -24,14 +24,16 @@ end
 include KLookup::Lookup
 
 require 'cgi'
+
+# GetText is being problematic when it is found.
 # If the platform doesn't have gettext we can survive
-begin
-  require 'gettext'
-  include GetText
-  bindtextdomain 'klookup'
-rescue LoadError
-  def _(arg); arg; end
-end
+#begin
+#  require 'gettext'
+#  include GetText
+#  bindtextdomain 'klookup'
+#rescue LoadError
+def _(arg); arg; end
+#end
 
 class String
   #Deletes the characters (NOT bytes) listed in str from the string

data/lib/klookup.rb

@@ -11,19 +11,13 @@
 =end
 
 begin
-  require 'active_support'
+  require 'rubygems'
 rescue LoadError
-#   begin
-#     require 'rubygems'
-#     require 'active_support'
-#   rescue LoadError
-  require 'runicode'
-#   end
 end
 
-#This allows regular expressions to work on characters.
 $KCODE='u'
 require 'jcode'
+require 'runicode'
 
 # Contains Lookup and Database.
 module KLookup

data/lib/klookup/database.rb

@@ -23,10 +23,7 @@ class KLookup::Database
 
   public
 
-  # Opens a resource.
-  #
-  # Priority: LOOKUP_PATH environment variable, Gem load path.
-  def self.open_resource(path, mod='klookup')
+  def self.resource_path(path, mod='klookup')
     # Choose a directory
     env=ENV['KLOOKUP_PATH']
     if env and env != ''
@@ -36,12 +33,26 @@ class KLookup::Database
         gem mod
         dir=Gem.datadir(mod)
       rescue NameError
-        raise IOError, 'Could not find resource %s' % path
+        # This is a fallback for older versions of RubyGems (0.8)
+        begin
+	  require_gem mod
+          dir=Gem.datadir(mod)
+        rescue NameError
+          raise IOError, 'Could not find resource %s' % path
+        end
       end
     end
+    raise Errno::ENOENT if Dir["#{dir}/#{path}"].empty?
+    "#{dir}/#{path}"
+  end
 
+  # Opens a resource.
+  #
+  # Priority: LOOKUP_PATH environment variable, Gem load path.
+  def self.open_resource(path, mod='klookup')
     # Open a file
-    file = open("#{dir}/#{path}")
+    path = resource_path(path, mod)
+    file = open(path)
     if block_given?
       yield file
     else
@@ -60,6 +71,6 @@ class KLookup::Database
   alias :is_radical? :undefined
 
   require 'klookup/database_flatfile'
-#  require 'klookup/database_quickfile'
+  require 'klookup/database_sqlite'
 #  require 'klookup/database_unihan'
 end

data/lib/klookup/database_flatfile.rb

@@ -50,35 +50,44 @@ class KLookup::Database::FlatFile < KLookup::Database
       kanji = RadK.instance.get_kanji(*args)
     end
     unless strokes.nil?
-        return kanji.select {|k| get_kanji_strokes(k) == strokes }
+        return kanji.select {|k| get_stroke_count(k) == strokes }
     end
     return kanji
   end
   public
-  def find_kanji(args)
+  def find_kanji(args={})
+    if not args.kind_of?(Hash)
+      raise ArgumentError, 'only takes a hash'
+    elsif (not args[:stroke].nil?) and (not args[:stroke].kind_of?(Integer))
+      raise ArgumentError, ':stroke must be an Integer'
+    end
     get_kanji(args[:stroke], args[:radical])
   end
-  def get_radical_strokes(*args)
-    RadK.instance.get_strokes(*args)
-  end
-  def get_stroke_count
+  def get_stroke_count(*args)
     begin
       RadK.instance.get_strokes(*args)
-    rescue
-      KanjiDic.instance.get_strokes(*args)
+    rescue NoMethodError
+      begin
+        KanjiDic.instance.get_strokes(*args)
+      rescue NoMethodError
+        raise ArgumentError, 'character not found'
+      end
     end
   end
-  def get_kanji_strokes(*args)
-    KanjiDic.instance.get_strokes(*args)
-  end
-  def get_radical(*args)
-    RadK.instance.get_radicals(*args)
+  def get_radical(kanji)
+    raise ArgumentError if kanji.chars.size > 1
+    raise ArgumentError unless is_kanji?(kanji)
+    RadK.instance.get_radicals(kanji)
   end
-  def get_reading(*args)
-    KanjiDic.instance.get_reading(*args)
+  def get_reading(kanji)
+    raise ArgumentError if kanji.chars.size > 1
+    raise ArgumentError unless is_kanji?(kanji)
+    KanjiDic.instance.get_reading(kanji)
   end
-  def get_meaning(*args)
-    KanjiDic.instance.get_meaning(*args)
+  def get_meaning(kanji)
+    raise ArgumentError if kanji.chars.size > 1
+    raise ArgumentError unless is_kanji?(kanji)
+    KanjiDic.instance.get_meaning(kanji)
   end
   def is_kanji?(*args)
     KanjiDic.instance.is_kanji?(*args)

data/lib/klookup/database_sqlite.rb

@@ -0,0 +1,110 @@
+=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::SQLite < KLookup::Database
+
+  require 'singleton'
+  include Singleton
+
+  def initialize
+    require 'sqlite'
+    path = KLookup::Database.resource_path('data.db')
+    @db = ::SQLite::Database.new(path)
+  end
+
+  # Umm...
+  def finalize
+    @db.close
+  end
+
+  def radical_stroke_count
+    @db.execute("select distinct stroke_count from radical order by stroke_count").flatten.collect {|s| s.to_i}
+  end
+
+  def find_radical(args={})
+    raise ArgumentError unless args.kind_of?(Hash)
+    stroke_count = args[:stroke]
+    raise ArgumentError unless stroke_count.kind_of?(Integer) or stroke_count.nil?
+    if stroke_count
+      @db.execute("select radical from radical where stroke_count=?", stroke_count).flatten
+    else
+      @db.execute("select radical from radical").flatten
+    end
+  end
+
+  def find_kanji(args={})
+    raise ArgumentError, 'args must be Hash or nil' unless args.kind_of?(Hash) or args.nil?
+    stroke_count = args[:stroke]
+    raise ArgumentError, ':stroke must be Integer or nil' unless stroke_count.kind_of?(Integer) or stroke_count.nil?
+    radical = args[:radical]
+    radical = [radical] if radical.kind_of?(String)
+    raise ArgumentError, ':radical must be Array, String, or nil' unless radical.kind_of?(Array) or radical.nil?
+
+    kanji = []
+    if stroke_count
+      kanji = @db.execute("select kanji from kanji where stroke_count=?",
+                          stroke_count).flatten
+    else
+      kanji = @db.execute("select kanji from kanji").flatten
+    end
+
+    if radical
+      radical.each {|r|
+        raise ArgumentError, ':radical must contain radicals' unless is_radical?(r)
+        new_r = @db.execute("select kanji from mapping where radical=?",
+                            r).flatten
+        kanji &= new_r
+      }
+    end
+    kanji
+  end
+
+  def get_stroke_count(character)
+    if is_kanji?(character)
+      @db.get_first_row("select stroke_count from kanji where kanji=?", character).first.to_i
+    elsif is_radical?(character)
+      @db.get_first_row("select stroke_count from radical where radical=?", character).first.to_i
+    else
+      raise ArgumentError
+    end
+  end
+
+  def get_radical(character)
+    raise ArgumentError unless is_kanji?(character)
+    @db.execute("select radical from mapping where kanji=?", character).
+      collect {|r| r.first }
+  end
+
+  def get_reading(character)
+    raise ArgumentError unless is_kanji?(character)
+    reading = @db.execute("select reading from reading where kanji=? and is_name_reading='false'", character).flatten
+    name_reading = @db.execute("select reading from reading where kanji=? and is_name_reading='true'", character).flatten
+    Struct.new(:reading, :name_reading).new(reading, name_reading)
+  end
+
+  def get_meaning(character)
+    raise ArgumentError unless is_kanji?(character)
+    @db.execute("select meaning from meaning where kanji=?", character).flatten
+  end
+
+  def is_kanji?(character)
+    @db.get_first_row("select count(*) from kanji where kanji=?",
+                character).first.to_i >= 1
+  end
+
+  def is_radical?(character)
+    @db.get_first_row("select count(*) from radical where radical=?",
+                character).first.to_i >= 1
+  end
+
+end

data/lib/klookup/lookup.rb

@@ -15,7 +15,12 @@ module KLookup::Lookup
 
   # Returns the default handler for database lookups.
   def self.default_handler
-    KLookup::Database::FlatFile
+    begin
+      KLookup::Database::SQLite.instance
+      KLookup::Database::SQLite
+    rescue LoadError
+      KLookup::Database::FlatFile
+    end
   end
 
   # Set the handler used by both Kanji and Radical.

data/lib/klookup/lookup_kanji.rb

@@ -19,34 +19,9 @@ class KLookup::Lookup::Kanji
   # 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
+  # Uses RUnicode's Integer#chr method
+  def self.cp_to_str(val)
+    return val.chr
   end
 
   # Returns a regular expression that matches strings in a kana-insensitive
@@ -69,9 +44,9 @@ class KLookup::Lookup::Kanji
     re=''
     str.each_char {|c|
       if hiragana.include?(c.chars.first)
-        re << "[#{c}#{int_to_utf8(hkhash[c.chars.first])}]"
+        re << "[#{c}#{cp_to_str(hkhash[c.chars.first])}]"
       elsif katakana.include?(c.chars.first)
-        re << "[#{c}#{int_to_utf8(khhash[c.chars.first])}]"
+        re << "[#{c}#{cp_to_str(khhash[c.chars.first])}]"
       else
         re << c
       end
@@ -206,4 +181,8 @@ class KLookup::Lookup::Kanji
     end
     @meaning
   end
+
+  def stroke_count
+    @@data.instance.get_stroke_count(@kanji)
+  end
 end

data/lib/klookup/lookup_radical.rb

@@ -22,6 +22,10 @@ class KLookup::Lookup::Radical
     @radical = radical.to_s
   end
 
+  def stroke_count
+    @@data.instance.get_stroke_count(@radical)
+  end
+
   # Get handler used by this class.
   def self.handler
     @@data

data/lib/runicode.rb

@@ -0,0 +1,39 @@
+=begin
+
+  lib/runicode.rb
+
+  Copyright © Tom Adams 2006
+
+  This programme is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby License.
+
+=end
+
+$KCODE='u'
+require 'jcode'
+
+module RUnicode # :nodoc:
+end
+
+# Ruby-based UTF-8 processing
+require 'runicode/utf8'
+
+class String # :nodoc:
+
+  #Yields to each codepoint of a string.
+  def each_char
+    raise LocalJumpError unless block_given?
+    each_codepoint {|cp| yield cp.chr}
+  end
+
+  #Collects the codepoints as an array.
+  def codepoints
+    codepoints = []
+    each_codepoint {|c| codepoints << c}
+    return codepoints
+  end
+
+  alias :chars :codepoints
+
+end

data/lib/runicode/utf8.rb

@@ -0,0 +1,132 @@
+=begin
+
+  lib/runicode/utf8.rb
+
+  Copyright © Tom Adams 2006
+
+  This programme is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby License.
+
+=end
+
+module RUnicode::UTF8 # :nodoc:
+  class ThisShouldNotHappen < Exception # :nodoc:
+  end
+
+  INVALID_BYTES = ((0xC0..0xC1).to_a + (0xF5..0xFE).to_a +
+                   [0b11000000, 0b11100000, 0b11110000])
+
+  # Converts one set of bytes making up a character into an integer codepoint
+  def self.bytes_to_char(bytes)
+    case bytes.size
+    when 1 # 0xxxxxxx
+      return bytes.first & 0b01111111
+    when 2 # 110xxxxx 10xxxxxx
+      return ((bytes.first & 0b00011111) << 6) + rest(bytes[1..-1])
+    when 3 # 1110xxxx 10xxxxxx 10xxxxxx
+      return ((bytes.first & 0b00001111) << 12) + rest(bytes[1..-1])
+    when 4 # 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+      return ((bytes.first & 0b00000111) << 18) + rest(bytes[1..-1])
+    else raise ThisShouldNotHappen
+    end
+  end
+  
+  # Gives the total value from 10xxxxxx in each byte
+  def self.rest(bytes)
+    val = 0b0
+    bytes.each {|b|
+      val = (val << 6)
+      val += (b & 0b00111111)
+    }
+    val
+  end
+
+end
+
+class String # :nodoc:
+  #Passes each character in str to the given block as an Integer. A rewrite of
+  #codepoints.
+  def each_codepoint
+    raise LocalJumpError, 'no block given' unless block_given?
+
+    steal_next = 0
+    current_bytes = nil
+
+    to_s.each_byte {|b|
+      if steal_next==0 # No octets need to be stolen
+        unless current_bytes==nil
+          current_bytes.each {|byte|
+            if RUnicode::UTF8::INVALID_BYTES.include? byte
+              raise IOError, 'ill-formed UTF-8'
+            end
+          }
+          yield RUnicode::UTF8::bytes_to_char(current_bytes)
+        end
+        current_bytes = [b]
+        if b >> 7 == 0b0
+          steal_next = 0
+        elsif b >> 5 == 0b110
+          steal_next = 1
+        elsif b >> 4 == 0b1110
+          steal_next = 2
+        elsif b >> 3 == 0b11110
+          steal_next = 3
+        else
+          raise IOError, 'ill-formed UTF-8'
+        end
+
+      else # We have some octets to steal
+        raise IOError, 'ill-formed UTF-8' unless b >> 6 == 0b10
+        current_bytes << b
+        steal_next -= 1
+      end
+    }
+
+    # One last time:
+    unless current_bytes==nil
+      current_bytes.each {|byte|
+          if RUnicode::UTF8::INVALID_BYTES.include? byte
+            raise IOError, 'ill-formed UTF-8'
+          end
+        }
+      yield RUnicode::UTF8::bytes_to_char(current_bytes)
+    end
+
+    raise IOError, 'ill-formed UTF-8' if steal_next != 0
+
+  end # each_codepoint
+end
+
+class Integer # :nodoc:
+  #Returns a string containing the UTF-8 encoded character represented by the
+  #receiver’s value.
+  def chr
+    case to_i
+    when 0xD800..0xDFFF
+      raise RangeError, 'these values are surrogate pairs'
+    when 0x0000..0x007F
+      return "%c" % (to_i & 0b01111111) # 7
+    when 0x0080..0x07FF
+      byte = []
+      byte[0] = 0b11000000 + ((to_i >> 6) & 0b11111) # 5
+      byte[1] = 0b10000000 + (to_i & 0b111111) # 6
+      return "%c%c" % byte
+    when 0x0800..0xFFFF
+      byte = []
+      byte[0] = 0b11100000 + ((to_i >> 12) & 0b1111) # 4
+      byte[1] = 0b10000000 + ((to_i >> 6) & 0b111111) # 6
+      byte[2] = 0b10000000 + (to_i & 0b111111) # 6
+      return "%c%c%c" % byte
+    when 0x00010000..0x0010FFFF
+      byte = []
+      byte[0] = 0b11110000 + ((to_i >> 18) & 0b11111) # 5
+      byte[1] = 0b10000000 + ((to_i >> 12) & 0b111111) # 6
+      byte[2] = 0b10000000 + ((to_i >> 6) & 0b111111) # 6
+      byte[3] = 0b10000000 + (to_i & 0b111111) # 6
+      return "%c%c%c%c" % byte
+    else
+      raise RangeError, 'out of Unicode range'
+    end
+  end
+end

data/test/database_test.rb

@@ -8,62 +8,58 @@ class Database_Test < Test::Unit::TestCase
     @@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 = KLookup::Database.open_resource('newradkfile')
+    assert_respond_to f, :each_line, 'valid path'
 
-    f = @@dbc.open_resource('newradkfile', 'klookup')
-    assert f.respond_to?(:each_line), 'valid path and valid gem'
+    f = KLookup::Database.open_resource('newradkfile', 'klookup')
+    assert_respond_to f, :each_line, 'valid path and valid gem'
 
     flag=false
-    @@dbc.open_resource('newradkfile') {|f|
-      assert f.respond_to?(:each_line)
+    KLookup::Database.open_resource('newradkfile') {|f|
+      assert_respond_to f, :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')
+    assert_raise(Errno::ENOENT, 'invalid path') {
+      KLookup::Database.open_resource('all your base are belong to us')
     }
-    must_except(Errno::ENOENT, 'invalid gem') {
-      @@dbc.open_resource('newradkfile', 'cookies are yummy')
+    assert_raise(Errno::ENOENT, 'invalid path') {
+      KLookup::Database.open_resource('all your base are belong to us')
+    }
+    assert_raise(Errno::ENOENT, 'invalid gem') {
+      KLookup::Database.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
+     :find_kanji,
+     :get_stroke_count,
+     :get_radical,
+     :get_reading,
+     :get_meaning,
+     :is_kanji?,
+     :is_radical?
     ].each {|m|
-      assert @@db.respond_to?(m), "#{m.to_s} exists"
+      assert_respond_to @@db, m
     }
-    assert @@dbc.respond_to?(:open_resource)
+#    assert_respond_to @@dbc, :open_resource
   end
 
   def test_radical_stroke_count
-    assert @@db.radical_stroke_count.kind_of?(Enumerable), 'an Enumerable'
+    assert_kind_of Enumerable, @@db.radical_stroke_count
     assert (@@db.radical_stroke_count.size > 0), 'more than zero'
-    assert @@db.radical_stroke_count.each {|s|
-      assert s.kind_of?(Integer), 'an Integer'
+    (1..15).each {|n|
+      assert @@db.radical_stroke_count.include?(n)
+    }
+    @@db.radical_stroke_count.each {|s|
+      assert_kind_of Integer, s
+    }
+    assert_raise(ArgumentError) {
+      @@db.radical_stroke_count(7)
     }
   end
 
@@ -71,57 +67,287 @@ class Database_Test < Test::Unit::TestCase
     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'
+    assert_equal test, newtest, 'Sets are identical'
     test = @@db.find_radical(:stroke=>0)
-    assert test.size == 0, 'Size is zero'
+    assert_equal test.size, 0, 'Size is zero'
 
-    must_except(ArgumentError, 'not a hash (String)') {
+    assert_raise(ArgumentError, 'not a hash (String)') {
       @@db.find_radical('cats')
     }
-    must_except(ArgumentError, 'not a hash (Integer)') {
+    assert_raise(ArgumentError, 'not a hash (Integer)') {
       @@db.find_radical(6)
     }
-    must_except(ArgumentError, 'invalid :stroke') {
+    assert_raise(ArgumentError, 'invalid :stroke') {
       @@db.find_radical(:stroke=>'nobbly knees')
     }
+    assert_raise(ArgumentError) {
+      @@db.find_radical('動', '詞')
+    }
+    assert_raise(ArgumentError) {
+      @@db.find_radical('動')
+    }
+
     test = @@db.find_radical(:stroke=>10,:cats=>:dogs)
     assert test.include?('馬')
     assert (not test.include?('鳥'))
   end
 
   def test_find_kanji
+    # Simple cases
+    test = @@db.find_kanji(:stroke=>11)
+    assert test.include?('猫'), '11 includes 猫'
+    assert (not test.include?('犬')), '11 excludes 犬'
+
+    test = @@db.find_kanji(:stroke=>4)
+    assert test.include?('犬'), '10 includes 犬'
+    assert (not test.include?('猫')), '10 excludes 猫'
+
+    test = @@db.find_kanji(:radical=>['犭'])
+    assert test.include?('猫'), '犭 includes 猫'
+    assert (not test.include?('鳥')), '犭 excludes 鳥'
+
+    test = @@db.find_kanji(:radical=>['犭'],:stroke=>11)
+    assert test.include?('猫'), '犭 (11 strokes) includes 猫'
+    assert (not test.include?('鳥')), '犭 (11 strokes) excludes 鳥'
+
+    test = @@db.find_kanji(:radical=>['犭', '艹', '田'],:stroke=>11)
+    assert test.include?('猫'), '犭艹田 (11 strokes) includes 猫'
+    assert (not test.include?('鳥')), '犭艹田 (11 strokes) excludes 鳥'
+
+    test = @@db.find_kanji(:radical=>['犭', '艹', '田'])
+    assert test.include?('猫'), '犭艹田 (no strokes) includes 猫'
+    assert (not test.include?('鳥')), '犭艹田 (no strokes) excludes 鳥'
+
+    # Uncommon cases
+    test = @@db.find_kanji
+    assert test.include?('猫'), 'all includes 猫'
+    assert test.include?('犬'), 'all includes 犬'
+
+    test = @@db.find_kanji(:radical=>'犭')
+    assert test.include?('猫'), '犭 (not list) includes 猫'
+    assert (not test.include?('鳥')), '犭 (not list) excludes 鳥'
+
+    test = @@db.find_kanji(:radical=>'犭',:stroke=>11)
+    assert test.include?('猫'), '犭 (not list, 11 strokes) includes 猫'
+    assert (not test.include?('鳥')), '犭 (not list, 11 strokes) excludes 鳥'
+
+    test = @@db.find_kanji(:radical=>['犭', '艹', '田'], :stroke=>10)
+    assert_kind_of Enumerable, test, '犭艹田 (10 strokes!) is Enumerable'
+    assert_equal test.size, 0, '犭艹田 (10 strokes!) returns zero results'
+
+    # Extraneous input
+    test = @@db.find_kanji(:stroke=>4,:strokes=>'cat')
+    assert test.include?('犬'), '10 with extraneous input includes 犬'
+    assert (not test.include?('猫')), '10 with extraneous input excludes 猫'
+
+    # Problem cases
+    assert_raise(ArgumentError, ':stroke=>"cat"') {
+      @@db.find_kanji(:stroke=>'cat')
+    }
+    assert_raise(ArgumentError, ':radical=>"cat"') {
+      @@db.find_kanji(:radical=>'cat')
+    }
+    assert_raise(ArgumentError, ':radical=>["cat"]') {
+      @@db.find_kanji(:radical=>['cat'])
+    }
+    assert_raise(ArgumentError, ':radical=>["田犬"]') {
+      @@db.find_kanji(:radical=>['田犬'])
+    }
+    assert_raise(ArgumentError) {
+      @@db.find_kanji('犬', '田')
+    }
+    assert_raise(ArgumentError) {
+      @@db.find_kanji('犬')
+    }
   end
 
-end
+  def test_get_stroke_count
+    # Simple cases
+
+    assert_equal @@db.get_stroke_count('猫'), 11, '猫=11'
+    assert_equal @@db.get_stroke_count('鳥'), 11, '鳥=11'
+    assert_equal @@db.get_stroke_count('犬'), 4, '犬=4'
+    assert_equal @@db.get_stroke_count('田'), 5, '田=5'
+    assert_equal @@db.get_stroke_count('犭'), 3, '犭=3'
 
+    # Problem cases
+    assert_raise(ArgumentError, 'no arguments') {
+      @@db.get_stroke_count()
+    }
+    assert_raise(ArgumentError, ':radical=>"犬"') {
+      @@db.get_stroke_count(:radical=>'犬')
+    }
+    assert_raise(ArgumentError, 'two characters') {
+      @@db.get_stroke_count('犬猫')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_stroke_count
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_stroke_count('動', '詞')
+    }
+  end
 
+  def test_get_radical
+    #TODO: May not play well with other data sources
+    cat = @@db.get_radical('猫')
+    assert_equal cat.size, 3
+    ['犭', '艹', '田'].each {|r|
+      assert cat.include?(r), "contains #{r}"
+    }
 
-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)]
+    assert_raise(ArgumentError) {
+      @@db.get_radical('犭')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_radical('h')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_radical('猫犬')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_radical
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_radical('動', '詞')
+    }
+  end
+
+  def test_get_reading
+    #TODO: May not play well with other data sources
+    cat = @@db.get_reading('猫').reading
+    assert cat.size>=2
+    ['ねこ', 'ビョウ'].each {|r|
+      assert cat.include?(r), "contains #{r}"
+    }
+
+    rich = @@db.get_reading('富')
+    assert rich.reading.size>=2
+    ['とみ', 'フウ'].each {|r|
+      assert rich.reading.include?(r), "contains #{r}"
+    }
+    assert rich.name_reading.size>=2
+    ['とん', 'ふっ'].each {|r|
+      assert rich.name_reading.include?(r), "contains #{r}"
+    }
+
+    assert_raise(ArgumentError) {
+      @@db.get_reading('犭')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_reading('h')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_reading('猫犬')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_reading
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_reading('動', '詞')
+    }
+  end
+
+  def test_get_meaning
+    #TODO: May not play well with other data sources
+    pull = @@db.get_meaning('引')
+    assert pull.size>=3
+    ['pull', 'tug', 'refer to'].each {|r|
+      assert pull.include?(r), "contains #{r}"
+    }
+
+    comp = @@db.get_meaning('以')
+    assert comp.size>=3
+    ['by means of', 'because', 'in view of'].each {|r|
+      assert comp.include?(r), "contains #{r}"
+    }
+
+    assert_raise(ArgumentError) {
+      @@db.get_meaning('犭')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_meaning('h')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_meaning('猫犬')
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_meaning
+    }
+    assert_raise(ArgumentError) {
+      @@db.get_meaning('動', '詞')
+    }
+  end
+
+  def test_is_kanji?
+    assert @@db.is_kanji?('猫')
+    assert @@db.is_kanji?('犬')
+    assert @@db.is_kanji?('富')
+    assert @@db.is_kanji?('夢')
+    assert @@db.is_kanji?('田')
+    assert (not @@db.is_kanji?('犭'))
+    assert (not @@db.is_kanji?('t'))
+    assert (not @@db.is_kanji?(''))
+    assert (not @@db.is_kanji?('犬猫'))
+    assert_raise(ArgumentError) {
+      @@db.is_kanji?
+    }
+    assert_raise(ArgumentError) {
+      @@db.is_kanji?('犬','猫')
+    }
+  end
+
+  def test_is_radical?
+    assert @@db.is_radical?('犭')
+    assert @@db.is_radical?('犬')
+    assert @@db.is_radical?('田')
+    assert (not @@db.is_radical?('富'))
+    assert (not @@db.is_radical?('t'))
+    assert (not @@db.is_radical?('夢'))
+    assert (not @@db.is_radical?(''))
+    assert (not @@db.is_radical?('犬田'))
+    assert_raise(ArgumentError) {
+      @@db.is_radical?
+    }
+    assert_raise(ArgumentError) {
+      @@db.is_radical?('犬','田')
+    }
+  end
+
+end
+
+
+if $0 == __FILE__
+  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?
-}
+  results.each {|p|
+    h,r=p
+    puts "#{r.passed? ? 'PASS' : 'FAIL'} : #{h}"
+    puts ("       %s" % r.to_s) unless r.passed?
+  }
+end

data/test/runicode_test.rb

@@ -0,0 +1,89 @@
+=begin
+
+  test/runicode_test.rb
+
+  Copyright © Tom Adams 2006
+
+  This programme is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby License.
+
+=end
+
+require 'runicode'
+
+require 'test/unit'
+
+# RUnicode tests
+class RUnicode_Test < Test::Unit::TestCase
+  def test_all
+    str = "hello ÂÅ¿ 今日は ���"
+    nstr = ""
+    str.each_codepoint {|c| nstr << c.chr}
+    assert str == nstr, 'Testcase equals testcase.'
+  end
+
+  def test_string_codepoints
+    str = "hello ÂÅ¿ 今日は ���"
+    strcp = []
+    str.each_codepoint {|c| strcp << c}
+    assert str.codepoints == strcp, 'codepoints and each_codepoints give the same values'
+  end
+
+  def test_integer_chr
+    codepoint = 0x00110000 # This is one higher than the highest codepoint
+    begin
+      codepoint.chr
+      assert false, 'Failed to raise exception.'
+    rescue Exception
+      assert $!.is_a?(RangeError), 'Raised correct exception.'
+    end
+    assert (codepoint-1).chr.is_a?(String)
+  end
+
+  #The Unicode Standard, version 4.0--online edition.
+  #Section 3.9, D36.
+  def test_d36
+    # Example strings
+    cp = [0x004D, 0x0430, 0x4E8C, 0x10302]
+    str = [0x4D, 0xD0, 0xB0, 0xE4, 0xBA, 0x8C, 0xF0, 0x90, 0x8C, 0x82]
+
+    new_cp = ''
+    cp.each {|c| new_cp << c.chr}
+    new_str = "%c%c%c%c%c%c%c%c%c%c" % str
+
+    assert new_cp == new_str, 'Strings match.'
+
+    # Table 3-6
+
+    # Non-shortest form
+    #Covered by previous section
+
+    # Surrogate pairs
+    cprange = 0xD800..0xDFFF
+    cprange.each {|cp|
+      begin
+        cp.chr
+        assert false, ('Exception not thrown for U+%04X' % cp)
+      rescue RangeError
+      end
+    }
+
+    # Extra test cases mentioned around D36
+
+    begin
+      # 0b11000000 0b10101111
+      ("%c%c" % [0xC0, 0xAF]).codepoints
+      assert false, 'Exception not thrown for invalid 2-byte construct'
+    rescue IOError
+    end
+    begin
+      # 0b11100000 0b10011111 0b10011111
+      ("%c%c%c" % [0xE0, 0x9F, 0x80]).codepoints
+      assert false, 'Exception not thrown for invalid 3-byte construct'
+    rescue IOError
+    end
+    # This one should succeed
+    ("%c%c%c%c" % [0xF4, 0x80, 0x83, 0x92]).codepoints
+  end
+end

data/test/suite.rb

@@ -10,12 +10,8 @@
 
 =end
 
-begin
-  require 'runicode_test'
-rescue LoadError
-end
-
-require 'database_test.rb'
+require 'runicode_test'
+require 'database_test'
 
 require 'klookup'
 require 'test/unit'
@@ -25,13 +21,13 @@ class Lookup_Test < Test::Unit::TestCase
 
   # Check classes
   def test_radical_type
-    assert KLookup::Lookup::Radical.strokes.kind_of?(Array), 'KLookup::Lookup::Radical.strokes is an Array'
-    assert KLookup::Lookup::Radical.new('田').kind_of?(KLookup::Lookup::Radical), 'KLookup::Lookup::Radical initilaisation works'
+    assert_kind_of Array, KLookup::Lookup::Radical.strokes, 'KLookup::Lookup::Radical.strokes is an Array'
+    assert_kind_of KLookup::Lookup::Radical, KLookup::Lookup::Radical.new('田'), 'KLookup::Lookup::Radical initilaisation works'
   end
 
   # Check to_s behaviour
   def test_radical_to_s
-    assert KLookup::Lookup::Radical.new('田').to_s=='田', 'A field is a field.'
+    assert_equal KLookup::Lookup::Radical.new('田').to_s, '田', 'A field is a field.'
   end
 
   def test_radical_list
@@ -41,8 +37,8 @@ class Lookup_Test < Test::Unit::TestCase
 
   # Initialisation should work
   def test_kanji_to_s
-    assert KLookup::Lookup::Kanji.new('猫').to_s=='猫', 'Cat.'
-    assert KLookup::Lookup::Kanji.new('栗').to_s=='栗', 'Chestnut.'
+    assert_equal KLookup::Lookup::Kanji.new('猫').to_s, '猫', 'Cat.'
+    assert_equal KLookup::Lookup::Kanji.new('栗').to_s, '栗', 'Chestnut.'
   end
 
   # Lookups should work
@@ -62,27 +58,25 @@ class Lookup_Test < Test::Unit::TestCase
   # Checks stroke count works
   def test_kanji_lookup_stroke
     # Unmatching stroke counts should result in empty lists
-    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.'
+    assert_equal 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_equal 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
     cat=KLookup::Lookup::Kanji.new('猫').radicals
     catr=[KLookup::Lookup::Radical.new('艹'), KLookup::Lookup::Radical.new('犭'), KLookup::Lookup::Radical.new('田')]
-    unless cat.all? {|r| catr.include? r } and cat.size==catr.size
-      assert false, 'KLookup::Lookup::Kanji#radicals works fine.'
-    end
+    assert (cat.all? {|r| catr.include? r } and cat.size==catr.size), 'KLookup::Lookup::Kanji#radicals works fine.'
   end
 
+  # TODO: Not compatible with non-KANJIDIC data sources
   def test_kanji_meaning
     pull = KLookup::Lookup::Kanji.new('引')
-    assert pull.meaning==['pull','tug','jerk','admit','install','quote',
+    assert_equal pull.meaning, ['pull','tug','jerk','admit','install','quote',
                           'refer to']
     origin = KLookup::Lookup::Kanji.new('元')
-    assert origin.meaning==['beginning','former time','origin'], origin.to_s
+    assert_equal origin.meaning, ['beginning','former time','origin']
     i = KLookup::Lookup::Kanji.new('以')
-    assert i.meaning==['by means of','because','in view of','compared with'],
-    i.to_s
+    assert_equal i.meaning,['by means of','because','in view of','compared with']
   end
 
   def test_kanji_reading
@@ -92,30 +86,21 @@ class Lookup_Test < Test::Unit::TestCase
   end
 
   def test_multiple_kanji
-    begin
-      stupid = KLookup::Lookup::Kanji.new('馬鹿')
-      assert false, 'Failed to raise exception.'
-    rescue Exception
-      assert $!.is_a?(ArgumentError), 'Raised correct exception.'
-    end
+    assert_raise(ArgumentError) {
+      KLookup::Lookup::Kanji.new('馬鹿')
+    }
   end
 
   def test_un_kanji
-    begin
-      not_a_kanji = KLookup::Lookup::Kanji.new('k')
-      assert false, 'Raised exception.'
-    rescue ArgumentError
-      # Win
-    end
+    assert_raise(ArgumentError) {
+      KLookup::Lookup::Kanji.new('k')
+    }
   end
 
   def test_un_radical
-    begin
-      not_a_radical = KLookup::Lookup::Radical.new('r')
-      assert false, 'Raised exception.'
-    rescue ArgumentError
-      # Win
-    end
+    assert_raise(ArgumentError) {
+      KLookup::Lookup::Radical.new('r')
+    }
   end
 
   def test_exist
@@ -191,28 +176,57 @@ class Lookup_Test < Test::Unit::TestCase
     assert (look.include?(cat) and not look.include?(dog)),
     'true in block and reading'
   end
+
+  def test_kanji_stroke_count
+    assert_equal KLookup::Lookup::Kanji.new('猫').stroke_count, 11
+    assert_equal KLookup::Lookup::Kanji.new('犬').stroke_count, 4
+  end
+
+  def test_radical_stroke_count
+    assert_equal KLookup::Lookup::Radical.new('犬').stroke_count, 4
+    assert_equal KLookup::Lookup::Radical.new('犭').stroke_count, 3
+  end
 end
 
+if $0 == __FILE__
+  require 'test/unit/ui/console/testrunner'
+  results=[]
+  db_results=[]
+  db=KLookup::Database
+  puts
+
+  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
+    db_results << [handler,
+                   Test::Unit::UI::Console::TestRunner.run(Database_Test)]
+
+    KLookup::Lookup.handler = eval(handler)
+    results << [handler,
+                Test::Unit::UI::Console::TestRunner.run(Lookup_Test)]
+    puts
+  }
 
-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(Lookup_Test)]
+  puts "= RUnicode_Test"
+  runicode_results = Test::Unit::UI::Console::TestRunner.run(RUnicode_Test)
+  puts "#{runicode_results.passed? ? 'PASS' : 'FAIL'}"
+  puts ("\t%s" % runicode_results.to_s) unless runicode_results.passed?
+
   puts
-}
+  puts "= Database_Test"
+  db_results.each {|h,r|
+    puts "#{r.passed? ? 'PASS' : 'FAIL'}\t: #{h}"
+    puts ("\t%s" % r.to_s) unless r.passed?
+  }
 
-results.each {|p|
-  h,r=p
-  puts "#{r.passed? ? 'PASS' : 'FAIL'} : #{h}"
-  puts ("       %s" % r.to_s) unless r.passed?
-}
+  puts
+  puts "= Lookup_Test"
+  results.each {|h,r|
+    puts "#{r.passed? ? 'PASS' : 'FAIL'}\t: #{h}"
+    puts ("\t%s" % r.to_s) unless r.passed?
+  }
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: klookup
 version: !ruby/object:Gem::Version 
-  version: 0.2.4
-date: 2007-02-18 00:00:00 +00:00
+  version: "0.3"
+date: 2007-03-01 00:00:00 +00:00
 summary: A set of kanji lookup tools and a library.
 require_paths: 
 - lib
@@ -12,7 +12,7 @@ email: tom@holizz.com
 homepage: http://klookup.rubyforge.org/
 rubyforge_project: klookup
 description: A character dictionary for Japanese kanji.
-autorequire: 
+autorequire: klookup
 default_executable: cklookup
 bindir: bin
 has_rdoc: true
@@ -29,22 +29,27 @@ post_install_message:
 authors: 
 - Tom Adams
 files: 
+- data/klookup/data.db
 - data/klookup/kanjidic
 - data/klookup/newradkfile
-- lib/klookup.rb
+- lib/runicode.rb
 - lib/klookup
-- lib/klookup/lookup.rb
-- lib/klookup/lookup_radical.rb
+- lib/klookup/database_sqlite.rb
+- lib/klookup/lookup_kanji.rb
 - lib/klookup/database.rb
-- lib/klookup/database_quickfile.rb
-- lib/klookup/database_flatfile_radk.rb
-- lib/klookup/database_unihan.rb
+- lib/klookup/lookup.rb
 - lib/klookup/database_flatfile_kanjidic.rb
+- lib/klookup/database_unihan.rb
+- lib/klookup/database_flatfile_radk.rb
+- lib/klookup/lookup_radical.rb
 - lib/klookup/database_flatfile.rb
-- lib/klookup/lookup_kanji.rb
+- lib/runicode
+- lib/runicode/utf8.rb
+- lib/klookup.rb
 test_files: 
-- test/suite.rb
 - test/database_test.rb
+- test/runicode_test.rb
+- test/suite.rb
 rdoc_options: 
 - - --main
   - KLookup
@@ -61,11 +66,11 @@ requirements: []
 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: sqlite-ruby
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.4.0
+        version: 2.2.3
     version: 

data/lib/klookup/database_quickfile.rb

@@ -1,38 +0,0 @@
-=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