bitclust-dev 0.5.0

data/tools/check-signature.rb

@@ -0,0 +1,19 @@
+#!/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/forall-ruby.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+
+bindir = Pathname.new(__FILE__).realpath.dirname
+$LOAD_PATH.unshift((bindir + '../lib').realpath)
+
+require 'bitclust/crossrubyutils'
+
+include BitClust::CrossRubyUtils
+
+def main
+  ENV.delete('GEM_HOME')
+  forall_ruby(ENV['PATH']) do |ruby, ver|
+    puts ver
+    system ruby, *ARGV
+  end
+end
+
+main

data/tools/gencatalog.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+#
+# gencatalog.rb
+#
+# Copyright (c) 2008 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+require 'optparse'
+
+def main
+  catalog_path = nil
+  parser = OptionParser.new
+  parser.banner = "Usage: #{File.basename($0)} --merge=PATH [<file>...]"
+  parser.on('--merge=PATH', 'Current catalog file.') {|path|
+    catalog_path = path
+  }
+  parser.on('--help', 'Prints this message and quit.') {
+    puts parser.help
+    exit 0
+  }
+  begin
+    parser.parse!
+  rescue OptionParser::ParseError => err
+    $stderr.puts err
+    $stderr.puts parser.help
+    exit 1
+  end
+
+  h = collect_messages(ARGF)
+  h.update load_catalog(catalog_path) if catalog_path
+  print_catalog h
+end
+
+def print_catalog(h)
+  h.keys.sort.each do |key|
+    puts key
+    puts h[key]
+  end
+end
+
+def collect_messages(f)
+  h = {}
+  f.each do |line|
+    line.scan(/_\(
+        (?: "( (?:[^"]+|\\.)* )"
+          | '( (?:[^']+|\\.)* )'
+          )
+    /x) do
+      text = ($1 || $2).strip
+      h[text] = text unless text.empty?
+    end
+  end
+  h
+end
+
+def load_catalog(path)
+  h = {}
+  File.open(path) {|f|
+    f.each do |line|
+      h[line.chomp] = f.gets.chomp
+    end
+  }
+  h
+end
+
+main

data/tools/statrefm.rb

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

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

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