bitclust-dev 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2b70c22f437c01d0972d9cc39ed011f26af88ce04a295909ad02dc3177822c7
-  data.tar.gz: 3a86cd213fb1cb1be92d1d1f71c8cf3da91ece0cbd9e24ac05f11639f7a47aee
+  metadata.gz: d2759bd606017d5361386015b8fa44b404272bd23445c74f98f6e6e571fc0c0d
+  data.tar.gz: f370ab5fbe22cad11dfe65c9b7fed3eb75086428352947b778bb58336783861a
 SHA512:
-  metadata.gz: 7b6750fd7bf351610c039432aa220ce67bb95602002d281c8bb52e79667207b8156adf230193c7115ef6d13025642bfaecacd3f5ee5048beaefe5a1d960c7c36
-  data.tar.gz: fe4fa1117faa16fd0f4b6cf7f0aa4c09e8cbb8f244b1ba7eb3e20be9be62f4c5e91a79f6adaddc783f5f0c227a34a006c9b6cdc1c691044185f0331db7658504
+  metadata.gz: 4a9caaab23e117be4018664057f2df0765ee8874a22da2d31003892edce97ada3524dc0475c866aebab775559d9862c770c93cd12e9e8735d8a01837d7d9bf97
+  data.tar.gz: e68dc2a8cb51eeb48a86cbab2e335faaec7e0297cc6c444662782e6b2fe70ce1facae7ab283a3b2f5c16bf99e4c1d581a3da1a6052066c0801b525d4e9afc5c5

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitclust-dev
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - https://github.com/rurema
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: 1.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.7.0
+        version: 1.8.0
 description: |
   Rurema is a Japanese ruby documentation project, and
   bitclust is a rurema document processor.
@@ -30,40 +30,25 @@ description: |
 email:
 - ''
 executables:
-- bc-checkparams.rb
-- bc-convert.rb
-- bc-rdoc.rb
 - forall-ruby.rb
 - gencatalog.rb
-- insert-canonical.rb
 - md-bridge-check.rb
 - md-compile-check.rb
 - md-db-check.rb
 - md-parse-check.rb
 - md-roundtrip-check.rb
 - md-tree-check.rb
-- statrefm.rb
-- stattodo.rb
-- update-database.rb
 extensions: []
 extra_rdoc_files: []
 files:
-- tools/bc-checkparams.rb
-- tools/bc-convert.rb
-- tools/bc-rdoc.rb
-- tools/check-signature.rb
 - tools/forall-ruby.rb
 - tools/gencatalog.rb
-- tools/insert-canonical.rb
 - tools/md-bridge-check.rb
 - tools/md-compile-check.rb
 - tools/md-db-check.rb
 - tools/md-parse-check.rb
 - tools/md-roundtrip-check.rb
 - tools/md-tree-check.rb
-- tools/statrefm.rb
-- tools/stattodo.rb
-- tools/update-database.rb
 homepage: https://docs.ruby-lang.org/ja/
 licenses: []
 metadata:

data/tools/bc-checkparams.rb

