bitclust-core 1.6.1 → 1.8.0

data/test/test_mdcompiler.rb

@@ -23,7 +23,7 @@ class TestMDCompiler < Test::Unit::TestCase
     @rd = BitClust::RDCompiler.new(@u, 1, { :database => @db })
   end
 
-  def compile_method(compiler, src)
+  def compile_method(compiler, src, rbs_signature_overloads: nil)
     method_entry = Object.new
     mock(method_entry).source { src }
     mock(method_entry).index_id.any_times { "dummy" }
@@ -32,6 +32,7 @@ class TestMDCompiler < Test::Unit::TestCase
     mock(method_entry).names.any_times { [] }
     mock(method_entry).since_map.any_times { {} }
     mock(method_entry).until_map.any_times { {} }
+    mock(method_entry).rbs_signature_overloads.any_times { rbs_signature_overloads }
     compiler.compile_method(method_entry)
   end
 
@@ -58,6 +59,47 @@ class TestMDCompiler < Test::Unit::TestCase
 
   # ---- メソッドエントリ ----
 
+  # RBS シグネチャ表示: MDCompiler も entry_chunk をオーバーライドしている
+  # ので、rd 経路と同じ位置(説明 <dd> の直前)に同じ <dt> が出ること
+  def test_rbs_signatures_dt_matches_rd_output
+    rd_src = "--- index(val) -> Integer\n\n説明\n"
+    overloads = [{'segments' => [['t', '() -> void']]}]
+    md_src = BitClust::RRDToMarkdown.convert(rd_src)
+    rd_html = compile_method(@rd, rd_src, rbs_signature_overloads: overloads)
+    md_html = compile_method(@md, md_src, rbs_signature_overloads: overloads)
+    assert_include md_html,
+      '<dt class="rbs-signature"><code>() &rarr; void</code></dt>'
+    assert_equal rd_html, md_html
+  end
+
+  # チャンク振り分けは md 側のシグネチャ行(### def ...)でも rd と同じに
+  # 動くこと(MDCompiler は行を "--- " に正規化してから照合する)
+  def test_rbs_signatures_chunk_assignment_matches_rd_output
+    rd_src = <<~RD
+      --- index(sub) -> Integer | nil
+
+      文字列で探す。
+
+      --- index(pattern) {|s| ... } -> Integer | nil
+
+      ブロックで探す。
+    RD
+    overloads = [
+      {'segments' => [['t', '(String sub) -> Integer?']],
+       'params' => ['sub'], 'arity' => [1, 1]},
+      {'segments' => [['t', '(Regexp pattern) { (String) -> bool } -> Integer?']],
+       'params' => ['pattern'], 'arity' => [1, 1], 'block' => 'req'},
+    ]
+    md_src = BitClust::RRDToMarkdown.convert(rd_src)
+    rd_html = compile_method(@rd, rd_src, rbs_signature_overloads: overloads)
+    md_html = compile_method(@md, md_src, rbs_signature_overloads: overloads)
+    assert_match(
+      %r!<code>index\(pattern\).*?</dt>\n<dt class="rbs-signature"><code>\(Regexp pattern\) \{ \(String\) &rarr; bool \} &rarr; Integer\?</code></dt>\n<dd!m,
+      md_html)
+    assert_equal 2, md_html.scan('rbs-signature').size
+    assert_equal rd_html, md_html
+  end
+
   def test_method_signature_and_paragraph
     assert_equivalent_method <<~RD
       --- index(val) -> Integer
@@ -752,10 +794,10 @@ class TestMDCompiler < Test::Unit::TestCase
   def test_gfm_table_alignment
     md = "# T\n\n| a | b | c |\n|:--|:-:|--:|\n| 1 | 2 | 3 |\n"
     html = gfm_compiler.compile(md)
-    assert_include html, '<th align="left">a</th>'
-    assert_include html, '<th align="center">b</th>'
-    assert_include html, '<th align="right">c</th>'
-    assert_include html, '<td align="right">3</td>'
+    assert_include html, '<th style="text-align:left">a</th>'
+    assert_include html, '<th style="text-align:center">b</th>'
+    assert_include html, '<th style="text-align:right">c</th>'
+    assert_include html, '<td style="text-align:right">3</td>'
   end
 
   def test_gfm_pipe_line_without_delimiter_is_paragraph

