bitclust-core 1.6.1 → 1.8.0

data/lib/bitclust/markdown_exporter.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require 'bitclust/nameutils'
+
+module BitClust
+
+  # statichtml の --markdown-output 用に、HTML の各ページと対になる Markdown を
+  # エントリの前処理済みソース(Markdown ツリー由来の md)から組み立てる。
+  # 参照記法(単一ブラケットの [m:...] 等と、参照 scheme を宛先にした
+  # ラベル付きリンク)は相対 .md リンクへ解決する。解決できない参照
+  # (未対応の種別・不正な指定)はそのまま残し、エラーにしない。
+  # コードスパンとコードフェンスの中は変換しない。
+  class MarkdownExporter
+
+    # クラスページの メソッド種別 → セクション見出し(doctree の md と同じ名称)
+    CLASS_SECTIONS = [
+      ["Class Methods",              :public,    :singleton_method],
+      ["Instance Methods",           :public,    :instance_method],
+      ["Private Class Methods",      :private,   :singleton_method],
+      ["Private Instance Methods",   :private,   :instance_method],
+      ["Protected Instance Methods", :protected, :instance_method],
+      ["Module Functions",           :public,    :module_function],
+      ["Constants",                  :public,    :constant],
+      ["Special Variables",          :public,    :special_variable],
+    ].freeze
+
+    def initialize(urlmapper, html_suffix)
+      @urlmapper = urlmapper
+      @html_suffix = html_suffix
+    end
+
+    def library_page(entry)
+      page("# library #{entry.name}", entry.source)
+    end
+
+    # クラスページは HTML と同じく本文+メソッドリンク一覧(本文は載せない)
+    def class_page(entry)
+      out = +""
+      CLASS_SECTIONS.each do |section, visibility, type|
+        methods = entry.entries.select { |m|
+          !m.undefined? && m.type == type && m.visibility == visibility
+        }
+        next if methods.empty?
+        out << "\n## #{section}\n\n"
+        methods.each do |m|
+          m.names.each do |name|
+            spec = m.klass.name + m.typemark + name
+            url = ref_url('m', spec)
+            out << (url ? "- [#{escape_label(name)}](#{url})\n" : "- #{escape_label(name)}\n")
+          end
+        end
+      end
+      page(class_heading(entry), entry.source, out)
+    end
+
+    def method_page(method_name, entries)
+      out = +"# #{method_name.sub('.#', '?.')}\n"
+      entries.each do |m|
+        body = m.source.strip
+        out << "\n" << convert_text(body) << "\n" unless body.empty?
+      end
+      out
+    end
+
+    def doc_page(entry)
+      page("# #{entry.title}", entry.source)
+    end
+
+    def function_page(entry)
+      page("# #{entry.name}", "### #{entry.header}\n#{entry.source}")
+    end
+
+    # 本文中の参照をコードスパン・コードフェンスを避けて相対 .md リンクへ
+    # 変換する
+    def convert_text(str)
+      out = +''
+      fence = nil
+      str.each_line do |line|
+        if fence
+          out << line
+          stripped = line.strip
+          fence = nil if stripped.match?(/\A`+\z/) && stripped.length >= (fence || 0)
+        elsif (m = /\A {0,3}(`{3,})/.match(line))
+          fence = (m[1] || raise).length
+          out << line
+        else
+          out << convert_line(line)
+        end
+      end
+      out
+    end
+
+    private
+
+    def page(heading, source, trailer = "")
+      out = +"#{heading}\n"
+      body = source.strip
+      out << "\n" << convert_text(body) << "\n" unless body.empty?
+      out << trailer
+      out
+    end
+
+    def class_heading(entry)
+      case entry.type
+      when :class
+        sc = entry.superclass
+        sc ? "# class #{entry.name} < #{sc.name}" : "# class #{entry.name}"
+      when :module
+        "# module #{entry.name}"
+      when :object
+        "# object #{entry.name}"
+      else
+        "# #{entry.name}"
+      end
+    end
+
+    def convert_line(line)
+      spans = [] #: Array[String]
+      converted = convert_refs(extract_code_spans(line, spans))
+      converted.gsub(/\x00(\d+)\x00/) { spans[($1 || raise).to_i] || raise }
+    end
+
+    # インラインコードスパン(CommonMark 6.1、N 連バッククォートの同長
+    # ペアリング)を書かれたままプレースホルダへ退避する
+    def extract_code_spans(str, saved)
+      result = +''
+      i = 0
+      len = str.length
+      while i < len
+        c = str[i] or raise
+        if c == '\\' && i + 1 < len
+          result << (str[i, 2] || raise)
+          i += 2
+          next
+        end
+        if c == '`'
+          run = 1
+          run += 1 while str[i + run] == '`'
+          close = find_code_span_close(str, i + run, run)
+          if close
+            saved << (str[i...(close + run)] || raise)
+            result << "\x00#{saved.size - 1}\x00"
+            i = close + run
+            next
+          end
+          result << ('`' * run)
+          i += run
+          next
+        end
+        result << c
+        i += 1
+      end
+      result
+    end
+
+    def find_code_span_close(str, from, run_len)
+      i = from
+      len = str.length
+      while i < len
+        case str[i]
+        when "\n"
+          return nil
+        when '`'
+          j = i
+          j += 1 while str[j] == '`'
+          return i if j - i == run_len
+          i = j
+        else
+          i += 1
+        end
+      end
+      nil
+    end
+
+    REF_SCHEME_RE = /\A([a-zA-Z][a-zA-Z-]*):(.*)\z/m
+
+    def convert_refs(str)
+      result = +''
+      i = 0
+      while i < str.length
+        if str[i] == '\\' && i + 1 < str.length
+          result << (str[i, 2] || raise)
+          i += 2
+          next
+        end
+        if str[i] == '['
+          close = matching_delimiter(str, i, '[', ']')
+          if close
+            if str[close + 1] == '(' &&
+               (dest_end = matching_delimiter(str, close + 1, '(', ')', space_ends: true)) &&
+               (dest = str[(close + 2)...dest_end])
+              # ラベル付きリンク [text](dest)
+              if (m = REF_SCHEME_RE.match(dest)) && (url = ref_url(m[1] || raise, m[2] || raise))
+                result << "[#{str[(i + 1)...close]}](#{url})"
+                i = dest_end + 1
+                next
+              end
+              if dest.start_with?('#') || dest.match?(%r{\Ahttps?://})
+                # 通常の Markdown リンクはそのまま(ラベル内は再解釈しない)
+                result << (str[i..dest_end] || raise)
+                i = dest_end + 1
+                next
+              end
+            end
+            # 単一ブラケット参照 [type:target]([[ は除外)
+            inner = str[(i + 1)...close] || raise
+            if str[i + 1] != '[' && (m = REF_SCHEME_RE.match(inner)) &&
+               (converted = bare_ref(m[1] || raise, m[2] || raise, inner))
+              result << converted
+              i = close + 1
+              next
+            end
+          end
+        end
+        result << (str[i] || raise)
+        i += 1
+      end
+      result
+    end
+
+    # open 位置の括弧に対応する閉じ括弧の位置(\ エスケープ対応・ネスト可)。
+    # space_ends: リンク宛先用。空白が現れたらリンクではない(nil)
+    def matching_delimiter(str, open, open_char, close_char, space_ends: false)
+      depth = 0
+      i = open
+      while i < str.length
+        c = str[i]
+        if c == '\\'
+          i += 1
+        elsif space_ends && c =~ /\s/
+          return nil
+        elsif c == open_char
+          depth += 1
+        elsif c == close_char
+          depth -= 1
+          return i if depth == 0
+        end
+        i += 1
+      end
+      nil
+    end
+
+    # 単一ブラケット参照 1 個を Markdown リンクにする。ラベルは書かれた
+    # ままの形(エスケープ込み)から type: を落としたもの
+    def bare_ref(type, arg, written)
+      label =
+        case type
+        when 'm', 'c', 'lib', 'd', 'f'
+          written.split(':', 2)[1]
+        when 'url'
+          arg
+        when 'ref'
+          case arg
+          when /\A(\w+):(.*)\#([-\w]+)\z/
+            "#{$2}##{$3}"
+          when /\A[-\w]+\z/
+            arg
+          end
+        end
+      return nil unless label
+      url = ref_url(type, arg)
+      return nil unless url
+      "[#{label}](#{url})"
+    end
+
+    # 参照 scheme の宛先 URL(.md への相対リンク)。解決できなければ nil
+    def ref_url(type, arg)
+      arg = unescape_md_brackets(arg)
+      case type
+      when 'm'
+        # md 表記の module function ?. は内部表記 .# に正規化して引く
+        md_suffix(@urlmapper.method_url(arg.sub('?.', '.#')))
+      when 'c'
+        md_suffix(@urlmapper.class_url(arg))
+      when 'lib'
+        md_suffix(@urlmapper.library_url(arg))
+      when 'd'
+        md_suffix(@urlmapper.document_url(arg))
+      when 'f'
+        md_suffix(@urlmapper.function_url(arg))
+      when 'url'
+        arg
+      when 'ref'
+        case arg
+        when /\A(\w+):(.*)\#([-\w]+)\z/
+          url = ref_url($1 || raise, $2 || raise)
+          url ? "#{url}##{$3}" : nil
+        when /\A[-\w]+\z/
+          "##{arg}"
+        end
+      end
+    rescue StandardError
+      nil
+    end
+
+    def md_suffix(html_url)
+      return html_url unless html_url.end_with?(@html_suffix)
+      "#{html_url[0, html_url.length - @html_suffix.length]}.md"
+    end
+
+    def unescape_md_brackets(str)
+      str.gsub(/\\([\[\]\\])/, '\1')
+    end
+
+    def escape_label(text)
+      text.gsub(/[\\\[\]]/) { "\\#{$&}" }
+    end
+
+  end
+
+end

data/lib/bitclust/markdown_tree.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'bitclust/exception'
+require 'bitclust/preprocessor'
+
 module BitClust
   # 新パイプラインのファイル発見（MARKUP_SPEC §1.1）。
   #
@@ -116,36 +119,45 @@ module BitClust
       if lines[0] =~ /\A---\s*\z/
         i = 1
         in_library_block = false
-        gate_stack = [] #: Array[[Symbol, String?]]
+        gate_stack = [] #: Array[list_gate]
         while i < lines.length && lines[i] !~ /\A---\s*\z/
           line = lines[i]
           if in_library_block
-            # 多重所属のゲート付きリスト（MARKUP_SPEC §1.2）。
+            # 多重所属のゲート付きリスト（MARKUP_SPEC §1.2.1）。
             # 項目は積まれているゲートをすべてまとって membership になる
             case line
             when /\A\s+- (\S+)/
-              m = { library: $1 }
-              gate_stack.each { |kind, ver| m[kind] = ver }
-              info[:memberships] << m
+              info[:memberships].concat gated_memberships($1 || raise, gate_stack)
+              i += 1; next
+            when /\A\#[@%]\#/   # 前処理コメント（Preprocessor と同じく無視）
+              i += 1; next
+            when /\A\#[@%]/
+              list_directive(line, gate_stack, path, i + 1)
+              i += 1; next
+            when /\A\s+\#[@%]/
+              # 列 0 でない #% 行は Preprocessor でも指令にならない（YAML の
+              # コメント扱い）。ゲートが無音で無視されないようエラーにする
+              raise ParseError, "#{path}:#{i + 1}: preprocessor directive must start at column 0: #{line.strip}"
+            when /\A\s+\#/   # YAML コメント
               i += 1; next
-            when /\A\#[@%]since\s+(\S+)/ then gate_stack.push([:since, $1]); i += 1; next
-            when /\A\#[@%]until\s+(\S+)/ then gate_stack.push([:until, $1]); i += 1; next
-            when /\A\#[@%]end\s*\z/ then gate_stack.pop; i += 1; next
             else
-              in_library_block = false  # ブロック終端。この行は通常キーとして処理
+              # ブロック終端。この行は通常キーとして処理
+              list_end(gate_stack, path, i + 1)
+              in_library_block = false
             end
           end
           case line
           when /\Atype:\s*library\s*\z/ then info[:library_file] = true
           when /\Aname:\s*(\S+)/ then info[:name] = $1
-          when /\Alibrary:\s*\z/ then in_library_block = true; gate_stack = [] #: Array[[Symbol, String?]]
-          when /\Alibrary:\s*(\S+)/ then info[:memberships] << { library: $1 }
+          when /\Alibrary:\s*\z/ then in_library_block = true; gate_stack = [] #: Array[list_gate]
+          when /\Alibrary:\s*(\S+)/ then info[:memberships] << { library: $1 || raise }
           when /\Asince:\s*"?([^"\s]+)"?/ then info[:since] = $1
           when /\Auntil:\s*"?([^"\s]+)"?/ then info[:until] = $1
           when RELATION_KEY_RE then info[:front_matter_relations] = true
           end
           i += 1
         end
