bitclust-core 1.2.6 → 1.6.0

data/lib/bitclust/syntax_highlighter.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "ripper"
 require "bitclust/htmlutils"
 
@@ -55,6 +56,7 @@ module BitClust
       nl: nil,                         # \n
       op: "o",                         # operator
       period: "p",                     # .
+      qsymbols_beg: "ss",              # %i(
       qwords_beg: "sx",                # %w(
       rbrace: "p",                     # }
       rbracket: "p",                   # ]
@@ -64,6 +66,7 @@ module BitClust
       semicolon: nil,                  # ;
       sp: nil,                         # space
       symbeg: "ss",                    # :
+      symbols_beg: "ss",               # %I(
       tlambda: "o",                    # ->
       tlambeg: "p",                    # (->) {
       tstring_beg: nil,                # " (string")
@@ -130,7 +133,7 @@ module BitClust
     end
 
     def on_default(event, token, data)
-      event_name = event.to_s.sub(/\Aon_/, "")   # :on_event --> "event"
+      event_name = event.to_s.sub(/\Aon_/, "")   ## :on_event --> "event"
       style = COLORS[event_name.to_sym]
       escaped_token = escape_html(token)
       data << (style ? "<span class=\"#{style}\">#{escaped_token}</span>" : escaped_token)
@@ -164,6 +167,8 @@ module BitClust
       when @stack.last == :method_call
         data << "<span class=\"nf\">#{token}</span>"
         @stack.pop
+      when @stack.last == :class
+        @name_buffer << token
       when BUILTINS_G.include?(token)
         data << "<span class=\"nb\">#{token}</span>"
       else
@@ -178,6 +183,9 @@ module BitClust
         @name_buffer << token
       when @stack.last == :module
         @name_buffer << token
+      when @stack.last == :symbol
+        data << "#{token}</span>"
+        @stack.pop
       else
         on_default(:on_const, token, data)
       end
@@ -213,8 +221,11 @@ module BitClust
 
     def on_op(token, data)
       case
-      when token == "::" && [:class, :module].include?(@stack.last)
+      when token == "::" && [:class, :module].include?(_ = @stack.last)
         @name_buffer << token
+      when token == "<<" && @stack.last == :class
+        @stack.pop
+        on_default(:on_op, token, data)
       else
         @stack.pop if @stack.last == :method_call
         on_default(:on_op, token, data)
@@ -266,6 +277,28 @@ module BitClust
       on_default(:on_nl, token, data)
     end
 
+    def on_semicolon(token, data)
+      case
+      when @name_buffer.empty?
+        return on_default(:on_semicolon, token, data)
+      when @stack.last == :module
+        name = @name_buffer.join
+        data << "<span class=\"nn\">#{name}</span>"
+        @stack.pop
+        @name_buffer.clear
+      when @stack.last == :class
+        namespace = @name_buffer.values_at(0..-3).join
+        operator = @name_buffer[-2]
+        name = @name_buffer.last
+        data << "<span class=\"nn\">#{namespace}</span>"
+        data << "<span class=\"o\">#{operator}</span>"
+        data << "<span class=\"nc\">#{name}</span>"
+        @stack.pop
+        @name_buffer.clear
+      end
+      on_default(:on_semicolon, token, data)
+    end
+
     def on_regexp_beg(token, data)
       style = COLORS[:regexp_beg]
       data << "<span class=\"#{style}\">#{token}"
@@ -313,7 +346,7 @@ module BitClust
       case
       when token == "'"
         data << "#{token}</span>"
-      when [:qwords, :words].include?(@stack.last)
+      when %i[qwords words qsymbols symbols].include?(_ = @stack.last)
         @stack.pop
         data << "#{token}</span>"
       else
@@ -337,6 +370,20 @@ module BitClust
       data
     end
 