data/test/test_mdparser.rb

@@ -82,7 +82,7 @@ class TestMDParser < Test::Unit::TestCase
 
       ## Class Methods
 
-      ### def new -> Comparable
+      ### def Comparable.new -> Comparable
 
       生成。
     MD
@@ -181,7 +181,7 @@ class TestMDParser < Test::Unit::TestCase
   end
 
   def test_unsupported_signature_forms_are_rejected
-    # RBS 形式（MARKUP_SPEC §3.2 で構想）と self. プレフィクスは描画側
+    # RBS 形式（MARKUP_SPEC §3.2 で構想）は描画側
     # （MethodSignature.parse）が受理できないため、パース時に拒否する
     base = <<~MD
       ---
@@ -197,12 +197,83 @@ class TestMDParser < Test::Unit::TestCase
 
       説明。
     MD
-    ['### def each: () { (untyped) -> void } -> self',
-     '### def self.new(size = 0) -> Foo'].each do |sig|
+    ['### def each: () { (untyped) -> void } -> self'].each do |sig|
       assert_raise(BitClust::ParseError, sig) { parse_md(base % sig) }
     end
   end
 
+  def test_self_and_class_name_prefixed_signatures
+    # クラスメソッドは `def self.name` / `def Klass.name` 形式でも書ける。
+    # どちらも singleton method として登録され、名前にプレフィクスは含まない
+    md = <<~MD
+      ---
+      library: _builtin
+      ---
+      # class Foo < Object
+
+      テスト。
+
+      ## Class Methods
+
+      ### def self.build(x) -> Foo
+
+      self. 形式。
+
+      ### def Foo.create(x) -> Foo
+
+      Klass. 形式。
+    MD
+    _, lib = parse_md(md)
+    entries = lib.classes.first.entries
+    assert_equal [["build"], ["create"]], entries.map(&:names)
+    assert_equal [:singleton_method, :singleton_method], entries.map(&:type)
+    # source には書かれたままの md が入る
+    assert_include entries[0].source, "### def self.build(x) -> Foo"
+  end
+
+  def test_main_prefixed_signature_on_object_page
+    # object main のページでは main. プレフィクスで特異メソッドを書ける
+    # （main は fatal・ARGF.class と同様に文法上クラス名として扱われる）
+    md = <<~MD
+      ---
+      library: _builtin
+      ---
+      # object main
+
+      テスト。
+
+      ## Class Methods
+
+      ### def main.include(*modules) -> self
+
+      main. 形式。
+    MD
+    _, lib = parse_md(md)
+    entries = lib.classes.first.entries
+    assert_equal [["include"]], entries.map(&:names)
+    assert_equal [:singleton_method], entries.map(&:type)
+  end
+
+  def test_self_prefixed_signature_in_instance_methods_section_is_rejected
+    # self. は singleton 確定なので Instance Methods セクションとは矛盾する
+    md = <<~MD
+      ---
+      library: _builtin
+      ---
+      # class Foo < Object
+
+      テスト。
+
+      ## Instance Methods
+
+      ### def self.bar -> nil
+
+      矛盾。
+    MD
+    error = assert_raise(BitClust::ParseError) { parse_md(md) }
+    assert_include error.message, "signature crash"
+  end
+
   def test_library_file_with_category
     md = <<~MD
       ---
@@ -341,6 +412,45 @@ class TestMDParser < Test::Unit::TestCase
     end
   end
 
