bitclust-core 1.6.0 → 1.7.0

data/test/test_methodentry.rb

@@ -3,6 +3,7 @@ require 'bitclust'
 require 'bitclust/methoddatabase'
 require 'tmpdir'
 require 'fileutils'
+require 'json'
 
 class TestMethodEntryTitleLabels < Test::Unit::TestCase
   def test_title_labels_matches_label_when_no_alias
@@ -326,3 +327,113 @@ class TestMethodEntrySinceUntil < Test::Unit::TestCase
     File.write(path, lines.join)
   end
 end
+
+# rbs_sig property(RBS シグネチャ表示)。オーバーロード配列
+# ({"segments" => 行, "params"/"arity"/"block" => メタ情報} の配列)を
+# {"overloads": [...]} の JSON 1 行で 'String' 型 property に格納する。
+# JSON は改行を含まず、値中の '=' や ',' も property ファイル
+# (key=value 1 行形式)で安全。
+#
+# テストリスト:
+# [x] 既定は nil で rbs_signature_overloads も nil
+# [x] JSON を入れて save → reload で round-trip する
+# [x] 旧形式(セグメント行列そのものの配列)は segments だけの
+#     オーバーロード列に読み替える(#322 以前の DB)
+# [x] property 行が無い古い DB でも nil(後方互換)
+# [x] 空文字列(シグネチャ無しで save された値)も nil 扱い
+# [x] 壊れた JSON は nil 扱い(描画を落とさない)
+class TestMethodEntryRbsSig < Test::Unit::TestCase
+  OVERLOADS = [
+    {'segments' => [['t', '('], ['c', 'Integer'], ['t', ') -> '], ['c', 'String']],
+     'params' => ['base'], 'arity' => [1, 1]},
+    {'segments' => [['t', '() -> void']],
+     'params' => [], 'arity' => [0, 0], 'block' => 'req'},
+  ]
+
+  def setup
+    @dir = Dir.mktmpdir
+    @db = BitClust::MethodDatabase.new(@dir)
+    @db.init
+    @db.transaction do
+      @db.propset('version', '4.0')
+      @db.propset('encoding', 'utf-8')
+    end
+  end
+
+  def teardown
+    FileUtils.rm_rf(@dir)
+  end
+
+  # 未保存エントリの String 型 property は "(uninitialized)" センチネル
+  # なので、rbs_sig そのものではなく overloads が nil であることを見る
+  def test_default_has_no_overloads
+    m = build_entry('sig')
+    assert_nil m.rbs_signature_overloads
+  end
+
+  def test_roundtrip
+    m = build_entry('sig')
+    m.rbs_sig = JSON.generate({'overloads' => OVERLOADS})
+    m.save
+
+    reloaded = reload_entry(m.id)
+    assert_equal(OVERLOADS, reloaded.rbs_signature_overloads)
+  end
+
+  def test_old_array_format_is_read_as_segments_only
+    m = build_entry('sig')
+    m.rbs_sig = JSON.generate(OVERLOADS.map {|o| o['segments'] })
+    m.save
+
+    reloaded = reload_entry(m.id)
+    assert_equal(OVERLOADS.map {|o| {'segments' => o['segments']} },
+                 reloaded.rbs_signature_overloads)
+  end
+
+  def test_missing_property_is_backward_compatible
+    m = build_entry('sig')
+    m.save
+    strip_property_line(m.id, 'rbs_sig')
+
+    reloaded = reload_entry(m.id)
+    assert_nil reloaded.rbs_sig
+    assert_nil reloaded.rbs_signature_overloads
+  end
+
+  def test_saved_without_signature_is_treated_as_absent
+    m = build_entry('sig')
+    m.save
+
+    reloaded = reload_entry(m.id)
+    assert_nil reloaded.rbs_signature_overloads
+  end
+
+  def test_broken_json_is_treated_as_absent
+    m = build_entry('sig')
+    m.rbs_sig = '{broken'
+    assert_nil m.rbs_signature_overloads
+  end
+
+  private
+
+  def build_entry(name)
+    id = BitClust::NameUtils.build_method_id('_builtin', 'Foo', :instance_method, name)
+    m = BitClust::MethodEntry.new(@db, id)
+    m.names = [name]
+    m.visibility = :public
+    m.kind = :defined
+    m.source = "説明\n"
+    m
+  end
+
+  def reload_entry(id)
+    fresh_db = BitClust::MethodDatabase.new(@dir)
+    BitClust::MethodEntry.new(fresh_db, id)
+  end
+
+  def strip_property_line(id, key)
+    path = File.join(@dir, BitClust::NameUtils.encodeid("method/#{id}"))
+    lines = File.readlines(path).reject {|l| l.start_with?("#{key}=") }
+    File.write(path, lines.join)
+  end
+end