+        list_end(gate_stack, path, i + 1) if in_library_block
         i += 1
       end
       info[:library] = info[:memberships].dig(0, :library)
@@ -190,6 +202,101 @@ module BitClust
       info
     end
 
+    # --- front matter ゲート付きリストのディレクティブ ---
+    # 本文側 Preprocessor と同じ集合のうち #%since/#%until/#%version/#%else/#%end
+    # を解釈する。#%if（任意の条件式）は非対応。解釈できない行は無音で
+    # リストを打ち切らず ParseError にする（本文側の unknown directive と同じ扱い）。
+    #
+    # ゲート1段は clause の選言。clause は since（以上）/until（未満）/
+    # version（その版のみ）/except（その版以外）の交差で、#%else は直前ゲートの
+    # 補集合（#%version A...B なら「A 未満」または「B 以上」の 2 clause）
+
+    def list_directive(line, stack, path, lineno)
+      err = ->(msg) { raise ParseError, "#{path}:#{lineno}: #{msg}: #{line.strip}" }
+      case line
+      when /\A\#[@%](since|until)\b(.*)/
+        kind, raw = $1, $2 || raise
+        ver = version_literal(raw.strip) or err.("wrong conditional expr")
+        clause = kind == 'since' ? { since: ver } : { until: ver } #: gate_clause
+        stack.push({ clauses: [clause], elsed: false })
+      when /\A\#[@%]version\b(.*)/
+        clause = version_range(($1 || raise).strip) or
+          err.("wrong version range (expected V / A...B / A... / ...B)")
+        stack.push({ clauses: [clause], elsed: false })
+      when /\A\#[@%]if\b/
+        err.("#%if is not supported in front matter library list (use #%since/#%until/#%version/#%else)")
+      when /\A\#[@%]else\s*\z/
+        gate = stack.last or err.("no matching #%since/#%until/#%version")
+        err.("duplicate #%else") if gate[:elsed]
+        stack[-1] = { clauses: gate[:clauses].flat_map { |c| complement(c) }, elsed: true }
+      when /\A\#[@%]end\s*\z/
+        stack.pop or err.("no matching #%since/#%until/#%version")
+      else
+        err.("unknown preprocessor directive")
+      end
+    end
+
+    def list_end(stack, path, lineno)
+      return if stack.empty?
+      raise ParseError, "#{path}:#{lineno}: unterminated #%since/#%until/#%version in front matter library list"
+    end
+
+    VERSION_LITERAL = Preprocessor::VERSION_LITERAL
+
+    def version_literal(raw)
+      raw =~ /\A#{VERSION_LITERAL}\z/o ? ($1 || $2) : nil
+    end
+
+    # #%version の版範囲（Preprocessor#build_cond_by_range と同じ記法）
+    def version_range(raw)
+      case raw
+      when /\A#{VERSION_LITERAL}\.\.\.#{VERSION_LITERAL}\z/o
+        { since: $1 || $2 || raise, until: $3 || $4 || raise }
+      when /\A#{VERSION_LITERAL}\.\.\.\z/o then { since: $1 || $2 || raise }
+      when /\A\.\.\.#{VERSION_LITERAL}\z/o then { until: $1 || $2 || raise }
+      when /\A#{VERSION_LITERAL}\z/o then { version: $1 || $2 || raise }
+      end
+    end
+
+    def complement(clause)
+      return [{ except: [clause[:version] || raise] }] if clause[:version]
+      alts = [] #: Array[gate_clause]
+      alts << { until: clause[:since] || raise } if clause[:since]
+      alts << { since: clause[:until] || raise } if clause[:until]
+      alts
+    end
+
+    # 積まれた全ゲートの交差。各段が選言なので組合せごとに1つの membership
+    # （矛盾する組合せ = 異なる単一版どうしは捨てる）
+    def gated_memberships(library, stack)
+      seed = [{}] #: Array[gate_clause]
+      combos = stack.inject(seed) { |acc, gate|
+        acc.product(gate[:clauses]).filter_map { |a, b| intersect(a, b) }
+      }
+      combos.map { |c|
+        m = { library: library } #: membership
+        m[:since] = c[:since] || raise if c[:since]
+        m[:until] = c[:until] || raise if c[:until]
+        m[:version] = c[:version] || raise if c[:version]
+        m[:except] = c[:except] || raise if c[:except]
+        m
+      }
+    end
+
+    def intersect(a, b)
+      r = {} #: gate_clause
+      sinces = [a[:since], b[:since]].compact
+      r[:since] = sinces.max_by { |v| Gem::Version.new(v) } || raise unless sinces.empty?
+      untils = [a[:until], b[:until]].compact
+      r[:until] = untils.min_by { |v| Gem::Version.new(v) } || raise unless untils.empty?
+      versions = [a[:version], b[:version]].compact.uniq
+      return nil if versions.size > 1
+      r[:version] = versions.first if versions.size == 1
+      excepts = (a[:except] || []) + (b[:except] || [])
+      r[:except] = excepts.uniq unless excepts.empty?
+      r
+    end
+
     # 大文字小文字のみが異なる名前は macOS/Windows の case-insensitive FS で
     # チェックアウト不能になるため、衝突を警告する（途中のディレクトリ名も見る）
     def warn_case_collisions(files)

