bitclust-core 1.3.0 → 1.6.0

data/lib/bitclust/search_index_generator.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+#
+# bitclust/search_index_generator.rb
+#
+# Builds a client-side search index compatible with RDoc's Aliki theme.
+#
+# The index is a flat array of entries:
+#
+#   { name:, full_name:, type:, path: }
+#
+# Singleton methods and module functions (full_name holding a literal "."/
+# ".#"/"?.", e.g. "File.open", "Kernel.#open", "Kernel?.open" -- see #250)
+# additionally carry a +match_name+: full_name with "?." folded to ".#" and
+# every "." turned into "::". This mirrors the "." -> "::" rewrite the
+# vendored Aliki ranker's parseQuery() applies to the *query* text (RDoc's
+# own full_names use "::" for class methods), so search_init.js/search_page.js
+# can feature-detect-wrap computeScore() to compare like-for-like without
+# ever touching the displayed full_name. See bitclust#279.
+#
+#   { name:, full_name:, type:, path:, match_name: }
+#
+# serialized as a JavaScript assignment so it can be loaded over file://
+# without tripping the browser's CORS check on JSON files:
+#
+#   var search_data = { "index": [ ... ] };
+#
+# This mirrors the static layout produced by StatichtmlCommand so that the
+# +path+ of each entry points at the file actually generated there.
+#
+
+require 'json'
+require 'bitclust/nameutils'
+
+module BitClust
+  class SearchIndexGenerator
+    include NameUtils
+
+    # Maps BitClust method typenames onto the type vocabulary understood by
+    # Aliki's searcher (class/module/constant/class_method/instance_method).
+    # Module functions are callable as singleton methods, so they are indexed
+    # as class methods; special variables have no Aliki equivalent and keep
+    # their own label (the searcher only uses the type for ranking).
+    TYPENAME_TO_SEARCH_TYPE = {
+      singleton_method: 'class_method',
+      module_function:  'class_method',
+      instance_method:  'instance_method',
+      constant:         'constant',
+      special_variable: 'variable',
+    }.freeze
+
+    # Doc pages (manual/doc/**/*.md) are prose, so language keywords such as
+    # "defined?", "undef" or "alias" (see rurema/doctree#2352) are never
+    # indexed as a class/method/library. They do, however, live at their own
+    # {#id}-anchored heading within a doc page (e.g. spec/def.md's "defined?"
+    # section). Rather than hardcoding a keyword list, scan every doc page for
+    # ATX headings carrying an explicit {#id} anchor -- the same anchors
+    # [ref:d:...] cross references already rely on -- and index each one
+    # individually so a keyword search can jump straight to its section.
+    # Headings without an explicit anchor aren't linkable, so they are
+    # skipped; a "# comment" that happens to open a line inside a fenced code
+    # block is not a heading at all, so fenced regions are skipped wholesale.
+    ANCHORED_HEADING_RE = /\A(\#{1,6})[ \t]+(.*?)(?:[ \t]+\{#([\w-]+)\})?[ \t]*\z/.freeze
+    FENCE_START_RE = /\A`{3,}/.freeze
+
+    def initialize(suffix: '.html', fs_casesensitive: false)
+      @suffix = suffix
+      @fs_casesensitive = fs_casesensitive
+    end
+
+    # Builds the search index as an array of entry hashes.
+    # +db+ is a MethodDatabase; +fdb+ is an optional FunctionDatabase (C API).
+    def build_index(db, fdb = nil)
+      index = [] #: Array[entry]
+      index.concat(class_entries(db))
+      index.concat(method_entries(db))
+      index.concat(library_entries(db))
+      index.concat(document_entries(db))
+      index.concat(document_heading_entries(db))
+      index.concat(function_entries(fdb)) if fdb
+      index
+    end
+
+    # Serializes the index as an Aliki-compatible +search_data.js+ body.
+    def to_js(db, fdb = nil)
+      "var search_data = #{JSON.generate(index: build_index(db, fdb))};"
+    end
+
+    # Merges per-version indexes (an array of [version, index] pairs) into a
+    # single index whose entries carry a +versions+ array, for the standalone
+    # cross-version search page. Entries are considered the same when all of
+    # name/full_name/type/path match. Versions are sorted numerically ("3.10"
+    # sorts after "3.4"), and entry order is the first appearance while
+    # scanning versions in ascending order — independent of the caller's
+    # argument order, so the generated file diffs stay stable.
+    #
+    # A module function's full_name is spelled ".#" by pre-4.0 databases and
+    # "?." by 4.0+ ones (bitclust#250), which would split it into two rows —
+    # confusing on a page that lists every version side by side. Fold the
+    # display to the current "?." spelling here, so both spellings collapse
+    # into one row with a unified versions list (name/type/path/match_name
+    # are spelling-independent already). Only entries carrying a match_name
+    # (dot-qualified methods) are folded: a prose heading whose *text*
+    # happens to contain ".#" must keep matching its page verbatim. The
+    # single-version in-page search keeps each version's own spelling —
+    # build_index is not affected. See the report in bitclust#279.
+    def self.merge(version_indexes)
+      merged = {} #: Hash[Array[String?], merged_entry]
+      sorted = version_indexes.sort_by { |version, _| Gem::Version.new(version) }
+      sorted.each do |version, index|
+        index.each do |e|
+          if e[:match_name] && e[:full_name].include?('.#')
+            e = e.merge(full_name: e[:full_name].gsub('.#', '?.'))
+          end
+          key = e.values_at(:name, :full_name, :type, :path)
+          entry = (merged[key] ||= e.merge(versions: []))
+          entry[:versions] << version
+        end
+      end
+      merged.values
+    end
+
+    # Serializes a merged multi-version index as a +search_data.js+ body.
+    def self.merged_js(version_indexes)
+      "var search_data = #{JSON.generate(index: merge(version_indexes))};"
+    end
+
+    private
+
+    def class_entries(db)
+      db.classes.sort.reject(&:dummy?).map do |c|
+        {
+          name:      c.name,
+          full_name: c.name,
+          type:      c.type.to_s,
+          path:      "class/#{encode(c.name)}#{@suffix}",
+        }
+      end
+    end
+
+    def method_entries(db)
+      seen = {} #: Hash[String, bool]
+      result = [] #: Array[entry]
+      db.methods.each do |entry|
+        next if entry.undefined?
+
+        type = TYPENAME_TO_SEARCH_TYPE[entry.typename]
+        next unless type
+
+        cname = entry.klass.name
+        # bitclust#250: 検索結果に出る表示ラベル(name/full_name)は 4.0
+        # 以降のドキュメントでは module function を "?." で表示する。path
+        # は識別子なので typechar(常に不変)のまま
+        tmark = entry.display_typemark
+        tchar = entry.typechar
+        entry.names.each do |mname|
+          path = "method/#{encode(cname)}/#{tchar}/#{encode(mname)}#{@suffix}"
+          next if seen[path]
+
+          seen[path] = true
+          if tmark == '$'
+            # A special variable has no owning class to qualify it; its "$"
+            # sigil is the only thing distinguishing it, so keep it in +name+
+            # too (not just +full_name+) or a "$;"-style query can't match it.
+            name = full_name = tmark + mname
+            result << { name: name, full_name: full_name, type: type, path: path }
+          else
+            name = mname
+            full_name = cname + tmark + mname
+            item = { name: name, full_name: full_name, type: type, path: path } #: entry
+            if tmark.include?('.')
+              # bitclust#279: singleton methods (".") and module functions
+              # (".#"/"?.") keep a literal "." in full_name for display, but
+              # the vendored ranker's parseQuery() rewrites every "." in the
+              # *query* to "::". match_name is the same rewrite applied to
+              # this entry, so the search_init.js/search_page.js computeScore
+              # wrap can compare like-for-like. See the file header comment.
+              item[:match_name] = full_name.gsub('?.', '.#').gsub('.', '::')
+            end
+            result << item
+          end
+        end
+      end
+      result
+    end
+
+    def library_entries(db)
+      db.libraries.sort.map do |lib|
+        {
+          name:      lib.name,
+          full_name: lib.name,
+          type:      'library',
+          path:      "library/#{encode(lib.name)}#{@suffix}",
+        }
+      end
+    end
+
+    def document_entries(db)
+      db.docs.map do |doc|
+        slug  = doc.name
+        title = doc.title
+        # Prose pages are identified by a Japanese title, so index the title
+        # (for human queries) together with the slug (for identifier queries).
+        label = (title && !title.empty? && title != slug) ? "#{title} (#{slug})" : slug
+        {
+          name:      label,
+          full_name: label,
+          type:      'document',
+          path:      "doc/#{encode(slug)}#{@suffix}",
+        }
+      end
+    end
+
+    # One entry per {#id}-anchored heading found in a doc page's body, so
+    # that e.g. "defined?" or "alias" (headings inside spec/def.md) surface
+    # directly instead of only the whole "クラス／メソッドの定義" page. See
+    # ANCHORED_HEADING_RE above for why this only looks at doc pages (prose,
+    # not method/class references) and only at explicitly anchored headings.
+    def document_heading_entries(db)
+      seen = {} #: Hash[String, bool]
+      result = [] #: Array[entry]
+      db.docs.each do |doc|
+        source = doc.source
+        next unless source
+        page_title = (doc.title && !doc.title.empty?) ? doc.title : doc.name
+        base_path = "doc/#{encode(doc.name)}#{@suffix}"
+        each_anchored_heading(source) do |label, id|
+          path = "#{base_path}##{id}"
+          next if seen[path]
+
+          seen[path] = true
+          result << {
+            name:      label,
+            full_name: "#{label} (#{page_title})",
+            type:      'heading',
+            path:      path,
+          }
+        end
+      end
+      result
+    end
+
+    # Yields [label, id] for each ATX heading in +source+ that carries an
+    # explicit {#id} anchor, skipping the contents of fenced code blocks
+    # (```lang ... ```) so an in-sample "# comment" line can never be
+    # mistaken for a heading.
+    def each_anchored_heading(source)
+      fence = nil #: Integer?
+      source.each_line do |raw|
+        line = raw.chomp
+        if fence
+          # Matches MDCompiler#code_fence's own terminator: the closing fence
+          # must be exactly as long as the opening one.
+          fence = nil if /\A`{#{fence}}[ \t]*\z/ =~ line
+          next
+        end
+        if m = FENCE_START_RE.match(line)
+          fence = (m[0] || raise).size
+          next
+        end
+        next unless m = ANCHORED_HEADING_RE.match(line)
+
+        id = m[3] or next
+        yield clean_heading_label(m[2] || raise), id
+      end
+    end
+
+    # Headings may carry inline Markdown (code spans, escaped punctuation);
+    # strip that down to plain text for the index entry.
+    def clean_heading_label(label)
+      label.gsub(/`([^`]*)`/, '\1').gsub(/\\(.)/, '\1')
+    end
+
+    def function_entries(fdb)
+      fdb.functions.sort.map do |func|
+        {
+          name:      func.name,
+          full_name: func.name,
+          type:      'function',
+          path:      "function/#{func.name}#{@suffix}",
+        }
+      end
+    end
+
+    def encode(str)
+      @fs_casesensitive ? encodename_url(str) : encodename_fs(str)
+    end
+  end
+end

data/lib/bitclust/searcher.rb

@@ -40,8 +40,18 @@ module BitClust
         parser.banner = "Usage: #{@name} <pattern>"
         unless cmd == 'bitclust'
           parser.on('-d', '--database=URL', "Database location (default: #{dblocation_name()})") {|loc|
-            url = (/:/ =~ loc) ? loc : "file://#{File.expand_path(loc)}"
-            @dblocation = URI.parse(url)
+            @dblocation =
+              if windows_drive_path?(loc)
+                # "G:/Users/foo/.bitclust/db-2.2.0" のような Windows の
+                # ドライブレター付きパスは "/:/ =~ loc" が真になってしまい
+                # (":" がドライブレターの区切りに含まれるため)、既に URL
+                # 形式だと誤認されて file:// を付けずに URI.parse に渡って
+                # しまう。drive_path_uri で組み立てる
+                drive_path_uri(loc)
+              else
+                url = (/:/ =~ loc) ? loc : "file://#{File.expand_path(loc)}"
+                URI.parse(url)
+              end
           }
           parser.on('--server=URL', 'Spawns BitClust database server and listen URL.  Requires --database option with local path.') {|url|
             require 'bitclust/server'   # require here for speed
@@ -92,6 +102,14 @@ module BitClust
 
     def exec(argv, options = {})
       db = nil
+      prefix = options[:prefix]
+      if prefix
+        if options[:capi]
+          db = BitClust::FunctionDatabase.new(prefix)
+        else
+          db = BitClust::MethodDatabase.new(prefix)
+        end
+      end
       if @listen_url
         spawn_server db
       else
@@ -107,7 +125,7 @@ module BitClust
 
     def server_mode_check(argv)
       if @dblocation
-        unless @dblocation.scheme == 'file'
+        unless @dblocation&.scheme == 'file'
           $stderr.puts "Give local path to --database option on server mode"
           exit 1
         end
@@ -140,19 +158,19 @@ module BitClust
       #compiler = RDCompiler::Text.new
       compiler = Plain.new
       @view = TerminalView.new(compiler,
-                              {:describe_all => @describe_all, 
+                              {:describe_all => @describe_all,
                                :line => @linep,
                                :encoding => @encoding})
     end
 
     def spawn_server(db)
-      Server.new(new_local_database(db)).listen @listen_url, @foreground
+      Server.new(new_local_database(db)).listen (@listen_url || raise), @foreground
     end
 
     def new_local_database(db)
       return db if db
-      path = @dblocation ? @dblocation.path : dbpath()
-      MethodDatabase.new(path)
+      path = @dblocation ? @dblocation&.path : dbpath()
+      MethodDatabase.new(path || raise)
     end
 
     def new_database
@@ -172,15 +190,38 @@ module BitClust
 
     def find_dblocation
       %w( REFE2_SERVER BITCLUST_SERVER ).each do |key|
-        return URI.parse(ENV[key]) if ENV[key]
+        return URI.parse(ENV.fetch(key)) if ENV[key]
       end
       if path = dbpath()
-        URI.parse("file://#{path}")
+        # Windows で "G:/Users/foo/.bitclust/db-2.2.0" のようなドライブ
+        # レター付きの絶対パスを URI.parse("file://#{path}") に渡すと、
+        # "G" が URI のホスト部分として解釈されてしまい、path からドライブ
+        # レターが失われる(URI.parse("file://G:/foo").path は "/foo" に
+        # なってしまう)。ドライブレター付きパスのときは URI 化せず、
+        # drive_path_uri でドライブレターを保持したまま file: URI を作る
+        windows_drive_path?(path) ? drive_path_uri(path) : URI.parse("file://#{path}")
       else
         nil
       end
     end
 
+    # "G:/foo" や "C:\\foo" のような、Windows のドライブレターで始まる
+    # 絶対パスかどうかを判定する
+    def windows_drive_path?(path)
+      /\A[A-Za-z]:/.match?(path)
+    end
+
+    # ドライブレター付きの絶対パスを、ドライブレターを失わずに保持した
+    # ままの file: URI (URI::File) にする。通常の URI.parse("file://...")
+    # はホスト部分を認識してしまい先頭のドライブレターを取りこぼすため、
+    # ここでは URI::Generic#initialize の arg_check を無効にして、
+    # "先頭は / から始まる絶対パスであること" という通常の URI のパス
+    # 検証を素通りさせ、path にドライブレターを含む文字列をそのまま保持
+    # させる
+    def drive_path_uri(path)
+      URI::File.new('file', nil, '', nil, nil, path, nil, nil, nil, nil, false)
+    end
+
     def dbpath
       env_dbpath() || default_dbpath()
     end
@@ -188,7 +229,7 @@ module BitClust
     def env_dbpath
       [ 'REFE2_DATADIR', 'BITCLUST_DATADIR' ].each do |key|
         if ENV.key?(key)
-          unless MethodDatabase.datadir?(ENV[key])
+          unless MethodDatabase.datadir?(ENV.fetch(key))
             raise InvalidDatabase, "environment variable #{key} given but #{ENV[key]} is not a valid BitClust database"
           end
           return ENV[key]
@@ -202,7 +243,7 @@ module BitClust
       [ "#{datadir}/refe2", "#{datadir}/bitclust" ].each do |path|
         return path if MethodDatabase.datadir?(path)
       end
-      config_path = Pathname(ENV['HOME']) + ".bitclust" + "config"
+      config_path = Pathname(ENV.fetch('HOME')) + ".bitclust" + "config"
       if config_path.exist?
         config = YAML.load_file(config_path)
         return "#{config[:database_prefix]}-#{config[:default_version]}"
@@ -213,10 +254,14 @@ module BitClust
     def search_pattern(db, argv)
       db ||= new_database()
       @view.database ||= db if @view
+      # FIXME なぜか else 節にきかないのでここに書いておく
+      # @type var db: MethodDatabase
       case @target_type || db
       when :class
+        # @type var db: MethodDatabase
         find_class db, argv[0]
       when FunctionDatabase
+        # @type var db: FunctionDatabase
         case argv.size
         when 0
           show_all_functions db
@@ -226,6 +271,7 @@ module BitClust
           raise "must not happen: #{argv.size}"
         end
       else
+        # @type var db: MethodDatabase
         case argv.size
         when 0
           show_all_classes db
@@ -236,7 +282,7 @@ module BitClust
           find_method db, c, nil, m
         when 3
           c, t, m = *argv
-          check_method_type t
+          check_method_type t || raise
           find_method db, c, t, m
         else
           raise "must not happen: #{argv.size}"
@@ -278,7 +324,8 @@ module BitClust
       when /\A\$/   # Special variable.
         find_method db, 'Kernel', '$', pattern.sub(/\A\$/, '')
       when /[\#,]\.|\.[\#,]|[\#\.\,]/   # method spec
-        find_method db, *parse_method_spec_pattern(pattern)
+        c, t, m = parse_method_spec_pattern(pattern)
+        find_method db, c, t, m
       when /::/   # Class name or constant name.
         find_constant db, pattern
       when /\A[A-Z]/   # Method name or class name, but class name is better.
@@ -305,11 +352,13 @@ module BitClust
       find_method db, cnames.join('::'), '::', name
     end
 
+    # 区切りは反転文字列上で探す。"?." は 4.0 以降の module function の
+    # 表示形式(反転すると ".?")で、内部表記の ".#" に正規化する
     def parse_method_spec_pattern(pat)
-      _m, _t, _c = pat.reverse.split(/([\#,]\.|\.[\#,]|[\#\.\,])/, 2)
-      c = _c.reverse
-      t = _t.tr(',', '#').sub(/\#\./, '.#')
-      m = _m.reverse
+      _m, _t, _c = pat.reverse.split(/([\#,]\.|\.[\#,]|\.\?|[\#\.\,])/, 2)
+      c = (_c || raise).reverse
+      t = (_t || raise).tr(',', '#').sub(/\#\.|\.\?/, '.#')
+      m = (_m || raise).reverse
       return c, t, m
     end
 
@@ -465,7 +514,7 @@ module BitClust
       puts title
       print_names methods.map{|m| m.name }
     end
-    
+
     def describe_method(rec)
       unless rec.entry.library.name == '_builtin'
         puts "require '#{rec.entry.library.name}'"
@@ -501,10 +550,10 @@ module BitClust
     end
 
     def convert(string)
-      return string if @database.nil?
+      return string if database.nil?
       _output_encoding = output_encoding
       return string if _output_encoding.nil?
-      input_nkf_option = encoding_to_nkf_option(@database.encoding)
+      input_nkf_option = encoding_to_nkf_option(database.encoding)
       output_nkf_option = encoding_to_nkf_option(_output_encoding)
       if input_nkf_option and output_nkf_option
         NKF.nkf("-#{input_nkf_option.upcase}#{output_nkf_option}", string)

data/lib/bitclust/simplesearcher.rb

@@ -9,12 +9,14 @@ module BitClust
     include NameUtils
 
     module_function
-    
+
     def search_pattern(db, pat)
       pat = to_pattern(pat)
       return [] if pat.empty? or /\A\s+\z/ =~ pat
       cname, type, mname = parse_method_spec_pattern(pat)
-      cs = ms = []
+      # @type var cs: Array[ClassEntry]
+      # @type var ms: Array[MethodEntry]
+      cs = []; ms = []
       if cname and not cname.empty?
         if mname
           ms = find_class_method(db, cname, type, mname)
@@ -23,9 +25,9 @@ module BitClust
           cs = find_class(db, cname)
         end
       elsif type == '$'
-        ms = find_special_vars(db, mname)
+        ms = find_special_vars(db, mname || raise)
       else
-        ms = find_methods(db, mname)        
+        ms = find_methods(db, mname || raise)
       end
       ms = ms.sort_by{|e| [e.library.name, e.klass.name] }
       cs = cs.sort_by{|e| [e.library.name] }
@@ -35,9 +37,9 @@ module BitClust
     def find_class(db, cname)
       db.classes.find_all{|c| /\b#{Regexp.escape(cname)}\w*\z/ =~ c.name }
     end
-    
+
     def find_class_method(db, cname, type, mname)
-      ret = []
+      ret = [] #: Array[MethodEntry]
       db.classes.each{|c|
         if /\b#{Regexp.escape(cname)}/ =~ c.name
           ret += c.methods.find_all{|m|
@@ -62,24 +64,34 @@ module BitClust
 
     def to_pattern(pat)
       pat = pat.to_str
-      pat = pat[/\A\s*(.*?)\s*\z/, 1]                  
+      pat = pat[/\A\s*(.*?)\s*\z/, 1] || raise
     end
-    
+
     def parse_method_spec_pattern(pat)
       if /\s/ =~ pat
         return parse_method_spec_pattern0(pat)
       end
       return pat, nil, nil if /\A[A-Z]\w*\z/ =~ pat
       return nil, '$', $1  if /\$(\S*)/ =~ pat
-      _m, _t, _c = pat.reverse.split(/(::|[\#,]\.|\.[\#,]|[\#\.\,])/, 2)
+      # bitclust#250: "?." is an alternate spelling of the module-function
+      # separator ".#" (Ruby >=4.0 docs display it that way since #277; see
+      # NameUtils.display_typemark). Accept it here regardless of which
+      # Ruby version the query is about -- this is query *input*, not
+      # display, so both notations are always accepted. "?" is added to the
+      # same reversed-pattern alternative that already matches "#." and ",."
+      # (a marker character immediately followed by ".", read in the
+      # reversed pattern), so "?." matches the same way "#." already does.
+      _m, _t, _c = pat.reverse.split(/(::|[\#,]\.|\.[\#,\?]|[\#\.\,])/, 2)
+      _m || raise
       c = _c.reverse if _c
-      t = _t.tr(',', '#').sub(/\#\./, '.#') if _t
+      t = _t.tr(',?', '##').sub(/\#\./, '.#') if _t
       m = _m.reverse
       return c, t, m
     end
 
-    def parse_method_spec_pattern0(q)
-      q = q.scan(/\S+/)[0..1]
+    def parse_method_spec_pattern0(pat)
+      # @type var q: Array[String]
+      q = _ = pat.scan(/\S+/)[0..1]
       q = q.reverse unless /\A[A-Z]/ =~ q[0]
       return q[0], nil, q[1]
     end

data/lib/bitclust/subcommand.rb

@@ -24,6 +24,12 @@ module BitClust
       @parser.parse! argv
     end
 
+    # グローバル --database（options[:prefix]）を必要とするか。
+    # DB パスを自前の引数で受けるサブコマンド（searchpage）は false を返す
+    def needs_database?
+      true
+    end
+
     def help
       @parser.help
     end
@@ -57,7 +63,7 @@ module BitClust
     def align_progress_bar_title(title)
       size = title.size
       if size > 14
-        title[0..13]
+        title[0..13] || raise
       else
         title + ' ' * (14 - size)
       end

data/lib/bitclust/subcommands/ancestors_command.rb

@@ -45,10 +45,15 @@ Options:
         }
       end
 
+      # DB はサブコマンド自身の -d/--database オプションで受ける
+      def needs_database?
+        false
+      end
+
       def exec(argv, options)
         classname = argv[0]
-        db = MethodDatabase.new(@prefix)
-        ruby = get_ruby(@version)
+        db = MethodDatabase.new(@prefix || raise)
+        ruby = get_ruby(@version) || raise
         if classname && !@all
           check_ancestors(db, ruby, @requires, classname)
         else
@@ -83,6 +88,7 @@ Options:
         rescue ClassNotFound => ex
           $stderr.puts ex.backtrace
           $stderr.puts "class not found in database : #{classname}"
+          # @type var b: Array[String]
           b = []
         end
         unless a.to_set == b.to_set
@@ -95,6 +101,7 @@ Options:
       end
 
       def check_all_ancestors(db, ruby, requires)
+        # @type var classnames: Array[String]
         classnames = []
         requires.each do |lib|
           classnames.push(*defined_classes(ruby, lib, []))

data/lib/bitclust/subcommands/checklink_command.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+#
+# bitclust/subcommands/checklink_command.rb
+#
+# DB 中の全ソースをコンパイル経路で走査し、[[c:]]/[[m:]]/[[lib:]]/[[d:]]/
+# [[f:]] 参照のリンク切れを報告する:
+#
+#   bitclust -d db-3.4 checklink
+#   bitclust -d db-3.4 checklink --capi-database=db-3.4-capi
+#
+# リンク切れが1件でもあれば exit 1(CI 組み込み用)。
+# [[f:]](C API 関数)は --capi-database 指定時のみ検証し、
+# 未指定ならスキップ数だけ報告する。
+
+require 'bitclust'
+require 'bitclust/subcommand'
+require 'bitclust/link_checker'
+
+module BitClust
+  module Subcommands
+    class ChecklinkCommand < Subcommand
+      def initialize
+        super
+        @capi_prefix = nil
+        @parser.banner = "Usage: #{File.basename($0, '.*')} --database=PATH checklink [options]"
+        @parser.on('--capi-database=PATH', 'C API (function) database for [[f:]] refs.') {|path|
+          @capi_prefix = path
+        }
+      end
+
+      def exec(argv, options)
+        super
+        db = @db
+        unless db.is_a?(MethodDatabase)
+          error 'checklink is for method databases (do not use --capi; pass --capi-database instead)'
+        end
+        capi_prefix = @capi_prefix
+        fdb = capi_prefix ? BitClust::FunctionDatabase.new(capi_prefix) : nil
+        checker = LinkChecker.new(db, function_database: fdb)
+        checker.check_all
+        # 同一エントリ内の同一参照の繰り返しは1行にまとめる
+        checker.findings.map {|f| "#{f.location}: [[#{f.ref}]] #{f.message}" }.uniq.each do |line|
+          puts line
+        end
+        if fdb.nil? && checker.skipped_function_refs > 0
+          puts "note: #{checker.skipped_function_refs} [[f:]] refs skipped (no --capi-database)"
+        end
+        version = @db.properties['version']
+        puts "#{checker.broken_count} broken link(s) in #{version ? "db (version #{version})" : 'db'}"
+        exit 1 unless checker.broken_count.zero?
+      end
+    end
+  end
+end