data/test/test_methodsignature.rb

@@ -6,7 +6,9 @@ class TestMethodSignature < Test::Unit::TestCase
   data("special var" => ["$_ -> String | nil", "--- $_ -> String | nil"],
        "backquote"   => ["`command` -> String", "--- `(command) -> String"],
        "aset"        => ["self[key] = value", "--- []=(key, value)"],
-       "aset splat"  => ["[]=(*idxary)", "--- []=(*idxary)"])
+       "aset splat"  => ["[]=(*idxary)", "--- []=(*idxary)"],
+       "self prefix" => ["build(x) -> Foo", "--- self.build(x) -> Foo"],
+       "class prefix" => ["build(x) -> Foo", "--- Foo.build(x) -> Foo"])
   def test_friendlyname(data)
     friendly_string, method_signature = data
     assert_equal(friendly_string, BitClust::MethodSignature.parse(method_signature).friendly_string)

data/test/test_preprocessor.rb

@@ -516,6 +516,32 @@ HERE
       assert_equal "",       process(src, '4.0')
     end
 
+    def test_single_version
+      # 単一版のみの省略記法(#%if (version == "V") と同義)
+      src = gated('#%version 3.1')
+      assert_equal "out\n", process(src, '3.0')
+      assert_equal "in\n",  process(src, '3.1')
+      assert_equal "out\n", process(src, '3.2')
+    end
+
+    def test_single_version_quoted
+      src = gated('#%version "3.1"')
+      assert_equal "in\n",  process(src, '3.1')
+      assert_equal "out\n", process(src, '3.2')
+    end
+
+    def test_single_version_old_prefix
+      src = gated("\#@version 3.1")
+      assert_equal "in\n", process(src, '3.1')
+    end
+
+    def test_single_version_teeny
+      # 版名は文字列一致(teeny 付き版名は teeny まで一致したときのみ)
+      src = gated('#%version 2.7.0')
+      assert_equal "in\n",  process(src, '2.7.0')
+      assert_equal "out\n", process(src, '2.7')
+    end
+
     def test_two_dot_range_is_error
       # .. (終端を含む Range)は誤解を招くため受け付けない(#285)
       assert_raise(BitClust::ParseError) { process(gated('#%version 3.1..3.4'), '3.2') }

