bitclust-core 1.6.0 → 1.7.0

data/lib/bitclust/preprocessor.rb

@@ -159,6 +159,7 @@ module BitClust
     # 版範囲の省略記法(#285): #%version A...B は半開区間 [A, B)。
     # Ruby の終端排他 Range リテラルに合わせて3点ドット(.. は終端を含むと
     # 誤解しやすいため受け付けない)。A... は A 以上、...B は B 未満。
+    # ドットなしの単一版 V はその版のみ(version == "V")。
     # 版はダブルクォート付きでもよい
     VERSION_LITERAL = /"(\d+(?:\.\d+)*)"|(\d+(?:\.\d+)*)/
     def build_cond_by_range(line)
@@ -170,8 +171,10 @@ module BitClust
         %Q(version >= "#{$1 || $2}")
       when /\A\.\.\.#{VERSION_LITERAL}\z/o
         %Q(version < "#{$1 || $2}")
+      when /\A#{VERSION_LITERAL}\z/o
+        %Q(version == "#{$1 || $2}")
       else
-        parse_error "wrong version range (expected A...B / A... / ...B)", line
+        parse_error "wrong version range (expected V / A...B / A... / ...B)", line
       end
     end
 

data/lib/bitclust/rbs_overload_matcher.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+#
+# bitclust/rbs_overload_matcher.rb
+#
+# RBS のオーバーロードを、引数パターンごとに分かれた説明チャンク
+# (Array.new / Array#[] のように同名メソッドの `---` 見出し+説明の組が
+# 複数あるもの)へ振り分ける。RBS の引数名は rdoc の call-seq 由来で
+# rurema のシグネチャの引数名とよく一致するため、
+# 「ブロック有無 → 引数名の一致 → アリティ範囲の重なり」のスコアで
+# 最も近いチャンクを選ぶ。1:1 対応は原理的に保証されない
+# (RBS の () と (int size, ?Elem val) が rurema では同一チャンク等)ので、
+# 多対 1 の割り当てとし、確実な対応が取れないオーバーロードは先頭チャンクに
+# 寄せる(どのチャンクにも重複しては出さない)。
+#
+# オーバーロードのメタ情報(params/arity/block)は RbsSigImporter が
+# rbs_sig property の JSON に書き込んだものをそのまま(文字列キーの Hash で)
+# 受け取る。チャンク側は正規化済みシグネチャ行("--- " 始まり)を
+# MethodSignature.parse で解析する。
+
+require 'bitclust/methodsignature'
+require 'bitclust/exception'
+
+module BitClust
+
+  module RbsOverloadMatcher
+
+    module_function
+
+    # overloads: rbs_sig JSON の overloads 配列(文字列キー Hash の配列)
+    # chunks: チャンクごとの正規化済みシグネチャ行("--- " 始まり)の配列
+    # 返り値: チャンクごとのオーバーロード添字の配列(chunks と同じ長さ)
+    def assign(overloads, chunks)
+      result = Array.new(chunks.size) { [] } #: Array[Array[Integer]]
+      return result if chunks.empty?
+      if chunks.size == 1
+        result[0] = (0...overloads.size).to_a
+        return result
+      end
+      features = chunks.map {|lines| chunk_features(lines) }
+      overloads.each_index do |i|
+        ov = overload_features(overloads[i])
+        result[ov ? best_chunk(ov, features) : 0] << i
+      end
+      result
+    end
+
+    # チャンクのシグネチャ行群から照合用の特徴を合算する。
+    # 1 行も解析できなければ nil(振り分け先にしない)
+    def chunk_features(sig_lines)
+      names = [] #: Array[String]
+      min = nil #: Integer?
+      max = 0 #: Integer?
+      block = false
+      parsed = false
+      sig_lines.each do |line|
+        begin
+          sig = MethodSignature.parse(line)
+        rescue ParseError
+          next
+        end
+        parsed = true
+        block ||= !sig.block.nil?
+        pmin, pmax, pnames, pblock = params_features(sig.params)
+        block ||= pblock
+        names.concat(pnames)
+        min = pmin if min.nil? || pmin < min
+        max = (max && pmax) ? [max, pmax].max : nil
+      end
+      return nil unless parsed
+      { names: names, min: min || 0, max: max, block: block }
+    end
+
+    # rbs_sig JSON のオーバーロード 1 個からスコア用の特徴を取り出す。
+    # メタ情報が無いもの(#322 以前の旧形式・attr・(?) 型)は nil
+    def overload_features(overload)
+      arity = overload['arity']
+      params = overload['params']
+      block = overload['block']
+      return nil unless arity || params || block
+      { names: params || [],
+        min: arity && arity[0],
+        max: arity && arity[1],
+        block: block }
+    end
+
+    # ---- 以下は実装詳細(module_function なので呼べてしまうが非公開扱い) ----
+
+    def best_chunk(overload, features)
+      best = 0
+      best_score = nil #: Integer?
+      features.each_with_index do |chunk, i|
+        next unless chunk
+        s = score(overload, chunk)
+        if best_score.nil? || s > best_score
+          best = i
+          best_score = s
+        end
+      end
+      best
+    end
+
+    # ブロックの一致(または矛盾)を最優先に、引数名の一致 > アリティ範囲の
+    # 重なりで加点する。同点は先頭チャンク優先(best_chunk が > で更新)
+    def score(overload, chunk)
+      s = 0
+      case overload[:block]
+      when 'req'
+        s += chunk[:block] ? 2 : -3
+      when 'opt'
+        s += 1
+      else
+        s += chunk[:block] ? -3 : 2
+      end
+      s += 2 * (overload[:names] & chunk[:names]).size
+      if overload[:min] && chunk[:min]
+        omax = overload[:max] || Float::INFINITY
+        cmax = chunk[:max] || Float::INFINITY
+        s += (overload[:min] <= cmax && chunk[:min] <= omax) ? 1 : -2
+      end
+      s
+    end
+
+    # シグネチャの引数リスト文字列 → [最小アリティ, 最大アリティ(nil=無制限),
+    # 引数名(位置引数+キーワード名。**kwrest 名も含む), ブロック有無(&引数)]
+    def params_features(params)
+      return [0, 0, [], false] if params.nil? || params.strip.empty?
+      required = 0
+      optional = 0
+      rest = false
+      block = false
+      names = [] #: Array[String]
+      split_top_level(params).each do |token|
+        token = token.strip
+        next if token.empty?
+        name = token[/[A-Za-z_]\w*/]
+        case token
+        when /\A&/
+          block = true
+        when /\A\*\*/
+          names << name if name
+        when /\A\*/, '...'
+          rest = true
+          names << name if name
+        when /\A[A-Za-z_]\w*:/
+          names << (name || raise)
+        when /=/
+          optional += 1
+          names << name if name
+        else
+          required += 1
+          names << name if name
+        end
+      end
+      [required, rest ? nil : required + optional, names, block]
+    end
+
+    # 括弧((), [], {})のネストを無視して最上位の ',' で分割する
+    # (デフォルト値の中の ',' で切らないため)
+    def split_top_level(str)
+      tokens = [+''] #: Array[String]
+      depth = 0
+      str.each_char do |c|
+        case c
+        when '(', '[', '{' then depth += 1
+        when ')', ']', '}' then depth -= 1
+        when ','
+          if depth == 0
+            tokens << +''
+            next
+          end
+        end
+        tokens.last << c
+      end
+      tokens
+    end
+
+  end
+
+end

