bitclust-dev 0.5.0

data/tools/bc-convert.rb

@@ -0,0 +1,165 @@
+#!/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-list.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+
+bindir = Pathname.new(__FILE__).realpath.dirname
+$LOAD_PATH.unshift((bindir + '../lib').realpath)
+
+require 'bitclust'
+require 'optparse'
+
+def main
+  check_only = false
+  parser = OptionParser.new
+  parser.banner = "Usage: #{File.basename($0, '.*')} <file>..."
+  parser.on('-c', '--check-only', 'Check syntax and output status.') {
+    check_only = true
+  }
+  parser.on('--help', 'Prints this message and quit.') {
+    puts parser.help
+    exit
+  }
+  begin
+    parser.parse!
+  rescue OptionParser::ParseError => err
+    $stderr.puts err.message
+    exit 1
+  end
+
+  success = true
+  ARGV.each do |path|
+    begin
+      lib = BitClust::RRDParser.parse_stdlib_file(path)
+      if check_only
+        $stderr.puts "#{path}: OK"
+      else
+        show_library lib
+      end
+    rescue BitClust::WriterError => err
+      raise if $DEBUG
+      $stderr.puts "#{File.basename($0, '.*')}: FAIL: #{err.message}"
+      success = false
+    end
+  end
+  exit success
+end
+
+def show_library(lib)
+  puts "= Library #{lib.name}"
+  lib.classes.each do |c|
+    puts "#{c.type} #{c.name}"
+    c.each do |m|
+      puts "\t* #{m.klass.name}#{m.typemark}#{m.names.join(',')}"
+    end
+  end
+  unless lib.methods.empty?
+    puts "Additional Methods:"
+    lib.methods.each do |m|
+      puts "\t* #{m.klass.name}#{m.typemark}#{m.names.join(',')}"
+    end
+  end
+end
+
+main

data/tools/bc-methods.rb