data/test/test_rbs_overload_matcher.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+require 'test/unit'
+require 'bitclust/rbs_overload_matcher'
+
+# RbsOverloadMatcher(RBS シグネチャ表示)。引数パターンごとに説明チャンクが
+# 分かれているメソッド(Array.new / Array#[] 等)で、RBS の各オーバーロードを
+# 「ブロック有無 → 引数名の一致 → アリティ範囲の重なり」のスコアで最も近い
+# チャンクへ振り分ける。RBS の引数名は rdoc の call-seq 由来で rurema の
+# 引数名とよく一致するのが根拠。確実な対応が取れない場合は先頭チャンクに
+# 寄せる(重複表示はしない)。
+#
+# オーバーロードは rbs_sig property の JSON をそのまま(文字列キーの Hash)
+# 受け取る。チャンクは正規化済みシグネチャ行("--- " 始まり)の配列の配列。
+#
+# テストリスト:
+# [x] チャンクが 1 つなら全オーバーロードをそこへ(スコア不要)
+# [x] メタの無いオーバーロード(旧形式・attr・(?))は先頭チャンクへ
+# [x] Array#[] 型: 引数名 range / start+length で振り分け・名前が合わない
+#     ものはアリティ同点 → 先頭チャンク
+# [x] Array.new 型: () はアリティで・(ary) は名前で・ブロック付きは
+#     ブロックチャンクへ
+# [x] ブロック必須オーバーロードはブロック無しチャンクより有りを選ぶ
+# [x] チャンク側の引数解析: 省略可能引数・*rest・キーワード・&block・
+#     引数リスト無し
+# [x] 解析できないシグネチャ行だけのチャンクには振り分けない
+class TestRbsOverloadMatcher < Test::Unit::TestCase
+  M = BitClust::RbsOverloadMatcher
+
+  def test_single_chunk_takes_everything
+    overloads = [
+      {'segments' => [], 'params' => ['x'], 'arity' => [1, 1]},
+      {'segments' => [], 'params' => [], 'arity' => [0, 0], 'block' => 'req'},
+    ]
+    assert_equal [[0, 1]], M.assign(overloads, [['--- foo(x) -> nil']])
+  end
+
+  def test_overload_without_meta_goes_to_first_chunk
+    overloads = [{'segments' => []}]
+    chunks = [['--- foo(x) -> nil'], ['--- foo(x, y) -> nil']]
+    assert_equal [[0], []], M.assign(overloads, chunks)
+  end
+
+  # Array#[] の実データ(rbs v3.10.0)。(int index) は nth/range どちらとも
+  # 名前が合わずアリティも同点 → 先頭の nth チャンクへ。range と
+  # start+length は引数名で決まる
+  def test_aref_like_assignment
+    chunks = [
+      ['--- [](nth) -> object | nil'],
+      ['--- [](range) -> Array | nil'],
+      ['--- [](start, length) -> Array | nil'],
+    ]
+    overloads = [
+      {'segments' => [], 'params' => ['index'], 'arity' => [1, 1]},
+      {'segments' => [], 'params' => ['start', 'length'], 'arity' => [2, 2]},
+      {'segments' => [], 'params' => ['range'], 'arity' => [1, 1]},
+    ]
+    assert_equal [[0], [2], [1]], M.assign(overloads, chunks)
+  end
+
+  # Array.new の実データ(rbs v3.10.0)。() はアリティ 0 を含む先頭チャンク
+  # だけに重なる。(ary) と (size, ?val) は引数名で分かれ、ブロック付きは
+  # ブロックチャンクへ
+  def test_new_like_assignment
+    chunks = [
+      ['--- new(size = 0, val = nil) -> Array'],
+      ['--- new(ary) -> Array'],
+      ['--- new(size) {|index| ... } -> Array'],
+    ]
+    overloads = [
+      {'segments' => [], 'params' => [], 'arity' => [0, 0]},
+      {'segments' => [], 'params' => ['ary'], 'arity' => [1, 1]},
+      {'segments' => [], 'params' => ['size', 'val'], 'arity' => [1, 2]},
+      {'segments' => [], 'params' => ['size'], 'arity' => [1, 1], 'block' => 'req'},
+    ]
+    assert_equal [[0, 2], [1], [3]], M.assign(overloads, chunks)
+  end
+
+  def test_required_block_prefers_block_chunk
+    chunks = [
+      ['--- each -> Enumerator'],
+      ['--- each {|item| ... } -> self'],
+    ]
+    overloads = [
+      {'segments' => [], 'params' => [], 'arity' => [0, 0]},
+      {'segments' => [], 'params' => [], 'arity' => [0, 0], 'block' => 'req'},
+    ]
+    assert_equal [[0], [1]], M.assign(overloads, chunks)
+  end
+
+  # 省略可能ブロック(?{ ... })はどちらのチャンクとも矛盾しない。
+  # 引数名の一致で決まる
+  def test_optional_block_is_neutral
+    chunks = [
+      ['--- open(path) -> IO'],
+      ['--- open(fd) {|io| ... } -> object'],
+    ]
+    overloads = [
+      {'segments' => [], 'params' => ['fd'], 'arity' => [1, 1], 'block' => 'opt'},
+    ]
+    assert_equal [[], [0]], M.assign(overloads, chunks)
+  end
+
+  # チャンク側の引数リスト解析。省略可能引数で最小アリティが下がり、
+  # *rest で上限が消え、キーワード名も名前照合に使われる
+  def test_chunk_parsing_of_optional_rest_and_keywords
+    chunks = [
+      ['--- foo(a, b = 1, *rest, key: 0) -> nil'],
+      ['--- foo(x, y) -> nil'],
+    ]
+    overloads = [
+      {'segments' => [], 'params' => ['key'], 'arity' => [5, 5]},
+      {'segments' => [], 'params' => ['x', 'y'], 'arity' => [2, 2]},
+    ]
+    assert_equal [[0], [1]], M.assign(overloads, chunks)
+  end
+
+  # &block 引数はブロック有りとして扱う
+  def test_chunk_block_argument_counts_as_block
+    chunks = [
+      ['--- foo -> Enumerator'],
+      ['--- foo(&block) -> object'],
+    ]
+    overloads = [
+      {'segments' => [], 'params' => [], 'arity' => [0, 0], 'block' => 'req'},
+    ]
+    assert_equal [[], [0]], M.assign(overloads, chunks)
+  end
+
+  # 引数リストの無いシグネチャはアリティ 0 扱い
+  def test_chunk_without_params_is_zero_arity
+    chunks = [
+      ['--- size -> Integer'],
+      ['--- size(n) -> Integer'],
+    ]
+    overloads = [
+      {'segments' => [], 'params' => [], 'arity' => [0, 0]},
+      {'segments' => [], 'params' => ['n'], 'arity' => [1, 1]},
+    ]
+    assert_equal [[0], [1]], M.assign(overloads, chunks)
+  end
+
+  # 同一チャンクに複数シグネチャ行(別名など)がある場合は特徴を合算する
+  def test_multiple_signature_lines_in_one_chunk
+    chunks = [
+      ['--- collect {|item| ... } -> [object]', '--- map {|item| ... } -> [object]'],
+      ['--- collect -> Enumerator', '--- map -> Enumerator'],
+    ]
+    overloads = [
+      {'segments' => [], 'params' => [], 'arity' => [0, 0], 'block' => 'req'},
+      {'segments' => [], 'params' => [], 'arity' => [0, 0]},
+    ]
+    assert_equal [[0], [1]], M.assign(overloads, chunks)
+  end
+
+  # 解析できない行だけのチャンクは振り分け先にならない
+  def test_unparseable_chunk_is_skipped
+    chunks = [
+      ['?????'],
+      ['--- foo(x) -> nil'],
+    ]
+    overloads = [
+      {'segments' => [], 'params' => [], 'arity' => [0, 0]},
+    ]
+    assert_equal [[], [0]], M.assign(overloads, chunks)
+  end
+
+  def test_empty_chunks_returns_empty
+    assert_equal [], M.assign([{'segments' => []}], [])
+  end
+end