@@ -1,274 +0,0 @@
-#! /usr/bin/ruby
-
-require 'optparse'
-require 'pathname'
-require 'set'
-
-bindir = Pathname.new(__FILE__).realpath.dirname
-$LOAD_PATH.unshift((bindir + '../lib').realpath)
-
-require 'bitclust/preprocessor'
-require 'bitclust/lineinput'
-require 'bitclust/parseutils'
-require 'bitclust/methodsignature'
-
-def main
-  option = OptionParser.new
-  version = '1.9.1'
-  option.banner = "Usage: #{File.basename($0, '.*')} <filename>"
-  option.on('--ruby=[VER]', "The version of Ruby interpreter"){|ver|
-    version = ver
-  }
-  option.on('--help', 'Prints this message and quit.') {
-    puts option.help
-    exit 0
-  }
-  begin
-    option.parse!(ARGV)
-  rescue OptionParser::ParseError => err
-    $stderr.puts err.message
-    exit 1
-  end
-  unless ARGV.size == 1
-    $stderr.puts "wrong number of arguments"
-    $stderr.puts option.help
-    exit 1
-  end
-  filename = ARGV[0]
-  path = Pathname.new(filename)
-
-  params = { "version" => version }
-  parser = BitClust::RDParser.new(BitClust::Preprocessor.read(path, params))
-  parser.parse
-end
-
-module BitClust
-  class RDParser
-    def initialize(src)
-      @f = LineInput.new(StringIO.new(src))
-      @option = { :force => true }
-    end
-
-    def parse
-      while @f.next?
-        case @f.peek
-        when /\A---/
-          method_entry_chunk
-        else
-          @f.gets
-        end
-      end
-    end
-
-    def method_entry_chunk
-      method_signatures = []
-      @f.while_match(/\A---/) do |line|
-        method_signatures << method_signature(line)
-      end
-      props = {}
-      @f.while_match(/\A:/) do |line|
-        k, v = line.sub(/\A:/, '').split(':', 2)
-        props[k.strip] = v.strip
-      end
-      params = Set.new
-      while @f.next?
-        case @f.peek
-        when /\A===+/
-          @f.gets
-        when /\A==?/
-          if @option[:force]
-            break
-          else
-            raise "method entry includes headline: #{@f.peek.inspect}"
-          end
-        when /\A---/
-          break
-        when /\A\s+\*\s/
-          ulist
-        when /\A\s+\(\d+\)\s/
-          olist
-        when /\A:\s/
-          dlist
-        when %r<\A//emlist\{>
-          emlist
-        when /\A\s+\S/
-          list
-        when /@see/
-          see
-        when /\A@[a-z]/
-          method_info.each do |param|
-            params << param
-          end
-        else
-          if @f.peek.strip.empty?
-            @f.gets
-          else
-            method_entry_paragraph
-          end
-        end
-      end
-      check_parameters(method_signatures, params)
-    end
-
-    def headline(line)
-      # nop
-    end
-
-    def ulist
-      @f.while_match(/\A\s+\*\s/) do |line|
-        @f.while_match(/\A\s+[^\*\s]/) do |cont|
-          # nop
-        end
-      end
-    end
-
-    def olist
-      @f.while_match(/\A\s+\(\d+\)/) do |line|
-        @f.while_match(/\A\s+(?!\(\d+\))\S/) do |cont|
-          # nop
-        end
-      end
-    end
-
-    def dlist
-      while @f.next? and /\A:/ =~ @f.peek
-        @f.while_match(/\A:/) do |line|
-          # nop
-        end
-        dd_with_p
-      end
-    end
-
-    # empty lines separate paragraphs.
-    def dd_with_p
-      while /\A(?:\s|\z)/ =~ @f.peek or %r!\A//emlist\{! =~ @f.peek
-        case @f.peek
-        when /\A$/
-          @f.gets
-        when  /\A[ \t]/
-          @f.while_match(/\A[ \t]/) do |line|
-            # nop
-          end
-        when %r!\A//emlist\{!
-            emlist
-        else
-          raise 'must not happen'
-        end
-      end
-    end
-
-    # empty lines do not separate paragraphs.
-    def dd_without_p
-      while /\A[ \t]/ =~ @f.peek or %r!\A//emlist\{! =~ @f.peek
-        case @f.peek
-        when  /\A[ \t]/
-          @f.while_match(/\A[ \t]/) do |line|
-            # nop
-          end
-        when %r!\A//emlist\{!
-          emlist
-        end
-      end
-    end
-
-    def emlist
-      @f.gets   # discard "//emlist{"
-      @f.until_terminator(%r<\A//\}>) do |line|
-        # nop
-      end
-    end
-
-    def list
-      @f.break(/\A\S/)
-    end
-
-    def see
-      @f.gets
-      @f.span(/\A\s+\S/)
-    end
-
-    def paragraph
-      read_paragraph(@f).each do |line|
-        # nop
-      end
-    end
-
-    def read_paragraph(f)
-      f.span(%r<\A(?!---|=|//emlist\{)\S>)
-    end
-
-    def method_info
-      params = []
-      while @f.next? and /\A\@(?!see)\w+|\A$/ =~ @f.peek
-        header = @f.gets
-        next if /\A$/ =~ header
-        cmd = header.slice!(/\A\@\w+/)
-        @f.ungets(header)
-        case cmd
-        when '@param', '@arg'
-          name = header.slice!(/\A\s*\w+/) || '?'
-          params << name.strip
-        when '@raise'
-          # nop
-        when '@return'
-          # nop
-        when '@todo'
-          # nop
-        when '@undef'
-          # nop
-        else
-          $stderr.puts "[UNKNOWN_META_INFO] #{cmd}"
-        end
-        dd_without_p
-      end
-      params
-    rescue
-      $stderr.puts "#{@f.lineno}: #{@sig.friendly_string}"
-      $stderr.puts params.inspect
-      $stderr.puts @sig.params.inspect
-    end
-
-    def method_entry_paragraph
-      read_method_entry_paragraph(@f).each do |line|
-        # nop
-      end
-    end
-
-    def read_method_entry_paragraph(f)
-      f.span(%r<\A(?!---|=|//emlist\{|@[a-z])\S>)
-    end
-
-    def method_signature(sig_line)
-      @sig = MethodSignature.parse(sig_line)
-    end
-
-    private
-
-    def check_parameters(method_signatures, params)
-      params_in_signature = extract_params(method_signatures)
-      unless params_in_signature == params
-        puts "#{@f.lineno}:"
-        method_signatures.each do |signature|
-          puts signature.friendly_string
-          puts "signature: #{signature.params}"
-        end
-        puts "@params: #{params.to_a.join(", ")}"
-        puts "-" * 72
-      end
-    end
-
-    def extract_params(method_signatures)
-      method_signatures.map do |signature|
-        next unless signature.params
-        signature.params.split(",").map do |param|
-          param = param.tr("*&", "")
-          param = param.gsub(/\=.*/, "")
-          param = param.gsub(/.*:/, "")
-          param.strip
-        end
-      end.compact.flatten.to_set
-    end
-  end
-end
-
-main

data/tools/bc-convert.rb

@@ -1,165 +0,0 @@
-#!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
-
-$KCODE = 'UTF-8' unless Object.const_defined?(:Encoding)
-
-require 'stringio'
-require 'fileutils'
-require 'tmpdir'
-require 'optparse'
-
-def main
-  mode = :output
-  parser = OptionParser.new
-  parser.banner = "Usage: #{File.basename($0, '.*')} [--diff] [file...]"
-  parser.on('--diff', 'Show the diff between original file and output') {
-    mode = :diff
-  }
-  parser.on('--inplace', 'edit input files in-place (make backup)') {
-    mode = :inplace
-  }
-  parser.on('--help') {
-    puts parser.help
-    exit
-  }
-  begin
-    parser.parse!
-  rescue OptionParser::ParseError => err
-    $stderr.puts err.message
-    exit 1
-  end
-  case mode
-  when :output
-    do_convert ARGF
-  when :diff
-    ARGV.each do |path|
-      diff_output path
-    end
-  when :inplace
-    ARGV.each do |path|
-      inplace_edit path
-    end
-  else
-    raise "must not happen: mode=#{mode.inspect}"
-  end
-end
-
-def inplace_edit(path)
-  str = convert_file(path)
-  File.rename path, path + '.bak'
-  File.open(path, 'w') {|f|
-    f.write str
-  }
-end
-
-def diff_output(path)
-  tmppath = "#{Dir.tmpdir}/bc-convert-diff"
-  File.open(tmppath, 'w') {|f|
-    f.write convert_file(path)
-  }
-  system 'diff', '-u', path, tmppath
-ensure
-  FileUtils.rm_f tmppath
-end
-
-def convert_file(path)
-  File.open(path) {|f| convert(f) }
-end
-
-def convert(f)
-  buf = StringIO.new
-  do_convert f, buf
-  buf.string
-end
-
-def do_convert(f, out = $stdout)
-  f.each do |line|
-    case line
-    when /\A\#@/
-      out.puts line
-    when /\A\#/
-      out.puts '#@' + line
-    when /\A---\s/
-      sig = convert_signature(line.sub(/\A---/, '').sub(/\(\(<.*?>\)\)/i, '').strip)
-      out.puts "--- #{sig}"
-      if meta = line.slice(/\(\(<.*?>\)\)/i)
-        out.puts
-        out.puts meta
-        out.puts
-      end
-    else
-      out.puts convert_link(line.rstrip)
-    end
-  end
-end
-
-def convert_signature(sig)
-  case sig
-  when /\A([\w:\.\#]+[?!]?)\s*(?:[\(\{]|--|->|\z)/
-       # name(arg), name{}, name,
-       # name() -- obsolete
-       # name() -> return value type
-    sig
-  when /\A[\w:]+[\.\#]([+\-<>=~*^&|%\/]+)/   # Complex#+
-    sig
-  when /\Aself\s*(==|===|=~)\s*(\w+)/        # self == other
-    "#{$1}(#{$2})"
-  when /\A([\w:\.\#]+)\s*\=(\(|\s*\w+)?/   # name=
-    "#{remove_class_spec($1)}=(#{remove_paren($2.to_s.strip)})"
-  when /\A\w+\[(.*)\]=(.*)/                  # self[key]=
-    "[]=(#{$1}, #{$2.strip})"
-  when /\A[\w\:]+\[(.*)\]/                   # self[key]
-    "[](#{$1})"
-  when /\Aself\s*([+\-<>=~*^&|%\/]+)\s*(\w+)/   # self + other
-    "#{$1}(#{$2})"
-  when /\A([+\-~`])\s*\w+/                   # ~ self
-    case op = $1
-    when '+', '-' then op + '@'
-    else               op
-    end
-  when /\A(?:[\w:]+[\.\#])?(\[\]=?)/         # Matrix.[](i)
-    sig
-  when /\A([+\-<>=~*^&|%]+)/                 # +(m)
-    sig
-  when /\A([A-Z]\w+\*)/                      # HKEY_*
-    sig
-  when /\Aself([+\-<>=~*^&|%\/\[\]]+)\(\w/   # self+(other)
-    sig.sub(/\Aself/, '')
-  else
-    $stderr.puts "warning: unknown method signature: #{sig.inspect}"
-    sig
-  end
-end
-
-def remove_class_spec(str)
-  str.sub(/\A[A-Z]\w*(?:::[A-Z]\w*)*[\.\#]/, '')
-end
-
-def remove_paren(str)
-  str.sub(/\A\(/, '').sub(/\)\z/, '')
-end
-
-def convert_link(line)
-  line.gsub(/\(\(\{(.*?)\}\)\)/) { $1 }\
-      .gsub(/\(\(\|(.*?)\|\)\)/) { $1 }\
-      .gsub(/\(\(<(.*?)>\)\)/) { convert_href($1) }
-end
-
-def convert_href(link)
-  case link
-  when /\Atrap::(.*)/              then "[[trap:#{$1}]]"
-  when /\Aruby 1\.\S+ feature/     then "((<#{link}>))"
-  when /\Aobsolete/                then "((<obsolete>))"
-  when /\A組み込み変数\/(.*)/u     then "[[m:#{$1}]]"
-  when /\A組み込み定数\/(.*)/u     then "[[m:Kernel::#{$1}]]"
-  when /\A組み込み関数\/(.*)/u     then "[[m:Kernel\##{$1}]]"
-  when /\A([\w:]+[\#\.][^|]+)\|/   then "[[m:#{$1}]]"
-  when /\A(.*?)\|manual page\z/    then "[[man:#{$1}]]"
-  when /\A([\w:]+)\/(.*)\z/n       then "[[m:#{$1}\##{$2}]]"
-  when /\A([A-Z][\w:]*)\z/         then "[[c:#{$1}]]"
-  else
-    "[[unknown:#{link}]]"
-  end
-end
-
-main

data/tools/bc-rdoc.rb

@@ -1,343 +0,0 @@
-#!/usr/bin/env ruby
-#
-# bc-rdoc.rb -- handle rdoc (ri) database.
-#
-# "bc-rdoc history" code is derived from bc-history.rb, posted in
-# [ruby-reference-manual:150] by moriq.
-#
-
-require 'pathname'
-
-srcdir_root = Pathname.new(__FILE__).realpath.dirname.parent.cleanpath
-$LOAD_PATH.unshift srcdir_root + 'lib'
-
-require 'bitclust'
-require 'bitclust/ridatabase'
-require 'rdoc/ri/ri_reader'
-require 'rdoc/ri/ri_cache'
-require 'rdoc/ri/ri_paths'
-require 'rdoc/markup/simple_markup/fragments'
-require 'stringio'
-require 'pp'
-require 'optparse'
-
-class ApplicationError < StandardError; end
-class RiClassNotFound < ApplicationError; end
-
-def main
-  Signal.trap(:PIPE) { exit 1 } rescue nil   # Win32 does not have SIGPIPE
-  Signal.trap(:INT) { exit 1 }
-
-  parser = OptionParser.new
-  parser.banner = <<-EndUsage
-Usage: #{File.basename($0)} (list|diff|history) [options]
-
-Subcommands:
-    list        List methods stored in ri database.
-    diff        Compare between BitClust and ri database.
-    history     Show class/method history stored in ri database.
-
-Global Options:
-EndUsage
-  parser.on('--help', 'Prints this message and quit.') {
-    puts parser.help
-    exit 0
-  }
-  begin
-    parser.order!
-  rescue OptionParser::ParseError => err
-    $stderr.puts err.message
-    $stderr.puts parser.help
-    exit 1
-  end
-
-  subcommands = {
-    'list'    => ListCommand.new,
-    'diff'    => DiffCommand.new,
-    'history' => HistoryCommand.new
-  }
-  subcommands['hist'] = subcommands['history']
-  unless ARGV[0]
-    $stderr.puts 'no subcommand given'
-    $stderr.puts parser.help
-    exit 1
-  end
-  unless subcommands.key?(ARGV[0])
-    $stderr.puts "unknown subcommand: #{ARGV[0].inspect}"
-    $stderr.puts parser.help
-    exit 1
-  end
-  sub = subcommands[ARGV.shift]
-  begin
-    sub.parse ARGV
-  rescue OptionParser::ParseError => err
-    $stderr.puts err.message
-    $stderr.puts sub.parser.help
-    exit 1
-  end
-  sub.exec
-rescue Errno::EPIPE
-  exit 1
-rescue ApplicationError, BitClust::UserError => err
-  $stderr.puts err.message
-  exit 1
-end
-
-
-class Subcommand
-
-  def open_ri_database(prefix)
-    if prefix
-      RiDatabase.open(prefix, nil)
-    else
-      RiDatabase.open_system_db
-    end
-  end
-
-end
-
-
-class ListCommand < Subcommand
-
-  def initialize
-    @prefix = nil
-    @type = :name
-    @parser = OptionParser.new
-    @parser.banner = "Usage: #{File.basename($0, '.*')} list"
-    @parser.on('--ri-database=PREFIX', 'Ri database prefix') {|path|
-      @prefix = path
-    }
-    @parser.on('-c', '--content', 'Prints method description') {
-      @type = :content
-    }
-    @parser.on('--help', 'Prints this message and quit.') {
-      puts @parser.help
-      exit 0
-    }
-  end
-
-  attr_reader :parser
-
-  def parse(argv)
-    @parser.parse! argv
-    unless argv.size == 1
-      $stderr.puts "class name not given"
-      exit 1
-    end
-    @classname = argv[0]
-    @ri = open_ri_database(@prefix)
-  end
-
-  def exec
-    c = @ri.lookup_class(@classname)
-    case @type
-    when :name
-      c.method_entries.each do |m|
-        puts m.fullname
-      end
-    when :content
-      fmt = Formatter.new
-      c.method_entries.each do |m|
-        puts fmt.method_info(@ri.get_method(m))
-      end
-    end
-  end
-
-end
-
-
-class DiffCommand < Subcommand
-
-  def initialize
-    @bcprefix = nil
-    @riprefix = nil
-    @type = :name
-    @parser = OptionParser.new
-    @parser.banner = "Usage: #{File.basename($0, '.*')} diff --bc=PATH --ri=PATH <classname>"
-    @parser.on('--bc-database=PREFIX', 'BitClust database prefix') {|path|
-      @bcprefix = path
-    }
-    @parser.on('--ri-database=PREFIX', 'Ri database prefix') {|path|
-      @riprefix = path
-    }
-    @parser.on('-c', '--content', 'Prints method description') {
-      @type = :content
-    }
-    @parser.on('--help', 'Prints this message and quit.') {
-      puts @parser.help
-      exit 0
-    }
-  end
-
-  attr_reader :parser
-
-  def parse(argv)
-    @parser.parse! argv
-    unless @bcprefix
-      $stderr.puts 'missing BitClust database prefix.  Use --bc option'
-      exit 1
-    end
-    @bc = BitClust::MethodDatabase.new(@bcprefix)
-    @ri = open_ri_database(@riprefix)
-    unless argv.size == 1
-      $stderr.puts "wrong number of arguments (#{argv.size} for 1)"
-      $stderr.puts @parser.help
-      exit 1
-    end
-    @classname = argv[0]
-  end
-
-  def exec
-    @ri.current_class = @classname
-    win, lose = *diff_class(bc_lookup_class(@classname), @ri)
-    case @type
-    when :name
-      win.each do |m|
-        puts "+ #{m.id}"
-      end
-      lose.each do |m|
-        puts "- #{m.fullname}"
-      end
-    when :content
-      fmt = Formatter.new
-      lose.each do |m|
-#        puts "\#@\# bc-rdoc: detected missing name: #{m.name}"
-        puts fmt.method_info(m.entry)
-      end
-    end
-  end
-
-  def bc_lookup_class(classname)
-    @bc.fetch_class(classname)
-  rescue BitClust::ClassNotFound
-    $stderr.puts "warning: class #{classname} not exist in BitClust database"
-    @bc.get_class(classname)
-  end
-
-  def diff_class(bc, ri)
-    unzip(diff_entries(bc, bc_wrap(bc.singleton_methods), ri.singleton_methods),
-          diff_entries(bc, bc_wrap(bc.instance_methods),  ri.instance_methods))\
-        .map {|list| list.flatten }
-  end
-
-  def bc_wrap(ents)
-    ents.map {|m|
-      m.names.map {|name| BCMethodEntry.new(name, m) }
-    }.flatten.uniq
-  end
-
-  def unzip(*tuples)
-    [tuples.map {|s, i| s }, tuples.map {|s, i| i }]
-  end
-
-  def diff_entries(bc_class, bc, ri)
-    bc = bc.sort
-    ri = ri.sort
-    [bc - ri, (ri - bc).reject {|m| true_exist?(bc_class, m) }]
-  end
-
-  def true_exist?(c, m)
-    if m.singleton_method?
-      c.singleton_method?(m.name, true)
-    else
-      c.instance_method?(m.name, true)
-    end
-  end
-
-end
-
-
-class HistoryCommand < Subcommand
-
-  def initialize
-    @riprefix = nil
-    @parser = OptionParser.new
-    @parser.banner = "Usage: #{File.basename($0, '.*')} history --ri=PATH <classname>"
-    @parser.on('--ri-database=PREFIX', 'Ri database prefix') {|path|
-      @riprefix = path
-    }
-    @parser.on('--help', 'Prints this message and quit.') {
-      puts @parser.help
-      exit 0
-    }
-  end
-
-  attr_reader :parser
-
-  def parse(argv)
-    @parser.parse! argv
-    unless @riprefix
-      $stderr.puts 'ri database not given; use --ri option'
-      exit 1
-    end
-    @ris = Dir.glob("#{@riprefix}/1.*").map {|dir|
-      RiDatabase.open(dir, File.basename(dir))
-    }
-    if @ris.empty?
-      $stderr.puts 'wrong ri database directory; directories like <path>/1.8.3/, <path>/1.8.4/, ... must exist'
-      exit 1
-    end
-    unless argv.size == 1
-      $stderr.puts "wrong number of arguments (#{argv.size} for 1)"
-      $stderr.puts @parser.help
-      exit 1
-    end
-    @classname = argv[0]
-  end
-
-  def exec
-    @ris.each do |ri|
-      ri.current_class = @classname
-    end
-    s = {}
-    i = {}
-    @ris.each do |ri|
-      ri.singleton_methods.each do |m|
-        (s[m] ||= []).push ri.version
-      end
-      ri.instance_methods.each do |m|
-        (i[m] ||= []).push ri.version
-      end
-    end
-    namecols = calculate_n_namecols(s.keys + i.keys)
-    versions = @ris.map {|ri| ri.version }
-    print_header namecols, versions
-    print_records namecols, versions, (s.to_a + i.to_a)
-  end
-
-  def calculate_n_namecols(ms)
-    tabstop = 8
-    maxnamelen = ms.map {|m| m.fullname.size }.max
-    (maxnamelen / tabstop + 1) * tabstop
-  end
-
-  def print_header(namecols, versions)
-    print ' ' * namecols
-    versions.each do |ver|
-      printf '%4s', ver.tr('.', '')
-    end
-    puts
-  end
-
-  def print_records(namecols, versions, records)
-    veridx = {}
-    versions.each_with_index do |ver, idx|
-      veridx[ver] = idx
-    end
-    records.sort_by {|m, vers| m.fullname }.each do |m, vers|
-      printf "%-#{namecols}s", m.fullname
-
-      fmt = '%4s' * versions.size
-      cols = ['-'] * versions.size
-      vers.each do |ver|
-        cols[veridx[ver]] = 'o'
-      end
-      printf fmt, *cols
-      puts
-    end
-  end
-
-end
-
-
-main

data/tools/check-signature.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'pathname'
-$LOAD_PATH.unshift Pathname($0).realpath.dirname.dirname + 'lib'
-
-require 'bitclust/methodsignature'
-
-st = 0
-ARGF.each do |line|
-  if /\A---/ =~ line
-    begin
-      BitClust::MethodSignature.parse(line)
-    rescue => _err
-      $stderr.puts "#{ARGF.filename}:#{ARGF.file.lineno}: #{line.strip.inspect}"
-      st = 1
-    end
-  end
-end
-exit st

data/tools/insert-canonical.rb

@@ -1,60 +0,0 @@
-require "optparse"
-require "uri"
-require "fileutils"
-require "tempfile"
-require "strscan"
-
-canonical_base_url = "https://docs.ruby-lang.org/ja/latest/"
-base_dir = nil
-
-parser = OptionParser.new
-parser.on("--canonical-base-url=URL", "Canonical base URL") do |url|
-  canonical_base_url = URI(url)
-end
-parser.on("--base-dir=DIR", "Base directory") do |dir|
-  base_dir = dir
-end
-
-begin
-  parser.parse!
-rescue OptionParser::ParseError => ex
-  $stderr.puts ex.message
-  $stderr.push parser.help
-  exit(false)
-end
-
-def insert_canonical_url(canonical_base_url, entry)
-  canonical_link = %Q(<link rel="canonical" href="#{canonical_base_url + entry}">\n)
-  scanner = StringScanner.new(File.read(entry))
-  Tempfile.create(File.basename(entry)) do |file|
-    loop do
-      if scanner.scan(%r!( +)<link rel="icon" type="image/png" href=".+">\n!)
-        matched = scanner.matched
-        file.write(matched)
-        file.write(scanner[1])
-        file.write(canonical_link)
-      end
-      ch = scanner.getch
-      if ch
-        file.write(ch)
-      else
-        break
-      end
-    end
-    mode = File.stat(entry).mode
-    file.flush
-    FileUtils.cp(file.path, entry)
-    File.chmod(mode, entry)
-  end
-end
-
-Dir.chdir(base_dir) do
-  Dir.glob("**/*.html") do |entry|
-    print entry
-    insert_canonical_url(canonical_base_url, entry)
-    print "\r"
-    print " " * entry.bytesize
-    print "\r"
-  end
-  puts "done"
-end

data/tools/statrefm.rb

@@ -1,98 +0,0 @@
-#!/usr/bin/env ruby
-
-class Error < StandardError; end
-
-def main
-  entries = parse(find_basedir(ARGV[0]))
-  puts '--- Status'
-  done = entries.select {|ent| ent.done? }.size
-  puts "#{done}/#{entries.size} files done (#{percent_str(done, entries.size)})"
-  puts
-  puts '--- Ranking by number of files'
-  ranking_table(entries) {|ent| 1 }.each_with_index do |(owner, n), idx|
-    printf "%2d %4d %-s\n", idx + 1, n, (owner || '(not yet)')
-  end
-  puts
-  puts '--- Ranking by Kbytes'
-  ranking_table(entries) {|ent| ent.size }.each_with_index do |(owner,n), idx|
-    printf "%2d %4d %-s\n", idx + 1, kb(n), (owner || '(not yet)')
-  end
-rescue Error => err
-  $stderr.puts err.message
-  exit 1
-end
-
-def find_basedir(dir)
-  [ dir, "#{dir}/api", "#{dir}/refm/api", "#{dir}/.." ].each do |basedir|
-    if File.file?("#{basedir}/ASSIGN")
-      return basedir
-    end
-  end
-  raise Error, "error: wrong directory: #{dir}"
-end
-
-def percent_str(n, base)
-  sprintf('%0.2f%%', percent(n, base))
-end
-
-def percent(n, base)
-  n * 100 / base.to_f
-end
-
-def kb(bytes)
-  if bytes % 1024 == 0
-    bytes / 1024
-  else
-    (bytes / 1024) + 1
-  end
-end
-
-def ranking_table(entries)
-  h = Hash.new(0)
-  entries.each do |ent|
-    h[ent.done? ? ent.owner : nil] += yield(ent)
-  end
-  h.to_a.sort_by {|owner, n| -n }
-end
-
-def parse(basedir)
-  File.open("#{basedir}/ASSIGN") {|f|
-    f.map {|line|
-      next if line.strip.empty?
-      next if /\A\#/ =~ line
-      Entry.new(basedir, *line.split)
-    }.compact
-  }
-end
-
-class Entry
-  def initialize(basedir, name, owner = nil, status = nil)
-    @basedir = basedir
-    @name = name
-    @owner = owner
-    @status = status
-    @path = nil
-  end
-
-  attr_reader :name
-  attr_reader :owner
-  attr_reader :status
-
-  def done?
-    @status == 'done'
-  end
-
-  def size
-    File.size(path())
-  rescue Error
-    0
-  end
-
-  def path
-    @path ||= ["#{@basedir}/src/#{@name}.rd",
-               "#{@basedir}/src/#{@name}"].detect {|path| File.file?(path) } or
-        raise Error, "file not found: library #{@name}"
-  end
-end
-
-main

data/tools/stattodo.rb

@@ -1,150 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'pathname'
-
-bindir = Pathname.new(__FILE__).realpath.dirname
-$LOAD_PATH.unshift((bindir + '../lib').realpath)
-
-require 'bitclust/preprocessor'
-require 'find'
-
-#ALL = 14349
-
-def main
-  cmd, hist, prefix = ARGV[0], ARGV[1], ARGV[2]
-  case cmd
-  when 'count'
-    count hist, prefix
-  when 'update'
-    update hist, prefix
-  else
-    $stderr.puts "unknown command: #{cmd}"
-    exit 1
-  end
-end
-
-def count(hist, prefix)
-  total = 0
-  curr = 0
-  Table.parse_file(hist).each do |ent|
-    n = count_todo_in_file(File.join(prefix, ent.name))
-    curr += n
-    total += ent.total
-    report_count ent.name, n, ent.total
-  end
-  report_count 'TOTAL', curr, total
-end
-
-def report_count(label, curr, all)
-  done = all - curr
-  printf "%-24s %5d/%5d (%6.2f%%)\n", label, done, all, percent(done, all)
-end
-
-def percent(done, all)
-  return 0 if all == 0
-  done * 100 / all.to_f
-end
-
-def update(hist, prefix)
-  table = Table.parse_file(hist)
-  table.each do |ent|
-    ent.push count_todo(File.join(prefix, ent.name))
-  end
-  File.open("#{hist}.tmp", 'w') {|f|
-    f.puts table.header
-    table.each do |ent|
-      f.puts ent.serialize
-    end
-  }
-  File.rename "#{hist}.tmp", hist
-end
-
-def count_todo(path)
-  if File.directory?(path)
-    count_todo_in_dir(path)
-  else
-    count_todo_in_file(path)
-  end
-end
-
-def count_todo_in_dir(dir)
-  n = 0
-  Dir.entries(dir).each do |ent|
-    next if /\A\./ =~ ent
-    path = File.join(dir, ent)
-    if File.extname(ent) == '.rd' and File.file?(path)
-      n += count_todo_in_file(path)
-    elsif File.directory?(path)
-      n += count_todo_in_dir(path)
-    end
-  end
-  n
-end
-
-def count_todo_in_file(path)
-  n = 0
-  File.open(path) {|f|
-    pp = BitClust::LineCollector.wrap(f)
-    pp.grep(/\A\#[@%]todo/) { n += 1 }
-  }
-  n
-end
-
-class Table
-  def Table.parse_file(path)
-    File.open(path) {|f|
-      _, *dates = f.gets.split
-      ents = f.map {|line|
-        name, *ns = line.split
-        Entry.new(name, ns.map {|n| n.to_i })
-      }
-      return new(dates, ents)
-    }
-  end
-
-  include Enumerable
-
-  def initialize(dates, ents)
-    @dates = dates
-    @entries = ents
-  end
-
-  attr_reader :dates
-  attr_reader :entries
-
-  def header
-    (["-"] + @dates).join(' ')
-  end
-
-  def each(&block)
-    @entries.each(&block)
-  end
-end
-
-class Entry
-  def initialize(name, ns)
-    @name = name
-    @counts = ns
-  end
-
-  attr_reader :name
-  attr_reader :counts
-
-  def total
-    @counts.first
-  end
-
-  def count
-    @counts.last
-  end
-
-  def push(n)
-    @counts.push n
-  end
-
-  def serialize
-    @name + "\t" + @counts.join("\t")
-  end
-end
-
-main

data/tools/update-database.rb

@@ -1,146 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'pathname'
-
-def srcdir_root
-  (Pathname.new(__FILE__).realpath.dirname + '..').cleanpath
-end
-
-$LOAD_PATH.unshift srcdir_root() + 'lib'
-
-require 'bitclust'
-require 'fileutils'
-require 'net/smtp'
-require 'socket'
-require 'time'
-require 'optparse'
-
-include FileUtils
-
-def main
-  version = '1.9.0'
-  host = nil
-  port = Net::SMTP.default_port
-  from = nil
-  to = nil
-
-  parser = OptionParser.new
-  parser.banner = "Usage: #{File.basename($0, '.*')} --from=ADDR --to=ADDR --smtp-host=NAME [--smtp-port-NUM] <refm-api-dir>"
-  parser.on('--from=ADDR', 'From: address of error report.') {|addr|
-    from = addr
-  }
-  parser.on('--to=ADDR', 'To: address of error report.') {|addr|
-    to = addr
-  }
-  parser.on('--smtp-host=NAME', 'SMTP host to send mail.') {|name|
-    host = name
-  }
-  parser.on('--smtp-port=NUM', 'SMTP port to send mail.') {|num|
-    port = num.to_i
-  }
-  parser.on('--help', 'Prints this message and quit.') {
-    puts parser.help
-    exit 0
-  }
-  begin
-    parser.parse!
-  rescue OptionParser::ParseError => err
-    $stderr.puts err.message
-    $stderr.puts parser.help
-    exit 1
-  end
-  unless ARGV.size == 1
-    $stderr.puts "wrong number of argument (expected 1)"
-    exit 1
-  end
-  reporter = SMTPReporter.new(:host => host, :port => port,
-                              :from => from, :to   => to)
-  cwd = ARGV[0]
-  Dir.chdir cwd
-  begin
-    update_database "#{cwd}/var/#{version}", "#{cwd}/src", version
-    clear_error
-  rescue BitClust::Error, Errno::ENOENT => err
-    reporter.report_error err if new_error?(err)
-    save_error err
-  end
-end
-
-def update_database(dbdir, doctree, version)
-  tmpdir = 'db.tmp'
-  build_database tmpdir, doctree, version
-  begin
-    File.rename dbdir, 'db.old'
-  rescue Errno::ENOENT
-  end
-  mkdir_p File.dirname(dbdir)
-  File.rename tmpdir, dbdir
-ensure
-  rm_rf 'db.old'
-  rm_rf tmpdir
-end
-
-def build_database(prefix, doctree, version)
-  db = BitClust::MethodDatabase.new(prefix)
-  db.init
-  db.transaction {
-    db.propset 'version', version
-    db.propset 'encoding', 'utf-8'
-  }
-  db.transaction {
-    db.update_by_stdlibtree doctree
-  }
-end
-
-LASTLOG_FILE = 'lasterror.log'
-
-def new_error?(err)
-  return true unless File.exist?(LASTLOG_FILE)
-  serialize_error(err) != File.read(LASTLOG_FILE)
-end
-
-def save_error(err)
-  File.open(LASTLOG_FILE, 'w') {|f|
-    f.write serialize_error(err)
-  }
-end
-
-def clear_error
-  rm_f LASTLOG_FILE
-end
-
-def serialize_error(err)
-  msgline = "#{err.message} (#{err.class})"
-  backtraces = err.backtrace.map {|s| "\t#{s}" }
-  ([msgline] + backtraces).join("\n")
-end
-
-class SMTPReporter
-  def initialize(h)
-    @host = h[:host]
-    @port = h[:port]
-    @from = h[:from]
-    @to = h[:to]
-  end
-
-  def report_error(err)
-    send_message "[build error] #{err.message}", serialize_error(err)
-  end
-
-  private
-
-  def send_message(subject, body)
-    Net::SMTP.start(@host, @port, Socket.gethostname) {|smtp|
-      smtp.send_mail(<<-End, @from, @to)
-Date: #{Time.now.rfc2822}
-From: #{@from}
-To: #{@to}
-Subject: #{subject}
-
-#{body}
-      End
-    }
-  end
-end
-
-main