data/lib/bitclust/mdcompiler.rb

@@ -126,6 +126,12 @@ module BitClust
           break
         end
       end
+      # RBS シグネチャは見出し <dt> 群の直後・説明 <dd> の直前に、この
+      # チャンクへ振り分けられたぶんだけ <dt> 行として出す(rd 側
+      # entry_chunk と同じ。rbs_sig property が無ければ何も出ない)
+      if (rbs_dts = rbs_signature_dts_for_chunk())
+        @out.puts rbs_dts
+      end
       @out.puts %Q(<dd class="#{@type.to_s}-description">)
       undef_message if attrs.include?('undef')
       while @f.next?
@@ -184,6 +190,12 @@ module BitClust
       super(sig_line.sub(signature_re, '--- '), first)
     end
 
+    # RBS シグネチャのチャンク走査（RbsSignatures）用: md のシグネチャ行を
+    # rd の正規形にして返す（method_signature と同じ変換）
+    def rbs_signature_line(line)
+      line.sub(signature_re, '--- ') if signature_re =~ line
+    end
+
     def headline(line)
       hashes = line[/\A#+/] || raise
       label = line.sub(/\A#+\s*/, '').strip
@@ -405,11 +417,13 @@ module BitClust
       }
     end
 
+    # 列揃えはインラインスタイルで出す。align 属性は presentational hint
+    # としての扱いになり、テーマ CSS の text-align 指定に負けて効かない
     def table_row(row, tag, aligns)
       cells = split_table_row(row)
       string '<tr>'
       cells.each_with_index do |cell, i|
-        align = aligns[i] ? %Q( align="#{aligns[i]}") : ''
+        align = aligns[i] ? %Q( style="text-align:#{aligns[i]}") : ''
         string "<#{tag}#{align}>#{compile_text(cell)}</#{tag}>"
       end
       line '</tr>'

data/lib/bitclust/mdparser.rb

@@ -314,11 +314,50 @@ module BitClust
       src = (header + body).join('')
       src.location = sig_lines[0].location
       sigs = sig_lines.map {|line| method_signature(line) }
+      # キーワード不一致はより具体的なメッセージになるよう
+      # check_chunk_signatures(signature crash)より先に検査する
+      check_entry_style(sig_lines, sigs)
       mainsig = check_chunk_signatures(sigs, sig_lines[0])
       names = sigs.map {|s| s.name }.compact.uniq.sort
       Chunk.new(mainsig, names, src)
     end
 
+    # セクション（h2）の型ごとに期待するエントリキーワード。
+    # キーワードは型決定には使われない（型はセクションで決まる）ため、
+    # 食い違ったまま書けてしまう分類間違い（rurema/doctree#3291 の
+    # 「Class Methods 配下の const」等）をパース時に検出する
+    ENTRY_KEYWORD_RE = /\A### (module_function def|def|const|gvar) /
+    EXPECTED_ENTRY_KEYWORD = {
+      '#'  => 'def',
+      '.'  => 'def',
+      '.#' => 'module_function def',
+      '::' => 'const',
+      '$'  => 'gvar',
+    }.freeze
+
+    # エントリの書式とセクションの一致検査。
+    # - キーワードがセクションの種別と一致すること
+    # - 特異メソッドは `def Klass.name` / `def self.name` のプレフィクス
+    #   必須（MARKUP_SPEC §3.1。def 行だけでメソッド種別が分かるようにする）
+    def check_entry_style(sig_lines, sigs)
+      cxt = @context.signature
+      return unless cxt && cxt.type
+      expected = EXPECTED_ENTRY_KEYWORD[cxt.type] or return
+      sig_lines.zip(sigs).each do |line, sig|
+        keyword = (line || raise)[ENTRY_KEYWORD_RE, 1]
+        unless keyword == expected
+          parse_error "entry keyword `#{keyword}' does not match this section (expected `#{expected}')", line
+        end
+        if cxt.type == '.' && sig && sig.type.nil?
+          parse_error "singleton method entry must be written as `def #{cxt.klass || 'Klass'}.name' or `def self.name'", line
+        end
+      end
+    end
+
+    # `def self.name` 形式。type は singleton に確定し、klass は
+    # 見出しコンテキスト（H1/H2）から補完される
+    SELF_SIGNATURE = /\A---\s*self\.(#{METHOD_NAME_RE})/
+
     # md シグネチャ行を rd 形式（--- ...）へ落とし、既存の
     # Signature パースを継承する。エラー時は元の行を報告する
     def method_signature(line)
@@ -326,12 +365,14 @@ module BitClust
       begin
         # 描画（MethodSignature.parse）が受理できないシグネチャは
         # statichtml まで進んでから落ちる（か、誤った名前で DB に入る）ので
-        # パース時に拒否する。RBS 形式（def name:）や self. プレフィクスが該当
+        # パース時に拒否する。RBS 形式（def name:）が該当
         MethodSignature.parse(rd_line)
       rescue ParseError
         parse_error "unsupported method signature", line
       end
       case
+      when m = SELF_SIGNATURE.match(rd_line)
+        Signature.new(nil, '.', m[1])
       when m = SIGNATURE.match(rd_line)
         klass, typemark_, name = m.captures
         typemark = _ = typemark_

data/lib/bitclust/methoddatabase.rb

@@ -186,7 +186,7 @@ module BitClust
         # membership を持つライブラリだけがメンバーとして取り込む
         members = tree.entities.select { |_, e|
           e[:memberships].any? { |m|
-            m[:library] == libname && md_version_covers?(version, m[:since], m[:until])
+            m[:library] == libname && md_gate_covers?(version, m)
           }
         }
         sorted = members.keys.sort_by { |path|
@@ -211,12 +211,25 @@ module BitClust
     # since は「その版以降」、until は「その版未満」（ブリッジの
     # #@since/#@until ラッパーと同じ意味論）
     def md_version_covers?(version, since_version, until_version)
+      gate = {} #: MarkdownTree::gate_clause
+      gate[:since] = since_version if since_version
+      gate[:until] = until_version if until_version
+      md_gate_covers?(version, gate)
+    end
+    private :md_version_covers?
+
+    # membership のゲート（MarkdownTree の since/until/version/except）がこの版を
+    # 含むか。version は「その版のみ」、except は「その版以外」（#%version V と
+    # その #%else）。比較は Gem::Version なので 3.4 と 3.4.0 は同じ版
+    def md_gate_covers?(version, gate)
       v = Gem::Version.new(version)
-      return false if since_version && v < Gem::Version.new(since_version)
-      return false if until_version && v >= Gem::Version.new(until_version)
+      return false if (s = gate[:since]) && v < Gem::Version.new(s)
+      return false if (u = gate[:until]) && v >= Gem::Version.new(u)
+      return false if (only = gate[:version]) && v != Gem::Version.new(only)
+      return false if (except = gate[:except]) && except.any? { |x| v == Gem::Version.new(x) }
       true
     end
-    private :md_version_covers?
+    private :md_gate_covers?
 
     def refs
       @refs ||= RefsDatabase.load(realpath('refs'))

data/lib/bitclust/methodentry.rb

@@ -10,6 +10,7 @@
 
 require 'bitclust/entry'
 require 'bitclust/exception'
+require 'json'
 
 module BitClust
 
@@ -118,6 +119,11 @@ module BitClust
       # 現れない前提。fill_since/fill_until で検査する）
       property :since_by_name,   '[String]'
       property :until_by_name,   '[String]'
+      # RBS シグネチャ表示。オーバーロード配列(RbsSigImporter 参照)の
+      # JSON 1 行を持つ。型シグネチャは ',' を普通に含むので [String] 型
+      # (',' 区切り)は使えない。JSON は改行を含まず、property ファイルの
+      # key=value 1 行形式は値中の '=' を許す(split('=', 2))ので安全
+      property :rbs_sig,         'String'
     }
 
     def inspect
@@ -166,6 +172,24 @@ module BitClust
       "#{methodid2typechar(@id)}_#{encodename_fs(name).gsub(/=/, '--')}".upcase
     end
 
+    # rbs_sig(JSON)をオーバーロード配列に戻す。現行形式は
+    # {"overloads":[{"segments":..., "params":..., "arity":..., "block":...}]}
+    # で、セグメント行列そのものの配列だった旧形式の DB は segments だけの
+    # オーバーロード列に読み替える。property が無い古い DB(nil)・
+    # シグネチャ無しで保存された空文字列・未保存エントリの "(uninitialized)"
+    # センチネル・壊れた JSON はすべて nil(= 表示しない)に落として
+    # 描画側を守る
+    def rbs_signature_overloads
+      json = rbs_sig()
+      return nil unless json && (json.start_with?('{') || json.start_with?('['))
+      data = JSON.parse(json)
+      overloads = data.is_a?(Hash) ? data['overloads']
+                                   : data.map {|segments| {'segments' => segments} }
+      overloads.is_a?(Array) && !overloads.empty? ? overloads : nil
+    rescue JSON::ParserError
+      nil
+    end
+
     def labels
       c, t, _m, _lib = methodid2specparts(@id)
       names().map {|name| "#{c}#{t}#{name}" }

data/lib/bitclust/methodsignature.rb

@@ -21,7 +21,7 @@ module BitClust
 
     METHOD_SIGNATURE_RE = /\A
         --- \s*
-          (?: (?:#{CLASS_PATH_RE} #{TYPEMARK_RE})? (#{METHOD_NAME_RE})
+          (?: (?:#{CLASS_PATH_RE} #{TYPEMARK_RE} | self\.)? (#{METHOD_NAME_RE})
           | (#{GVAR_RE})
           )                 \s*         # method name ($1) or gvar name ($2)
         (?: \( (.*?) \)     \s* )?      # parameters (optional); $3=parameter_list