+  def test_update_by_markdowntree_else_and_single_version_memberships
+    # bitclust#331: ゲート付き library リストの #@version V（単一版）と #@else。
+    # 3.2 だけ onlylib、それ以外は builtin に属する。版の比較は Gem::Version
+    # なので 3.2.0 の DB でも 3.2 と同じ版として扱う
+    require 'tmpdir'
+    Dir.mktmpdir do |root|
+      write = ->(rel, s) {
+        path = File.join(root, rel)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, s)
+      }
+      write.call('builtin.md', "---\ntype: library\n---\nbuiltin。\n")
+      write.call('onlylib.md', "---\ntype: library\n---\nonlylib。\n")
+      write.call('onlylib/Shared.md', <<~'MD')
+        ---
+        library:
+        #@version 3.2
+          - onlylib
+        #@else
+          - builtin
+        #@end
+        ---
+        # class Shared < Object
+
+        共有クラス。
+      MD
+
+      classes = ->(version) {
+        db = BitClust::MethodDatabase.dummy("version" => version)
+        db.update_by_markdowntree(root)
+        %w[builtin onlylib].map { |lib| db.fetch_library(lib).classes.map(&:name) }
+      }
+      assert_equal [[], %w[Shared]], classes.call("3.2")
+      assert_equal [[], %w[Shared]], classes.call("3.2.0")
+      assert_equal [%w[Shared], []], classes.call("3.4")
+      assert_equal [%w[Shared], []], classes.call("3.0")
+    end
+  end
+
   def test_update_by_markdowntree_parse_error_suggests_gem_update
     # manual/ が新しい bitclust を必要とする記法を含むとき、古い gem では
     # パースエラーになる。原因へたどり着けるよう gem 更新の案内を添える
@@ -570,4 +680,113 @@ class TestMDParser < Test::Unit::TestCase
     assert_equal('2.0.0', entry.since_of('fuga'))
     assert_equal('3.0', entry.since_of('fuga2'))
   end