+    def on_qsymbols_beg(token, data)
+      @stack.push(:qsymbols)
+      style = COLORS[:qsymbols_beg]
+      data << "<span class=\"#{style}\">#{token}"
+      data
+    end
+
+    def on_symbols_beg(token, data)
+      @stack.push(:symbols)
+      style = COLORS[:symbols_beg]
+      data << "<span class=\"#{style}\">#{token}"
+      data
+    end
+
     def on_heredoc_beg(token, data)
       @stack.push(:heredoc)
       on_default(:on_heredoc_beg, token, data)
@@ -360,12 +407,12 @@ module BitClust
     def on___end__(token, data)
       on_default(:on___end__, token, data)
       style = COLORS[:comment]
-      data << "<span class=\"#{style}\">#{escape_html(@src.lines[lineno..-1].join)}</span>"
+      data << "<span class=\"#{style}\">#{escape_html((@src.lines[lineno..-1] || raise).join)}</span>"
       data
     end
 
     def highlight
-      parse("")
+      parse(+"")
     end
   end
 end

data/lib/bitclust/textutils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # bitclust/textutils
 #
@@ -17,7 +18,7 @@ module BitClust
     def detab(str, ts = 8)
       add = 0
       str.gsub(/\t/) {
-        len = ts - ($~.begin(0) + add) % ts
+        len = ts - ((($~ || raise).begin(0) || raise) + add) % ts
         add += len - 1
         ' ' * len
       }
@@ -29,11 +30,11 @@ module BitClust
     end
 
     def n_minimum_indent(lines)
-      lines.reject {|line| line.strip.empty? }.map {|line| n_indent(line) }.min
+      lines.reject {|line| line.strip.empty? }.map {|line| n_indent(line) }.min || raise
     end
 
     def n_indent(line)