data/test/test_rbs_sig_importer.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+require 'test/unit'
+require 'bitclust'
+require 'bitclust/methoddatabase'
+require 'bitclust/rbs_sig_importer'
+require 'tmpdir'
+require 'fileutils'
+require 'json'
+
+# RbsSigImporter(RBS シグネチャ表示)。.rbs 群から
+# "Class#method"/"Class.method" キー → オーバーロード配列の対応を作り、
+# MethodEntry の rbs_sig property に書き込む。
+#
+# オーバーロード = {"segments" => 行, "params" => 引数名, "arity" =>
+# [最小, 最大|nil], "block" => "req"|"opt"} の Hash(segments 以外は
+# チャンク振り分け=RbsOverloadMatcher 用のメタ情報で、無い形式もある)。
+# 行は [種別, テキスト] の配列で、種別 "t" は素のテキスト、"c" は
+# クラス/モジュール名(描画側が DB に存在すればリンク化する)。行の
+# テキストを連結すると元の型シグネチャ文字列に戻る(往復可能)。
+#
+# テストリスト:
+# [x] instance/singleton メソッドが # / . キーになる
+# [x] overload はオーバーロードごとに分かれ、テキスト連結で元に戻る
+# [x] 型名は ["c", name] セグメントになる(引数・戻り値・ジェネリクスの中も)
+# [x] 名前空間付き型名は :: が直前のテキスト側に残る
+# [x] メタ情報: 引数名(位置+キーワード)・アリティ範囲・ブロック有無
+# [x] メタ情報: 引数の無いオーバーロードは params=[]・arity=[0,0]
+# [x] def self?. は # と . の両キーに登録される
+# [x] alias メンバーは元メソッドのシグネチャを共有する
+# [x] attr_reader/attr_writer は name / name= キーになり、型だけの
+#     オーバーロード(メタ無し)になる
+# [x] lookup: typechar i/s/m で引ける(m は # → . の順)
+# [x] lookup: new は Class.new → Class#initialize の順でフォールバック
+# [x] lookup: 別名リストの後ろの名前でもヒットする
+# [x] lookup: 対応が無ければ nil(定数・特殊変数も nil)
+# [x] apply: DB のエントリに rbs_sig(overloads 形式の JSON)が書き込まれる
+# [x] apply: 対応が無いメソッドには書き込まれない
+# [x] apply: 2 回目は無変更(entries_updated=0)
+class TestRbsSigImporter < Test::Unit::TestCase
+  def setup
+    @tmpdir = Dir.mktmpdir
+    @sig_dir = File.join(@tmpdir, 'sig')
+    FileUtils.mkdir_p(@sig_dir)
+    File.write(File.join(@sig_dir, 'foo.rbs'), <<~RBS)
+      class Foo
+        def initialize: (String) -> void
+        def bar: (Integer base) -> String
+               | (::Enumerator::Lazy) -> Array[Integer]
+        def self.build: () -> Foo
+        def self?.mf: () -> bool
+        alias car bar
+        attr_reader label: String
+        attr_writer width: Integer
+        def pairs: (hash[Symbol, String]) -> void
+        def meta: (Integer x, ?String y, *Integer rest, size: Integer, ?name: String) { (Integer) -> void } -> void
+                | (Integer a, Integer b) ?{ () -> void } -> void
+      end
+    RBS
+    @importer = BitClust::RbsSigImporter.new(sig_dirs: [@sig_dir])
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmpdir)
+  end
+
+  def test_instance_and_singleton_methods_are_keyed
+    sigs = @importer.signatures
+    assert sigs.key?('Foo#bar')
+    assert sigs.key?('Foo#initialize')
+    assert sigs.key?('Foo.build')
+    assert_false sigs.key?('Foo#build')
+  end
+
+  def test_overload_lines_roundtrip_to_original_signature
+    overloads = @importer.signatures['Foo#bar']
+    assert_equal 2, overloads.size
+    assert_equal '(Integer base) -> String', join_text(overloads[0])
+    assert_equal '(::Enumerator::Lazy) -> Array[Integer]', join_text(overloads[1])
+  end
+
+  def test_type_names_become_class_segments
+    overloads = @importer.signatures['Foo#bar']
+    assert_equal(
+      [['t', '('], ['c', 'Integer'], ['t', ' base) -> '], ['c', 'String']],
+      overloads[0]['segments'])
+  end
+
+  def test_namespace_prefix_stays_in_text_segment
+    overloads = @importer.signatures['Foo#bar']
+    assert_equal(
+      [['t', '(::'], ['c', 'Enumerator::Lazy'], ['t', ') -> '],
+       ['c', 'Array'], ['t', '['], ['c', 'Integer'], ['t', ']']],
+      overloads[1]['segments'])
+  end
+
+  # 小文字のエイリアス型(hash 等)自体はテキストのままだが、その
+  # ジェネリクス引数の中のクラス名はリンク化候補にする
+  def test_alias_type_args_become_class_segments
+    overloads = @importer.signatures['Foo#pairs']
+    assert_equal(
+      [['t', '(hash['], ['c', 'Symbol'], ['t', ', '], ['c', 'String'],
+       ['t', ']) -> void']],
+      overloads[0]['segments'])
+  end
+
+  # チャンク振り分け用のメタ情報。引数名は位置引数(rest 含む)+
+  # キーワード名、アリティは位置引数の [最小, 最大](rest があれば nil)、
+  # block は必須 "req" / 省略可能 "opt"(無ければキー自体無し)
+  def test_overload_meta
+    overloads = @importer.signatures['Foo#meta']
+    assert_equal %w[x y rest size name], overloads[0]['params']
+    assert_equal [1, nil], overloads[0]['arity']
+    assert_equal 'req', overloads[0]['block']
+    assert_equal %w[a b], overloads[1]['params']
+    assert_equal [2, 2], overloads[1]['arity']
+    assert_equal 'opt', overloads[1]['block']
+  end
+
+  def test_overload_meta_without_params
+    overloads = @importer.signatures['Foo.build']
+    assert_equal [], overloads[0]['params']
+    assert_equal [0, 0], overloads[0]['arity']
+    assert_nil overloads[0]['block']
+    # 名前の無い位置引数はアリティにだけ数える
+    assert_equal [], @importer.signatures['Foo#initialize'][0]['params']
+    assert_equal [1, 1], @importer.signatures['Foo#initialize'][0]['arity']
+  end
+
+  def test_self_question_registers_both_keys
+    sigs = @importer.signatures
+    assert_equal sigs['Foo#mf'], sigs['Foo.mf']
+    assert_equal '() -> bool', join_text(sigs['Foo#mf'][0])
+  end
+
+  def test_alias_member_shares_signature
+    sigs = @importer.signatures
+    assert_equal sigs['Foo#bar'], sigs['Foo#car']
+  end
+
+  def test_attr_members
+    sigs = @importer.signatures
+    assert_equal 'String', join_text(sigs['Foo#label'][0])
+    assert_equal 'Integer', join_text(sigs['Foo#width='][0])
+    assert_equal({'segments' => [['c', 'String']]}, sigs['Foo#label'][0])
+  end
+
+  def test_lookup_by_typechar
+    sigs = @importer.signatures
+    assert_equal sigs['Foo#bar'], @importer.lookup('Foo', 'i', ['bar'])
+    assert_equal sigs['Foo.build'], @importer.lookup('Foo', 's', ['build'])
+    assert_equal sigs['Foo#mf'], @importer.lookup('Foo', 'm', ['mf'])
+  end
+
+  def test_lookup_new_falls_back_to_initialize
+    assert_equal @importer.signatures['Foo#initialize'],
+                 @importer.lookup('Foo', 's', ['new'])
+  end
+
+  def test_lookup_tries_every_alias_name
+    assert_equal @importer.signatures['Foo#bar'],
+                 @importer.lookup('Foo', 'i', ['zzz', 'bar'])
+  end
+
+  def test_lookup_misses_return_nil
+    assert_nil @importer.lookup('Foo', 'i', ['nope'])
+    assert_nil @importer.lookup('Bar', 'i', ['bar'])
+    assert_nil @importer.lookup('Foo', 'c', ['BAR'])
+    assert_nil @importer.lookup('Foo', 'v', ['$bar'])
+  end
+
+  def test_apply_writes_rbs_sig_property
+    prefix = build_db('4.0')
+    stats = @importer.apply(BitClust::MethodDatabase.new(prefix))
+
+    bar = find_entry(prefix, 'bar')
+    assert_equal({'overloads' => @importer.signatures['Foo#bar']},
+                 JSON.parse(bar.rbs_sig))
+    assert_equal 1, stats[:entries_updated]
+    assert_equal 1, stats[:sigs_matched]
+    assert_equal 1, stats[:methods_missed]
+  end
+
+  def test_apply_leaves_unmatched_methods_untouched
+    prefix = build_db('4.0')
+    @importer.apply(BitClust::MethodDatabase.new(prefix))
+    assert_nil find_entry(prefix, 'nope').rbs_signature_overloads
+  end
+
+  def test_apply_twice_is_idempotent
+    prefix = build_db('4.0')
+    @importer.apply(BitClust::MethodDatabase.new(prefix))
+    stats = @importer.apply(BitClust::MethodDatabase.new(prefix))
+    assert_equal 0, stats[:entries_updated]
+    assert_equal 1, stats[:sigs_matched]
+  end
+
+  private
+
+  def join_text(overload)
+    overload['segments'].map {|_kind, text| text }.join
+  end
+
+  def build_db(version)
+    root = "#{@tmpdir}/tree-#{version}/refm/api/src"
+    FileUtils.mkdir_p("#{root}/_builtin")
+    File.write("#{root}/LIBRARIES", "_builtin\n")
+    File.write("#{root}/_builtin.rd", <<~RD)
+      description
+
+      = class Foo < Object
+      == Instance Methods
+      --- bar(base) -> String
+
+      説明
+
+      --- nope -> nil
+
+      説明
+    RD
+    prefix = "#{@tmpdir}/db-#{version}"
+    db = BitClust::MethodDatabase.new(prefix)
+    db.init
+    db.transaction do
+      db.propset('version', version)
+      db.propset('encoding', 'utf-8')
+    end
+    db.transaction do
+      db.update_by_stdlibtree(root)
+    end
+    prefix
+  end
+
+  def find_entry(prefix, name)
+    db = BitClust::MethodDatabase.new(prefix)
+    db.get_class('Foo').entries.find {|m| m.name?(name) }
+  end
+end