+
+  def test_entry_style_bare_def_in_singleton_section_is_rejected
+    # MARKUP_SPEC §3.1: 特異メソッドはプレフィクス必須（def 行だけで
+    # メソッド種別が分かるようにする）
+    md = <<~MD
+      ---
+      library: _builtin
+      ---
+      # class Foo < Object
+
+      テスト。
+
+      ## Class Methods
+
+      ### def build(x) -> Foo
+
+      プレフィクスなし。
+    MD
+    error = assert_raise(BitClust::ParseError) { parse_md(md) }
+    assert_include error.message, "singleton method entry must be written as `def Foo.name' or `def self.name'"
+  end
+
+  def test_entry_style_keyword_section_mismatch_is_rejected
+    # rurema/doctree#3291 型の分類間違い: キーワードとセクションの不一致
+    base = <<~MD
+      ---
+      library: _builtin
+      ---
+      # class Foo < Object
+
+      テスト。
+
+      ## %s
+
+      ### %s
+
+      不一致。
+    MD
+    [
+      # Class Methods 配下の const（#3291 の実例）
+      ['Class Methods', 'const CURRENT -> Foo', "entry keyword `const' does not match this section (expected `def')"],
+      # Constants 配下の gvar
+      ['Constants', 'gvar $foo -> Foo', "entry keyword `gvar' does not match this section (expected `const')"],
+      # Instance Methods 配下の const
+      ['Instance Methods', 'const BAR -> Integer', "entry keyword `const' does not match this section (expected `def')"],
+    ].each do |section, sig, message|
+      error = assert_raise(BitClust::ParseError, "#{section} / #{sig}") do
+        parse_md(base % [section, sig])
+      end
+      assert_include error.message, message
+    end
+  end
+
+  def test_entry_style_module_functions_require_keyword
+    md = <<~MD
+      ---
+      library: _builtin
+      ---
+      # module Foo
+
+      テスト。
+
+      ## Module Functions
+
+      ### def bar -> nil
+
+      module_function キーワードなし。
+    MD
+    error = assert_raise(BitClust::ParseError) { parse_md(md) }
+    assert_include error.message, "entry keyword `def' does not match this section (expected `module_function def')"
+  end
+
+  def test_entry_style_accepts_consistent_forms
+    md = <<~MD
+      ---
+      library: _builtin
+      ---
+      # class Foo < Object
+
+      テスト。
+
+      ## Class Methods
+
+      ### def Foo.build(x) -> Foo
+
+      Klass 形式。
+
+      ### def self.create(x) -> Foo
+
+      self 形式。
+
+      ## Instance Methods
+
+      ### def each {|x| ... } -> self
+
+      素の def。
+
+      ## Constants
+
+      ### const BAR -> Integer
+
+      定数。
+    MD
+    _, lib = parse_md(md)
+    entries = lib.classes.first.entries
+    assert_equal [["build"], ["create"], ["each"], ["BAR"]], entries.map(&:names)
+    assert_equal [:singleton_method, :singleton_method, :instance_method, :constant],
+                 entries.map(&:type)
+  end
 end

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_methods_command.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'test/unit'
+require 'bitclust'
+require 'bitclust/subcommands/methods_command'
+
+class TestMethodsCommand < Test::Unit::TestCase
+  def setup
+    @cmd = BitClust::Subcommands::MethodsCommand.new
+  end
+
+  def test_needs_no_database
+    assert_false(@cmd.needs_database?)
+  end
+
+  def test_content_option_is_not_accepted
+    assert_raise(OptionParser::InvalidOption) do
+      @cmd.parse(['-c', 'Object'])
+    end
+  end
+
+  def test_ri_database_option_is_not_accepted
+    assert_raise(OptionParser::InvalidOption) do
+      @cmd.parse(['--ri-database=/tmp/ri', 'Object'])
+    end
+  end
+
+  def test_diff_and_ruby_options_are_kept
+    assert_nothing_raised do
+      @cmd.parse(['--ruby=3.4.8', '--diff=refm/api/src/_builtin/Object', 'Object'])
+    end
+  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_opensearchdescription_screen.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+require 'uri'
+require 'bitclust'
+require 'bitclust/screen'
+
+class TestOpenSearchDescriptionScreen < Test::Unit::TestCase
+  SRC = <<'HERE'
+= class Foo
+description
+HERE
+
+  def screen
+    _lib, db = BitClust::RRDParser.parse(SRC, 'testlib', {'version' => '3.4'})
+    datadir = File.expand_path('../data/bitclust', __dir__)
+    manager = BitClust::ScreenManager.new(
+      :templatedir => "#{datadir}/template",
+      :catalogdir => "#{datadir}/catalog",
+      :encoding => 'utf-8',
+      :default_encoding => 'utf-8',
+      :base_url => '',
+      :cgi_url => '/view',
+      :target_version => '3.4'
+    )
+    manager.opensearchdescription_screen(URI.parse('http://example.com/view/opensearchdescription'),
+                                         :database => db)
+  end
+
+  def test_body_is_bare_xml_without_html_layout
+    body = screen.body
+    assert_match(/\A<\?xml/, body)
+    assert_not_include(body, '<html')
+    assert_match(%r{\A<\?xml[^>]*\?>\s*<OpenSearchDescription\b.*</OpenSearchDescription>\s*\z}m, body)
+    assert_include(body, 'http://example.com/view/search')
+  end
+
+  def test_content_type_is_opensearch_xml
+    assert_equal 'application/opensearchdescription+xml; charset=utf-8', screen.content_type
+  end
+end

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_query_command.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'stringio'
+require 'tmpdir'
+require 'bitclust'
+require 'bitclust/subcommands/query_command'
+
+class TestQueryCommand < Test::Unit::TestCase
+  def run_query(script, capi: false)
+    Dir.mktmpdir do |dir|
+      cmd = BitClust::Subcommands::QueryCommand.new
+      cmd.parse([script])
+      out = StringIO.new
+      orig, $stdout = $stdout, out
+      begin
+        cmd.exec([script], {:prefix => dir, :capi => capi})
+      ensure
+        $stdout = orig
+      end
+      out.string
+    end
+  end
+
+  def test_db_is_available_to_the_script
+    assert_equal %Q("BitClust::MethodDatabase"\n), run_query('@db.class.name')
+  end
+
+  def test_capi_uses_function_database
+    assert_equal %Q("BitClust::FunctionDatabase"\n), run_query('@db.class.name', capi: true)
+  end
+end