-      line.slice(/\A\s*/).size
+      (line.slice(/\A\s*/) || raise).size
     end
 
     INDENT_RE = {

data/lib/bitclust/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module BitClust
-  VERSION = "1.2.6"
+  VERSION = "1.6.0"
 end

data/lib/bitclust/version_badges.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+#
+# bitclust/version_badges.rb
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+module BitClust
+
+  # Renders the small "since"/"until" version badges shown next to a
+  # method's signature (bitclust#132 phase P3). The version data comes from
+  # MethodEntry's per-name since_map/until_map (bitclust#132 phase P2); an
+  # empty map means "no badge", which keeps the output byte-identical to
+  # what it was before this feature existed.
+  #
+  # Included by both RDCompiler (the <dt class="method-heading"> emitted
+  # for RD/Markdown method pages) and TemplateScreen (the default server
+  # template's method table rows), so it only relies on the `_`
+  # (Translatable) and escape_html (HTMLUtils) methods that both hosts
+  # already provide.
+  module VersionBadges
+    SINCE_CSS_CLASS = 'method-since-badge'
+    UNTIL_CSS_CLASS = 'method-until-badge'
+    SINCE_CATALOG_KEY = 'since Ruby %s'
+    UNTIL_CATALOG_KEY = 'removed in Ruby %s'
+
+    # HTML for the badges attached to the <dt> heading of one of +entry+'s
+    # signature lines (RDCompiler#method_signature). since/until are
+    # decided independently: when every one of entry's names maps to the
+    # very same version, the badge is rendered once, on the first
+    # signature's <dt> (+first+ true), instead of being repeated on every
+    # alias's <dt>; otherwise (mixed/partial) it is looked up per +name+.
+    def heading_version_badges(entry, name, first)
+      name = badge_lookup_name(name)
+      join_badge_spans(
+        heading_badge_span(entry, name, first, entry.since_map,
+                            SINCE_CSS_CLASS, SINCE_CATALOG_KEY),
+        heading_badge_span(entry, name, first, entry.until_map,
+                            UNTIL_CSS_CLASS, UNTIL_CATALOG_KEY)
+      )
+    end
+
+    # HTML for the badges attached to a single signature line in the
+    # default (server) template's method table
+    # (data/bitclust/template/class). Each row already lists every alias on
+    # its own line, so this always looks the version up by +name+ directly
+    # -- no uniform-across-all-names aggregation, unlike heading_version_badges.
+    def row_version_badges(entry, name)
+      name = badge_lookup_name(name)
+      join_badge_spans(
+        badge_span(entry.since_map[name], SINCE_CSS_CLASS, SINCE_CATALOG_KEY),
+        badge_span(entry.until_map[name], UNTIL_CSS_CLASS, UNTIL_CATALOG_KEY)
+      )
+    end
+
+    private
+
+    # シグネチャ行から取り出した名前を since_map/until_map のキーに合わせる。
+    # 特殊変数のシグネチャ名は "$SAFE" のように $ 付きだが、エントリの names
+    # (= マップのキー)は先頭の $ を除いた形("SAFE"。"$$" なら "$")で
+    # 格納されている(rrdparser の method_signature と同じ規約)
+    def badge_lookup_name(name)
+      name.sub(/\A\$/, '')
+    end
+
+    def heading_badge_span(entry, name, first, map, css_class, catalog_key)
+      return nil if map.empty?
+      version = uniform_map?(entry, map) ? (first ? map.values.first : nil) : map[name]
+      badge_span(version, css_class, catalog_key)
+    end
+
+    # Whether +map+ assigns the very same version to every one of entry's
+    # names, i.e. the badge applies uniformly and doesn't need to be
+    # repeated per alias.
+    def uniform_map?(entry, map)
+      map.size == entry.names.size && map.values.uniq.size == 1
+    end
+
+    def badge_span(version, css_class, catalog_key)
+      # 空文字は「明示的に不明」({: since=""})= バッジ非表示(bitclust#132)
+      return nil if version.nil? || version.empty?
+      %Q(<span class="#{css_class}">#{escape_html(_(catalog_key, version))}</span>)
+    end
+
+    def join_badge_spans(*spans)
+      spans.compact.join(' ')
+    end
+  end
+end

data/lib/bitclust/whole_file_gate.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'bitclust/include_graph'
+
+module BitClust
+  # ファイル全体を包む単一の版ゲート（#@else 無し）の検出と解除（O4）。
+  #
+  # 旧 RD ではライブラリ/エンティティ自体の版ゲートをファイル全体の
+  # #@since/#@until/#@if ラップで表現していた。新パイプラインでは
+  # front matter の since/until（構造ゲート）で表現するため、
+  # スコープの下で「常に真」または「since/until で表現できる」ラップは外す。
+  #
+  # 据え置き（nil を返す）:
+  # - #@else 付き（fiddle.rd。枝の選択は本文の版分岐として温存）
+  # - スコープ外のゲート（profile.rd 等。旧版サルベージは別スコープで再実行）
+  # - 常に真と証明できない #@if 条件
+  module WholeFileGate
+    GATE_OPEN_RE = /\A\#@(since|until|if)\s*(.*)$/
+    BLOCK_OPEN_RE = /\A\#@(?:since|until|if|samplecode)\b/
+    BLANK_RE = /\A\s*\z/
+
+    # 常に真と証明できる #@if 条件の形（rss.rd の (version >= "1.8.2")）
+    VERSION_GE_RE = /\A\(?\s*version\s*>=\s*"([\d.]+)"\s*\)?\z/
+
+    module_function
+
+    # ファイル全体を包むゲートの Condition を返す。該当しなければ nil
+    def detect(src)
+      open_idx, close_idx, cond, has_else = parse(src.lines)
+      return nil if open_idx.nil? || has_else
+      cond if close_idx
+    end
+
+    # 据え置きゲート（unwrap できない library ルート等）のメタデータ領域
+    # （require/sublibrary/category）を、本文と分けてそれぞれ同じゲートで包んだ
+    # 意味等価な正規形に書き換える。native パースはメタデータを front matter から
+    # しか読まないため、ゲート内に埋もれた rd 形式のメタ行を、既存のゲート対応
+    # メタデータ収集器が front matter 化できる位置（ファイル先頭のブロック）へ出す。
+    # 全体ゲートでない・メタデータが無い・本文が無い場合は nil
+    def regate_metadata(src)
+      lines = src.lines
+      open_idx, close_idx, cond, has_else = parse(lines)
+      return nil if open_idx.nil? || close_idx.nil? || has_else || cond.nil?
+      content = lines[(open_idx + 1)...close_idx] || raise
+      i = 0
+      i += 1 while content[i] && content[i] =~ BLANK_RE
+      meta_start = i
+      meta_end = nil
+      j = meta_start
+      while content[j]
+        case content[j]
+        when /\A(?:require|sublibrary|category)\s+\S/ then meta_end = j + 1
+        when BLANK_RE then nil
+        else break
+        end
+        j += 1
+      end
+      return nil unless meta_end
+      rest = content[meta_end..] || raise
+      rest.shift while rest.first && rest.first =~ BLANK_RE
+      return nil if rest.empty?
+      gate_line = lines[open_idx]
+      # 種別（category/require/sublibrary）ごとに独立ブロックへ分ける
+      # （メタデータ収集器の「#@ ブロックは単一種のみ」の制約に合わせる）
+      runs = [] #: Array[[String?, Array[String]]]
+      (content[meta_start...meta_end] || raise).each do |l|
+        next if l =~ BLANK_RE
+        kind = l[/\A(category|require|sublibrary)/, 1]
+        if runs.last && runs.last[0] == kind
+          runs.last[1] << l
+        else
+          runs << [kind, [l]]
+        end
+      end
+      meta_blocks = runs.flat_map { |_, ls| [gate_line] + ls + ["\#@end\n", "\n"] }
+      ((lines[0...open_idx] || raise) +
+        meta_blocks +
+        [gate_line] + rest + ["\#@end\n"] +
+        (lines[(close_idx + 1)..] || raise)).join
+    end
+
+    # スコープの下で解除できる全体ゲートなら [解除後の src, front matter に
+    # 書く gate（{} は不要の意）] を返す。据え置きなら nil
+    def unwrap_for_scope(src, scope)
+      lines = src.lines
+      open_idx, close_idx, cond, has_else = parse(lines)
+      return nil if open_idx.nil? || close_idx.nil? || has_else || cond.nil?
+
+      gate =
+        case cond.kind
+        when :if
+          return nil unless provably_true_if?(cond.version, scope)
+          {} #: IncludeGraph::gate
+        else
+          scoped = scope.gate([cond])
+          return nil unless scoped   # スコープ外 → 据え置き
+          scoped
+        end
+
+      body = (lines[0...open_idx] || raise) + (lines[(open_idx + 1)...close_idx] || raise) + (lines[(close_idx + 1)..] || raise)
+      body.shift while body.first && body.first =~ BLANK_RE
+      [body.join, gate]
+    end
+
+    # [開き行 idx, 閉じ行 idx, Condition, トップレベル #@else の有無] を返す。
+    # 全体ゲートでなければ open_idx が nil
+    def parse(lines)
+      open_idx = lines.index { |l| l !~ BLANK_RE }
+      return [nil] unless open_idx && lines[open_idx] =~ GATE_OPEN_RE
+      cond = IncludeGraph::Condition.new(($1 || raise).to_sym, ($2 || raise).strip)
+
+      nest = 0
+      has_else = false
+      close_idx = nil #: Integer?
+      (open_idx...lines.length).each do |i|
+        case lines[i]
+        when BLOCK_OPEN_RE then nest += 1
+        when /\A\#@else\b/ then has_else = true if nest == 1
+        when /\A\#@end\b/
+          nest -= 1
+          if nest.zero?
+            close_idx = i
+            break
+          end
+        end
+      end
+      return [nil] if close_idx.nil?
+      # 閉じ行の後に非空行があれば全体ゲートではない
+      return [nil] if (lines[(close_idx + 1)..] || raise).any? { |l| l !~ BLANK_RE }
+      [open_idx, close_idx, cond, has_else]
+    end
+
+    def provably_true_if?(condition, scope)
+      condition =~ VERSION_GE_RE && Gem::Version.new($1) <= scope.lo
+    end
+  end
+end

data/lib/bitclust.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'bitclust/requesthandler'
 require 'bitclust/screen'
 require 'bitclust/server'

data/test/test_app.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+require 'test/unit'
+require 'bitclust'
+require 'bitclust/app'
+require 'rack'
+require 'rack/mock'
+require 'webrick'
+require 'tmpdir'
+require 'fileutils'
+require 'stringio'
+
+# bitclust#275: `rake generate` で DB を再生成しても `bitclust server` を
+# 再起動しなくてよいようにする。
+#
+# テストリスト:
+# [x] DB を再生成(rm_rf+init+update)した後、同じ App/Interface への同じ
+#     リクエストで新しい内容が返り、古い内容(メモ化されていたはず)が消えて
+#     いる(Rack ハンドラ、dbpath が String の単一 DB)
+# [x] 同じことが WEBrick ハンドラ(options[:rack] を渡さない既定経路)でも
+#     成り立つ
+# [x] dbpath が Array(複数バージョン)のときも、各バージョンの Interface が
+#     独立に再生成を検知する。片方だけ再生成しても、もう片方の内容は無関係
+#     のまま
+# [x] DB 再生成の途中(rm_rf 直後、properties が一時的に存在しない)に
+#     リクエストが来ても例外にならず、直前の内容を返し続ける(次のリクエスト
+#     で改めて判定する)
+# [x] --capi 有効時は FunctionDatabase 側の再生成も反映される
+class TestApp < Test::Unit::TestCase
+  def setup
+    $bitclust_context_cache = nil
+    @tmpdir = Dir.mktmpdir('bitclust-app-reload')
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmpdir)
+    $bitclust_context_cache = nil
+  end
+
+  def test_rack_handler_reflects_regenerated_db_without_restart
+    dbdir = "#{@tmpdir}/db"
+    srcroot = "#{@tmpdir}/src"
+    build_method_db(dbdir, srcroot, 'ORIGINAL_MARKER')
+
+    interface = build_app(dbdir, :rack => true).interfaces['/view/']
+
+    assert_include(rack_body(interface, '/class/Target'), 'ORIGINAL_MARKER')
+
+    regenerate(dbdir) { build_method_db(dbdir, srcroot, 'UPDATED_MARKER') }
+
+    after = rack_body(interface, '/class/Target')
+    assert_include(after, 'UPDATED_MARKER')
+    assert_not_include(after, 'ORIGINAL_MARKER')
+  end
+
+  def test_webrick_handler_reflects_regenerated_db_without_restart
+    dbdir = "#{@tmpdir}/db"
+    srcroot = "#{@tmpdir}/src"
+    build_method_db(dbdir, srcroot, 'ORIGINAL_MARKER')
+
+    servlet = build_app(dbdir).interfaces['/view/'].get_instance(WEBrick::Config::HTTP)
+
+    assert_include(webrick_body(servlet, '/class/Target'), 'ORIGINAL_MARKER')
+
+    regenerate(dbdir) { build_method_db(dbdir, srcroot, 'UPDATED_MARKER') }
+
+    after = webrick_body(servlet, '/class/Target')
+    assert_include(after, 'UPDATED_MARKER')
+    assert_not_include(after, 'ORIGINAL_MARKER')
+  end
+
+  def test_each_version_reloads_independently_for_array_dbpath
+    dbdir_30 = "#{@tmpdir}/db-3.0"
+    dbdir_40 = "#{@tmpdir}/db-4.0"
+    src_30 = "#{@tmpdir}/src-3.0"
+    src_40 = "#{@tmpdir}/src-4.0"
+    build_method_db(dbdir_30, src_30, 'V30_ORIGINAL')
+    build_method_db(dbdir_40, src_40, 'V40_ORIGINAL')
+
+    datadir = File.expand_path('../data/bitclust', __dir__)
+    app = BitClust::App.new(
+      :dbpath => [dbdir_30, dbdir_40],
+      :rack => true,
+      :baseurl => '',
+      :capi => false,
+      :encoding => 'utf-8',
+      :datadir => datadir,
+      :templatedir => "#{datadir}/template.offline"
+    )
+    interface_30 = app.interfaces['3.0']
+    interface_40 = app.interfaces['4.0']
+
+    assert_include(rack_body(interface_30, '/class/Target'), 'V30_ORIGINAL')
+    assert_include(rack_body(interface_40, '/class/Target'), 'V40_ORIGINAL')
+
+    regenerate(dbdir_30) { build_method_db(dbdir_30, src_30, 'V30_UPDATED') }
+
+    v30_after = rack_body(interface_30, '/class/Target')
+    assert_include(v30_after, 'V30_UPDATED')
+    assert_not_include(v30_after, 'V30_ORIGINAL')
+    # 触っていない 4.0 側は無関係のまま
+    assert_include(rack_body(interface_40, '/class/Target'), 'V40_ORIGINAL')
+  end
+
+  def test_stale_content_served_without_raising_while_properties_missing
+    dbdir = "#{@tmpdir}/db"
+    srcroot = "#{@tmpdir}/src"
+    build_method_db(dbdir, srcroot, 'ORIGINAL_MARKER')
+
+    interface = build_app(dbdir, :rack => true).interfaces['/view/']
+    assert_include(rack_body(interface, '/class/Target'), 'ORIGINAL_MARKER')
+
+    # rake generate の rm_rf 直後(init/update が終わる前)を再現する: properties
+    # が一時的に存在しない
+    FileUtils.rm_rf(dbdir)
+
+    assert_nothing_raised do
+      during = rack_body(interface, '/class/Target')
+      assert_include(during, 'ORIGINAL_MARKER')
+    end
+
+    regenerate(dbdir) { build_method_db(dbdir, srcroot, 'UPDATED_MARKER') }
+
+    assert_include(rack_body(interface, '/class/Target'), 'UPDATED_MARKER')
+  end
+
+  def test_capi_function_database_also_reloads
+    dbdir = "#{@tmpdir}/db"
+    srcroot = "#{@tmpdir}/src"
+    build_method_db(dbdir, srcroot, 'ORIGINAL_MARKER')
+    build_function(dbdir, 'This is the original function doc.')
+
+    interface = build_app(dbdir, :rack => true, :capi => true).interfaces['/view/']
+
+    assert_include(rack_body(interface, '/function/public_func'), 'the original function doc')
+
+    regenerate(dbdir) do
+      build_method_db(dbdir, srcroot, 'UPDATED_MARKER')
+      build_function(dbdir, 'This is the updated function doc.')
+    end
+
+    after = rack_body(interface, '/function/public_func')
+    assert_include(after, 'the updated function doc')
+    assert_not_include(after, 'the original function doc')
+  end
+
+  # rake generate の途中(init 後〜update 完了前)にリクエストが来ると、
+  # init 時点の properties mtime で途中状態の DB を掴んで再構築してしまう。
+  # update 完了(transaction の commit)時に properties の mtime が進むこと
+  # により、次のリクエストで完成した DB を読み直して収束すること。
+  # (utime による人工的な mtime 操作をせず、commit 側の touch だけに頼る)
+  def test_request_during_regeneration_converges_after_update_completes
+    dbdir = "#{@tmpdir}/db"
+    srcroot = "#{@tmpdir}/src"
+    build_method_db(dbdir, srcroot, 'ORIGINAL_MARKER')
+    interface = build_app(dbdir, :rack => true).interfaces['/view/']
+    assert_include(rack_body(interface, '/class/Target'), 'ORIGINAL_MARKER')
+
+    # 再生成の途中状態を再現: rm_rf → init+propset まで(update はまだ)
+    FileUtils.rm_rf(dbdir)
+    db = BitClust::MethodDatabase.new(dbdir)
+    db.init
+    db.transaction do
+      db.propset('version', '3.4')
+      db.propset('encoding', 'utf-8')
+    end
+    # 途中状態のリクエストは(内容はともかく)例外にならないこと
+    assert_nothing_raised { rack_body(interface, '/class/Target') }
+
+    # update 完了 → 次のリクエストで新しい内容に収束すること
+    File.write("#{srcroot}/testlib.rd", <<~RD)
+      = class Target < Object
+      UPDATED_MARKER
+
+      == Instance Methods
+      --- foo
+      foo body
+    RD
+    db.transaction do
+      db.update_by_stdlibtree(srcroot)
+    end
+    after = rack_body(interface, '/class/Target')
+    assert_include(after, 'UPDATED_MARKER')
+    assert_not_include(after, 'ORIGINAL_MARKER')
+  end
+
+  private
+
+  # Screen#run_template は互換 ERB を self.class(ClassScreen 等)にキャッシュ
+  # するため、同一プロセス内で異なる templatedir を混ぜて使うと「最初に
+  # コンパイルされた方が以後ずっと勝つ」(test_method_screen.rb 冒頭のコメント
+  # 参照)。このテストファイルはスイート内の他の Screen 系テストと同じ
+  # template.offline に統一し、新たな衝突を持ち込まない
+  def build_app(dbdir, extra = {})
+    datadir = File.expand_path('../data/bitclust', __dir__)
+    BitClust::App.new({
+      :dbpath => dbdir,
+      :viewpath => '/view/',
+      :baseurl => '',
+      :capi => false,
+      :encoding => 'utf-8',
+      :datadir => datadir,
+      :templatedir => "#{datadir}/template.offline"
+    }.merge(extra))
+  end
+
+  def rack_body(interface, path)
+    env = Rack::MockRequest.env_for(path)
+    _status, _headers, body = interface.call(env)
+    body.join
+  end
+
+  def webrick_body(servlet, path)
+    config = WEBrick::Config::HTTP
+    wreq = WEBrick::HTTPRequest.new(config)
+    wreq.parse(StringIO.new("GET #{path} HTTP/1.1\r\nHost: example.com\r\n\r\n"))
+    wres = WEBrick::HTTPResponse.new(config)
+    servlet.do_GET(wreq, wres)
+    wres.body
+  end
+
+  # DB 再生成の前後で properties の mtime が必ず変わるようにする。
+  # ファイルシステムの mtime 解像度(秒単位のものもある)に依存しないよう、
+  # 再生成後に明示的に前より先の時刻へ File.utime で進める
+  def regenerate(dbdir)
+    properties_path = "#{dbdir}/properties"
+    before = File.exist?(properties_path) ? File.mtime(properties_path) : nil
+    yield
+    forced = (before || Time.now) + 5
+    File.utime(forced, forced, properties_path)
+  end
+
+  def build_method_db(dbdir, srcroot, marker)
+    FileUtils.mkdir_p(srcroot)
+    File.write("#{srcroot}/LIBRARIES", "testlib\n")
+    File.write("#{srcroot}/testlib.rd", <<~RD)
+      = class Target < Object
+      #{marker}
+
+      == Instance Methods
+      --- foo
+      foo body
+    RD
+    db = BitClust::MethodDatabase.new(dbdir)
+    db.init
+    db.transaction do
+      db.propset('version', '3.4')
+      db.propset('encoding', 'utf-8')
+    end
+    db.transaction do
+      db.update_by_stdlibtree(srcroot)
+    end
+    db
+  end
+
+  def build_function(dbdir, doc)
+    FileUtils.mkdir_p("#{dbdir}/function")
+    File.write("#{dbdir}/function/public_func", <<~HERE)
+      filename=test.c
+      macro=false
+      private=false
+      type=VALUE
+      name=public_func
+      params=()
+
+
+      #{doc}
+    HERE
+  end
+end

data/test/test_bitclust.rb

@@ -73,9 +73,11 @@ This is public function.
 <dt>header</dt><dd>VALUE public_func()</dd>
 <dt>filename</dt><dd>test.c</dd>
 </dl>
+<dd class="function-description">
 <p>
 This is public function.
 </p>
+</dd>
     EOS
   end
 end