@@ -0,0 +1,171 @@
+#!/usr/bin/env ruby
+#
+# bc-methods.rb -- list all methods of existing rubys.
+#
+# This program is derived from bc-vdtb.rb, posted in
+# [ruby-reference-manual:160] by sheepman.
+#
+
+require 'pathname'
+
+bindir = Pathname.new(__FILE__).realpath.dirname
+$LOAD_PATH.unshift((bindir + '../lib').realpath)
+
+require 'bitclust'
+require 'bitclust/crossrubyutils'
+require 'optparse'
+
+include BitClust::CrossRubyUtils
+
+def main
+  @requires = []
+  @verbose = false
+  @ver = RUBY_VERSION
+  mode = :list
+  target = nil
+  opts = OptionParser.new
+  opts.banner = "Usage: #{File.basename($0, '.*')} [-r<lib>] <classname>"
+  opts.on('-r LIB', 'Requires library LIB') {|lib|
+    @requires.push lib
+  }
+  opts.on('-v', '--verbose', "Prints each ruby's version") {
+    @verbose = true
+  }
+  opts.on('--diff=RDFILE', 'RD file name') {|path|
+    mode = :diff
+    target = path
+  }
+  opts.on('-c', '') {
+    @content = true
+    require 'bitclust/ridatabase'
+  }
+  opts.on('--ruby=[VER]', "The version of Ruby interpreter"){|ver|
+    @ver = ver
+  }
+  opts.on('--ri-database', 'The path of ri database'){|path|
+    @ri_path = path
+  }
+  opts.on('--help', 'Prints this message and quit.') {
+    puts opts.help
+    exit 0
+  }
+  begin
+    opts.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 opts.help
+    exit 1
+  end
+  classname = ARGV[0]
+
+  case mode
+  when :list
+    print_crossruby_table {|ruby| defined_methods(ruby, classname) }
+  when :diff
+    unless ruby = get_ruby(@ver)
+      raise "Not found Ruby interpreter of the given version"
+    end
+    keys = defined_methods(ruby, classname) 
+    lib = BitClust::RRDParser.parse_stdlib_file(target, { 'version' => @ver })
+    c = lib.fetch_class(classname)
+    list0 = lib.classes.find_all{|c0| /\A#{classname}\b/o =~ c0.name }
+    list0 = c.entries + list0
+    list = list0.map {|ent| ent.labels.map {|n| expand_mf(n) } }.flatten
+    if @content      
+      ri = @ri_path ? RiDatabase.open(@ri_path, nil) : RiDatabase.open_system_db
+      ri.current_class = c.name
+      mthds = ( ri.singleton_methods + ri.instance_methods )
+      fmt = Formatter.new
+      (keys - list).sort.each do |name|
+        mthd = mthds.find{|m| name == m.fullname }
+        if mthd
+          puts fmt.method_info(mthd.entry)
+        else
+          name = name.sub(/\A\w+#/, '')
+          puts "--- #{name}\n\#@todo\n\n"
+        end
+      end
+    else
+      (keys - list).sort.each do |name|
+        puts "-#{name}"
+      end
+      (list - keys).sort.each do |name|
+        puts "+#{name}" 
+      end
+    end
+  else
+    raise "must not happen: #{mode.inspect}"
+  end
+end
+
+def expand_mf(n)
+  if /\.\#/ =~ n
+    [n.sub(/\.\#/, '.'), n.sub(/\.\#/, '#')]
+  else
+    n
+  end
+end
+
+def crossrubyutils_sort_entries(ents)
+  ents.sort_by {|m| m_order(m) }
+end
+
+ORDER = { '.' => 1, '#' => 2, '::' => 3 }
+
+def m_order(m)
+  m, t, c = *m.reverse.split(/(\#|\.|::)/, 2)
+  [ORDER[t] || 0, m.reverse]
+end
+
+def defined_methods(ruby, classname)
+  req = @requires.map {|lib| "-r#{lib}" }.join(' ')
+  avoid_tracer = ""
+  avoid_tracer = "Tracer.off" if @requires.include?("tracer")
+  if classname == 'Object'
+     `#{ruby} #{req} -e '
+     c = #{classname}
+     c.singleton_methods(false).each do |m|
+       puts "#{classname}.\#{m}"
+     end
+     c.instance_methods(true).each do |m|
+       puts "#{classname}\\#\#{m}"
+     end
+   '`.split
+  elsif classname == 'Kernel'
+    `#{ruby} #{req} -e '
+     c = #{classname}
+     c.singleton_methods(true).each do |m|
+       puts "#{classname}.\#{m}"
+     end
+     ( c.private_instance_methods(false) && c.methods(false) ).each do |m|
+       puts "#{classname}\\#\#{m}"
+     end
+     Object::constants.delete_if{|c| cl = Object.const_get(c).class; cl == Class or cl == Module }.each do |m|
+       puts "#{classname}::\#{m}"
+     end
+     global_variables.each do |m|
+       puts "#{classname}\#{m}"
+     end
+   '`.split
+  else
+    `#{ruby} #{req} -e '
+    #{avoid_tracer}
+    c = #{classname}
+    c.singleton_methods(false).each do |m|
+      puts "#{classname}.\#{m}"
+    end
+    c.instance_methods(false).each do |m|
+      puts "#{classname}\\#\#{m}"
+    end
+    c.ancestors.map {|mod| mod.constants }.inject {|r,n| r-n }.each do |m|
+      puts "#{classname}::\#{m}"
+    end
+  '`.split
+  end
+end
+
+main

data/tools/bc-preproc.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+
+bindir = Pathname.new(__FILE__).realpath.dirname
+$LOAD_PATH.unshift((bindir + '../lib').realpath)
+
+require 'bitclust/rrdparser'
+require 'optparse'
+
+def main
+  params = {"version" => "1.9.0"}
+  parser = OptionParser.new
+  parser.banner = "Usage: #{File.basename($0, '.*')} <file>..."
+  parser.on('--param=KVPAIR', 'Set parameter by key/value pair.') {|kv|
+    k, v = kv.split('=', 2)
+    params[k] = v
+  }
+  parser.on('--help', 'Prints this message and quit.') {
+    puts parser.help
+    exit
+  }
+  begin
+    parser.parse!
+  rescue OptionParser::ParseError => err
+    $stderr.puts err.message
+    exit 1
+  end
+
+  ARGV.each do |path|
+    File.open(path) {|f|
+      BitClust::Preprocessor.wrap(f, params).each do |line|
+        puts line
+      end
+    }
+  end
+rescue BitClust::WriterError => err
+  $stderr.puts err.message
+  exit 1
+end
+
+main

data/tools/bc-rdoc.rb

@@ -0,0 +1,343 @@
+#!/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