data/lib/bitclust/rbs_sig_importer.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+#
+# bitclust/rbs_sig_importer.rb
+#
+# RBS 型シグネチャ(.rbs)を読み込み、"Class#method"/"Class.method" キー →
+# オーバーロード配列の対応表を作って MethodEntry の rbs_sig property に
+# 書き込む(rbssig サブコマンドが DB 構築後に呼ぶ)。
+#
+# オーバーロードは Hash 1 個: "segments" = [種別, テキスト] の組の配列
+# (種別 "t" は素のテキスト、"c" はクラス/モジュール名で、描画側=
+# RbsSignatures が DB に存在するものだけリンク化する。テキストを連結すると
+# 元のシグネチャ文字列に戻る)に加え、説明チャンクへの振り分け
+# (RbsOverloadMatcher)用のメタ情報 "params"(引数名)・"arity"
+# ([最小, 最大|nil])・"block"("req"/"opt")を持つ。型名の位置は RBS
+# パーサの location で厳密に取る。rbs gem が必要なのは書き込み側のこの
+# ファイルだけで、描画側は property を読むだけで動く。
+
+require 'rbs'
+require 'json'
+require 'pathname'
+
+module BitClust
+
+  class RbsSigImporter
+
+    # core_root: ruby/rbs チェックアウトの core/(組み込みクラスの型)
+    # repository_root: 同 stdlib/(core_root を与えると rbs が stringio を
+    #                  暗黙に要求するので、core_root とセットで渡す)
+    # sig_dirs: 素の .rbs ディレクトリ(テスト・追加分)
+    def initialize(core_root: nil, repository_root: nil, sig_dirs: [])
+      @core_root = core_root
+      @repository_root = repository_root
+      @sig_dirs = sig_dirs
+      @signatures = nil
+    end
+
+    # "Class#method"/"Class.method" → オーバーロード配列
+    def signatures
+      @signatures ||= build_signatures
+    end
+
+    # bitclust の typechar('i'/'s'/'m')と名前の並び(別名)で対応表を引く。
+    # モジュール関数(m)は def self?. 由来の # キーを先に、new は
+    # Class.new → Class#initialize の順で引く。見つからなければ nil
+    def lookup(class_name, typechar, names)
+      names.each do |name|
+        case typechar
+        when 'i'
+          sig = signatures["#{class_name}##{name}"]
+        when 's'
+          sig = signatures["#{class_name}.#{name}"]
+          sig ||= signatures["#{class_name}#initialize"] if name == 'new'
+        when 'm'
+          sig = signatures["#{class_name}##{name}"] || signatures["#{class_name}.#{name}"]
+        else
+          return nil
+        end
+        return sig if sig
+      end
+      nil
+    end
+
+    # DB の全メソッドエントリに対応表を引き、ヒットしたものへ rbs_sig
+    # property(JSON 1 行)を書き込む。書き方は MethodSinceCalculator#apply と
+    # 同じ(変更があったエントリだけ save)
+    def apply(db)
+      stats = { entries_updated: 0, sigs_matched: 0, methods_missed: 0 } #: stats
+      db.classes.each do |c|
+        c.entries.each do |m|
+          next if m.kind == :undefined
+          next unless %w[i s m].include?(m.typechar)
+          overloads = lookup(c.name, m.typechar, m.names)
+          unless overloads
+            stats[:methods_missed] += 1
+            next
+          end
+          stats[:sigs_matched] += 1
+          json = JSON.generate({'overloads' => overloads})
+          next if m.rbs_sig == json
+          m.rbs_sig = json
+          m.save
+          stats[:entries_updated] += 1
+        end
+      end
+      stats
+    end
+
+    private
+
+    def build_signatures
+      env = load_environment
+      sigs = {} #: signatures
+      aliases = [] #: Array[[String, untyped]]
+      env.class_decls.each do |type_name, entry|
+        class_name = type_name.to_s.delete_prefix('::')
+        each_decl(entry) do |decl|
+          decl.members.each do |member|
+            case member
+            when RBS::AST::Members::MethodDefinition
+              overloads = member.overloads.map {|o| method_type_overload(o.method_type.to_s) }
+              method_keys(class_name, member.name, member.kind).each do |key|
+                sigs[key] ||= overloads
+              end
+            when RBS::AST::Members::AttrReader
+              sigs[attr_key(class_name, member, member.name)] ||= [attr_overload(member.type.to_s)]
+            when RBS::AST::Members::AttrWriter
+              sigs[attr_key(class_name, member, "#{member.name}=")] ||= [attr_overload(member.type.to_s)]
+            when RBS::AST::Members::AttrAccessor
+              overloads = [attr_overload(member.type.to_s)]
+              sigs[attr_key(class_name, member, member.name)] ||= overloads
+              sigs[attr_key(class_name, member, "#{member.name}=")] ||= overloads
+            when RBS::AST::Members::Alias
+              aliases << [class_name, member]
+            end
+          end
+        end
+      end
+      resolve_aliases(sigs, aliases)
+      sigs
+    end
+
+    def load_environment
+      repository = RBS::Repository.new(no_stdlib: true)
+      if (repository_root = @repository_root)
+        repository.add(Pathname(repository_root))
+      end
+      core_root = @core_root
+      loader = RBS::EnvironmentLoader.new(
+        core_root: core_root && Pathname(core_root),
+        repository: repository)
+      @sig_dirs.each {|dir| loader.add(path: Pathname(dir)) }
+      env = RBS::Environment.new
+      loader.load(env: env)
+      env
+    end
+
+    # rbs 3.x は MultiEntry#decls、rbs 4.x は entry.each_decl
+    def each_decl(entry, &block)
+      if entry.respond_to?(:each_decl)
+        entry.each_decl(&block)
+      else
+        entry.decls.each {|d| block.call(d.decl) }
+      end
+    end
+
+    # def self?.(kind :singleton_instance)は Class.name と Class#name の
+    # 両方を定義する(bitclust のモジュール関数に対応)ので両キーに登録する
+    def method_keys(class_name, name, kind)
+      case kind
+      when :singleton
+        ["#{class_name}.#{name}"]
+      when :singleton_instance
+        ["#{class_name}.#{name}", "#{class_name}##{name}"]
+      else
+        ["#{class_name}##{name}"]
+      end
+    end
+
+    def attr_key(class_name, member, name)
+      member.kind == :singleton ? "#{class_name}.#{name}" : "#{class_name}##{name}"
+    end
+
+    # alias メンバーは元メソッドのシグネチャを共有する。alias が alias を
+    # 指すこともあるので、解決が進まなくなるまで繰り返す
+    def resolve_aliases(sigs, aliases)
+      until aliases.empty?
+        resolved, aliases = aliases.partition {|class_name, member|
+          sigs.key?(alias_key(class_name, member, member.old_name))
+        }
+        break if resolved.empty?
+        resolved.each do |class_name, member|
+          sigs[alias_key(class_name, member, member.new_name)] ||=
+            sigs[alias_key(class_name, member, member.old_name)]
+        end
+      end
+    end
+
+    def alias_key(class_name, member, name)
+      member.kind == :singleton ? "#{class_name}.#{name}" : "#{class_name}##{name}"
+    end
+
+    # メソッド型シグネチャ 1 行をオーバーロード(segments+メタ情報)にする
+    def method_type_overload(sig)
+      method_type = RBS::Parser.parse_method_type(sig, require_eof: true)
+      locs = [] #: Array[[String, Integer]]
+      collect_function_type_names(method_type.type, locs)
+      collect_function_type_names(method_type.block.type, locs) if method_type.block
+      overload = {'segments' => build_segments(sig, locs)} #: overload
+      add_overload_meta(overload, method_type)
+      overload
+    end
+
+    # attr 用: 型だけの文字列をオーバーロード(segments のみ)にする
+    def attr_overload(sig)
+      type = RBS::Parser.parse_type(sig, require_eof: true)
+      locs = [] #: Array[[String, Integer]]
+      collect_type_names(type, locs)
+      {'segments' => build_segments(sig, locs)}
+    end
+
+    # チャンク振り分け(RbsOverloadMatcher)用のメタ情報。引数名は位置引数
+    # (rest 含む)+キーワード名。アリティは位置引数の [最小, 最大] で
+    # rest があれば最大 nil(無制限)。`(?)`(UntypedFunction)には位置引数の
+    # 概念が無いので params/arity は付けない
+    def add_overload_meta(overload, method_type)
+      fun = method_type.type
+      if fun.respond_to?(:required_positionals)
+        names = [] #: Array[String]
+        positionals = fun.required_positionals + fun.optional_positionals +
+                      fun.trailing_positionals
+        positionals.each {|p| names << p.name.to_s if p.name }
+        rest = fun.rest_positionals
+        names << rest.name.to_s if rest && rest.name
+        fun.required_keywords.each_key {|k| names << k.to_s }
+        fun.optional_keywords.each_key {|k| names << k.to_s }
+        required = fun.required_positionals.size + fun.trailing_positionals.size
+        overload['params'] = names
+        overload['arity'] =
+          [required, rest ? nil : required + fun.optional_positionals.size]
+      end
+      if (block = method_type.block)
+        overload['block'] = block.required ? 'req' : 'opt'
+      end
+    end
+
+    def collect_function_type_names(fun, locs)
+      fun.each_param {|param| collect_type_names(param.type, locs) }
+      collect_type_names(fun.return_type, locs)
+    end
+
+    # クラス/モジュール参照(ClassInstance)の名前とその開始位置を集める。
+    # location の :name 子は "::String" のように名前空間プレフィクスを含む
+    # ので、end_pos から正規化名の長さを引いて名前本体の開始位置にする
+    # (:: はテキストセグメント側に残る)
+    def collect_type_names(type, locs)
+      case type
+      when RBS::Types::ClassInstance
+        name = type.name.to_s.delete_prefix('::')
+        if (loc = type.location)
+          name_loc = loc[:name] || loc
+          locs << [name, name_loc.end_pos - name.length]
+        end
+        type.args.each {|t| collect_type_names(t, locs) }
+      when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Tuple
+        type.types.each {|t| collect_type_names(t, locs) }
+      when RBS::Types::Optional
+        collect_type_names(type.type, locs)
+      when RBS::Types::Record
+        type.all_fields.each_value {|t, _required| collect_type_names(t, locs) }
+      when RBS::Types::Alias
+        # エイリアス型(string, hash 等)自体はクラスではないのでテキストの
+        # ままにするが、ジェネリクス引数の中のクラス名は拾う
+        type.args.each {|t| collect_type_names(t, locs) }
+      when RBS::Types::Proc
+        collect_function_type_names(type.type, locs)
+      end
+    end
+
+    def build_segments(sig, locs)
+      segments = [] #: segment_line
+      pos = 0
+      locs.sort_by {|_name, start| start }.each do |name, start|
+        # 位置が既出セグメントと重なる・実文字列と一致しない型は
+        # リンク化を諦めてテキストのまま残す(取りこぼしても表示は壊れない)
+        next if start < pos || sig[start, name.length] != name
+        segments << ['t', sig[pos...start] || raise] if start > pos
+        segments << ['c', name]
+        pos = start + name.length
+      end
+      segments << ['t', sig[pos..] || raise] if pos < sig.length
+      segments
+    end
+
+  end
+
+end

