bitclust-core 1.3.0 → 1.6.0

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/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

data/test/test_capi_converter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+
+require 'bitclust/capi_converter'
+require 'bitclust/markdown_to_rrd'
+
+# CapiConverter: refm/capi（C API リファレンス）の md 変換。
+# 構造は「--- シグネチャ + 本文」の列のみ（見出し・include・emlist なし、
+# library 等のクロスファイル情報も無い）。front matter 不使用。
+#
+# テストリスト:
+# [x] シグネチャ: --- <C sig> ↔ ### <C sig>（def 等のキーワードは付けない）
+# [x] MACRO / static プレフィクスも素通し
+# [x] 本文の [[f:...]] 参照 ↔ [f:...]
+# [x] インデントコード例（api と同じフェンス化）
+# [x] #@since/#@until ディレクティブのパススルー
+# [x] 定義リスト・ネストリスト（api と同じ変換）
+# [x] convert(rrd) を md→rd すると元に戻る（roundtrip）
+class TestCapiConverter < Test::Unit::TestCase
+  def convert(rrd)
+    BitClust::CapiConverter.convert(rrd)
+  end
+
+  def roundtrip(rrd)
+    BitClust::MarkdownToRRD.convert(convert(rrd), capi: true)
+  end
+
+  def test_signature
+    assert_equal "### VALUE rb_ary_new()\n\n空の Ruby の配列を作成し返します。\n",
+      convert("--- VALUE rb_ary_new()\n\n空の Ruby の配列を作成し返します。\n")
+  end
+
+  def test_macro_and_static_signatures
+    assert_equal "### MACRO type* ALLOC(type)\n", convert("--- MACRO type* ALLOC(type)\n")
+    assert_equal "### static VALUE assign(VALUE self, NODE *lhs)\n",
+      convert("--- static VALUE assign(VALUE self, NODE *lhs)\n")
+  end
+
+  def test_function_reference
+    assert_equal "[f:SPECIAL_CONST_P](obj) が真のとき落ちます。\n",
+      convert("[[f:SPECIAL_CONST_P]](obj) が真のとき落ちます。\n")
+  end
+
+  def test_indented_code_block
+    # フェンス個数はベースインデント幅をエンコードする（3+4=7個。api と同仕様）
+    rrd = "使用例\n\n    VALUE ary;\n    ary = rb_ary_new();\n"
+    md = convert(rrd)
+    assert_match(/^`{7}\nVALUE ary;\nary = rb_ary_new\(\);\n`{7}$/, md)
+    assert_equal rrd, roundtrip(rrd)
+  end
+
+  def test_directives_pass_through
+    rrd = "\#@until 2.2.0\n--- void Check_SafeStr(VALUE v)\n\n古い API です。\n\#@end\n"
+    assert_equal "\#@until 2.2.0\n### void Check_SafeStr(VALUE v)\n\n古い API です。\n\#@end\n",
+      convert(rrd)
+  end
+
+  def test_roundtrip_composite
+    rrd = <<~RRD
+      --- MACRO int BUILTIN_TYPE(VALUE obj)
+
+      obj の構造体型 ID を返します。
+      [[f:SPECIAL_CONST_P]](obj) が真のオブジェクトに対して使うと落ちます。
+
+      : argcが0以上の時
+        その関数がとる引数の数を意味します。
+
+        * 必須引数の数 (省略可能な引数があるなら省略不可)
+        * 省略可能な引数の数 (ゼロ個ならば省略可)
+
+      --- VALUE rb_ary_new2(long len)
+
+      使用例
+
+          VALUE ary;
+          ary = rb_ary_new2(len);
+    RRD
+    assert_equal rrd, roundtrip(rrd)
+  end
+
+  def test_body_text_starting_with_require_is_not_metadata
+    # eval.c.rd の rb_require 型: 「require の C 版です。」のような本文が
+    # フラグメント先頭に来ても library メタデータと誤認しない
+    # （capi には require/category ヘッダは存在しない）
+    rrd = "\nrequire の C 版です。feature「fname」をロードします。\n"
+    md = BitClust::CapiConverter.convert(rrd)
+    assert_equal rrd, md
+    assert_equal rrd, roundtrip(rrd)
+  end
+end