data/lib/bitclust/rbs_signatures.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+#
+# bitclust/rbs_signatures.rb
+#
+# メソッドエントリの RBS 型シグネチャ(rbs_sig property。RbsSigImporter が
+# DB 構築後に書き込む)を、シグネチャ見出し(<dt> 群)の直後・説明 <dd> の
+# 直前に 1 オーバーロード 1 行の <dt class="rbs-signature"> として描画する。
+# dd だと字下げで説明の一部に見え、pre だと theme/script.js が COPY ボタンを
+# 付けてしまうため、見出しと同じ dt+code の並びにする。property が無い
+# エントリでは何も出さないので、出力は従来とバイト一致のまま。
+#
+# Array.new / Array#[] のように引数パターンごとに説明チャンクが分かれる
+# メソッドでは、compile_method 冒頭でソースのシグネチャ行を走査して
+# チャンク列を作り、RbsOverloadMatcher で各オーバーロードを最も近い
+# チャンクへ振り分けておく(entry_chunk は自分の番のぶんだけ描画する)。
+#
+# RDCompiler(md は MDCompiler が継承)に include される。escape_html /
+# class_link(いずれも HTMLUtils)と @option[:database] にだけ依存し、
+# rbs gem は使わない(型名の位置は property 側で解決済み)。
+
+require 'bitclust/rbs_overload_matcher'
+
+module BitClust
+
+  module RbsSignatures
+
+    # 振り分け状態はメソッドのコンパイル専用(compile_method が
+    # prepare_rbs_signatures で作り直す)なので、他のコンパイルへ
+    # 持ち越さないよう setup(全コンパイル共通)からリセットする
+    def reset_rbs_signatures
+      @rbs_sig_by_chunk = nil
+      @rbs_chunk_index = 0
+    end
+
+    # compile_method 冒頭で呼ぶ。rbs_sig property があれば、source の
+    # シグネチャ行からチャンク列を作りオーバーロードを振り分けておく
+    def prepare_rbs_signatures(entry, source)
+      reset_rbs_signatures
+      overloads = entry.rbs_signature_overloads
+      return unless overloads
+      chunks = rbs_scan_signature_chunks(source)
+      if chunks.empty?
+        no_signatures = [] #: Array[String]
+        chunks = [no_signatures]
+      end
+      assignment = RbsOverloadMatcher.assign(overloads, chunks)
+      @rbs_sig_by_chunk = assignment.map {|indexes|
+        indexes.filter_map {|i| overloads[i]['segments'] }
+      }
+    end
+
+    # 現在のチャンクに割り当てられたオーバーロードの <dt> 行(改行連結)を
+    # 返し、チャンクカウンタを進める。メソッド以外のコンパイル
+    # (prepare が呼ばれていない)や割り当てが無いチャンクでは nil
+    def rbs_signature_dts_for_chunk
+      by_chunk = @rbs_sig_by_chunk
+      return nil unless by_chunk
+      lines = by_chunk[@rbs_chunk_index]
+      @rbs_chunk_index += 1
+      return nil unless lines && !lines.empty?
+      lines.map {|line|
+        html = line.map {|kind, text| rbs_segment_html(kind, text) }.join
+        %Q(<dt class="rbs-signature"><code>#{html}</code></dt>)
+      }.join("\n")
+    end
+
+    private
+
+    # entry_chunk と同じ規則でシグネチャ行の並び(チャンク)を数える。
+    # 属性行({: ...})はシグネチャの並びを切らない
+    def rbs_scan_signature_chunks(source)
+      chunks = [] #: Array[Array[String]]
+      current = nil #: Array[String]?
+      source.each_line do |line|
+        line = line.chomp
+        if (sig = rbs_signature_line(line))
+          if current
+            current << sig
+          else
+            fresh = [sig] #: Array[String]
+            current = fresh
+            chunks << fresh
+          end
+        elsif current && RDCompiler::METHOD_ATTRIBUTE_LINE_RE =~ line
+          # シグネチャの並びを継続
+        else
+          current = nil
+        end
+      end
+      chunks
+    end
+
+    # シグネチャ行なら "--- " 始まりの正規形にして返す(rd はそのまま)。
+    # md のシグネチャ行(### def ...)は MDCompiler がオーバーライドする
+    def rbs_signature_line(line)
+      line if line.start_with?('---')
+    end
+
+    def rbs_segment_html(kind, text)
+      if kind == 'c' and rbs_known_class?(text)
+        class_link(text)
+      else
+        escape_html(text).gsub('-&gt;', '&rarr;')
+      end
+    end
+
+    # DB に存在するクラス/モジュールだけリンク化する(自動生成リンクで
+    # 死リンクを作らないため。interface や型変数もここで自然に落ちる)。
+    # 同じページで同じ型名を何度も引くのでメモ化する
+    def rbs_known_class?(name)
+      @rbs_known_classes ||= {} #: Hash[String, bool]
+      @rbs_known_classes.fetch(name) {
+        db = @option[:database]
+        @rbs_known_classes[name] =
+          begin
+            db ? (db.fetch_class(name) && true) : false
+          rescue ClassNotFound
+            false
+          end
+      }
+    end
+
+  end
+
+end

data/lib/bitclust/rdcompiler.rb

@@ -15,6 +15,7 @@ require 'bitclust/textutils'
 require 'bitclust/messagecatalog'
 require 'bitclust/syntax_highlighter'
 require 'bitclust/version_badges'
+require 'bitclust/rbs_signatures'
 require 'rouge'
 require 'stringio'
 
@@ -27,6 +28,7 @@ module BitClust
     include TextUtils
     include Translatable
     include VersionBadges
+    include RbsSignatures
 
     def initialize(urlmapper, hlevel = 1, opt = {})
       @urlmapper = urlmapper
@@ -59,7 +61,9 @@ module BitClust
       @opt = opt
       @type = :method
       @method = m
-      setup(m.source, m) {
+      source = m.source
+      setup(source, m) {
+        prepare_rbs_signatures(m, source)
         entry
       }
     ensure
@@ -71,6 +75,7 @@ module BitClust
     def setup(src, entry = nil)
       @f = LineInput.new(StringIO.new(src), entry)
       @out = StringIO.new
+      reset_rbs_signatures
       yield
       @out.string
     end
@@ -135,6 +140,12 @@ module BitClust
         k, v = line.sub(/\A:/, '').split(':', 2)
         props[k&.strip] = v&.strip
       end if @type == :method
+      # RBS シグネチャは見出し <dt> 群の直後・説明 <dd> の直前に、この
+      # チャンクへ振り分けられたぶんだけ <dt> 行として出す(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?

data/lib/bitclust/runner.rb

@@ -62,6 +62,7 @@ Subcommands(for developers):
     classes     Display defined classes for all ruby.
     methods     Display defined methods for all ruby.
     methodsince Fill per-name since/until from a version ladder of DBs.
+    rbssig      Fill RBS type signatures into a 4.0+ DB from .rbs files.
     checklink   Report broken [[c:]]/[[m:]]/[[lib:]]/[[d:]]/[[f:]] links.
 
 Subcommands(for packagers):
@@ -110,6 +111,7 @@ Global Options:
         'classes'     => BitClust::Subcommands::ClassesCommand.new,
         'methods'     => BitClust::Subcommands::MethodsCommand.new,
         'methodsince' => BitClust::Subcommands::MethodsinceCommand.new,
+        'rbssig'      => BitClust::Subcommands::RbssigCommand.new,
         'checklink'   => BitClust::Subcommands::ChecklinkCommand.new,
       }
     end

data/lib/bitclust/screen.rb

@@ -403,6 +403,10 @@ module BitClust
       @urlmapper.search_url
     end
 
+    def document_url(name)
+      @urlmapper.document_url(name)
+    end
+
     def library_index_url
       @urlmapper.library_index_url
     end