bitclust-core 0.5.4 → 0.5.5

data/ChangeLog

@@ -1,3 +1,45 @@
+2012-10-09  Ippei Obayashi  <ohai@kmc.gr.jp>
+
+	* lib/bitclust/subcommands/server_command.rb
+	(BitClust::Subcommands::ServerCommand#initialize): fix set_srcdir call
+	(BitClust::Subcommands::ServerCommand#srcdir_root): fix default srcdir
+
+2012-09-24  okkez  <okkez000@gmail.com>
+
+	* lib/bitclust/subcommand.rb: split subcommands.
+
+	* lib/bitclust/subcommands/update_command.rb: split update
+	subcommand.
+
+	* lib/bitclust/subcommands/setup_command.rb: split setup
+	subcommand.
+
+	* lib/bitclust/subcommands/server_command.rb: split server
+	subcommand.
+
+	* lib/bitclust/subcommands/query_command.rb: split query
+	subcommand.
+
+	* lib/bitclust/subcommands/property_command.rb: split property
+	subcommand.
+
+	* lib/bitclust/subcommands/lookup_command.rb: split lookup
+	subcommand.
+
+	* lib/bitclust/subcommands/list_command.rb: split list subcommand.
+
+	* lib/bitclust/subcommands/init_command.rb: split init subcommand.
+
+2012-09-16  Sho Hashimoto  <sho-h@netlab.jp>
+
+	* lib/bitclust/subcommand.rb (BitClust::SetupCommand#checkout):
+	  check svn installed Windows, too. (see #7026)
+
+2012-09-15  Sho Hashimoto  <sho-h@netlab.jp>
+
+	* lib/bitclust/subcommand.rb (BitClust::ServerCommand#exec): start
+	  browser mingw, cygwin and bccwin. (same as r5167)
+
 2012-09-02  okkez  <okkez000@gmail.com>
 
 	* lib/bitclust/subcommand.rb (BitClust::SetupCommand#prepare): do

data/data/bitclust/template.lillia/library

@@ -13,44 +13,34 @@
 
 <%
     headline_push
-    err_classes = @entry.error_classes
-    modules = @entry.all_classes.select{|c| c.module? }.sort
-    objects = @entry.all_classes.select{|c| c.object? }.sort
-    classes = (@entry.all_classes - @entry.all_error_classes - modules - objects).sort
-
-    class_tree = classes.group_by{|c| c.superclass }
-    class_root = class_tree.keys.select{|c| !c || !classes.include?(c)}
-    class_root.map!{|c| class_tree[c] }.flatten!
-    err_class_tree = err_classes.group_by{|c| c.superclass }
-    err_class_root = err_class_tree.keys.select{|c| !c || !err_classes.include?(c)}
-    err_class_root.map!{|c| err_class_tree[c] }.flatten!
+    all_classes = @entry.all_classes
+    err_classes = @entry.all_error_classes.sort
+    modules = @entry.all_modules
+    objects = @entry.all_objects
+    classes = all_classes - err_classes - modules - objects
 %>
 
 
 <%= headline(_("Abstract")) %>
 <%= compile_rd(@entry.source) %>
-<% draw_tree = proc do |list, tree, indent = 0| %>
-<tr>
-<%   list.each do |c| %>
-<td class="signature" style="text-indent: <%= indent * 1.0%>em;"><span style="display:none"><%= "&nbsp;" * indent %></span>
-<%=    class_link(c.name, c.name) %></td>
-<td class="description"><%= compile_rd(c.synopsis_source) %></td>
-</tr>
-<%
-       tree && tree[c] && draw_tree.call(tree[c], tree, indent + 1)
-     end
-   end
-%>
 <%
-  [[class_root,     class_tree    ,  _('Classes')],
-   [modules,        nil           ,  _('Modules')],
-   [objects,        nil           ,  _('Objects')],
-   [err_class_root, err_class_tree,  _('Exception Classes')]].each do |cs, tree, msg|
+  [[classes,      _('Classes')],
+   [modules,      _('Modules')],
+   [objects,      _('Objects')],
+   [err_classes,  _('Exception Classes')]].each do |cs, msg|
     unless cs.empty?
 %>
 <%= headline(msg) %>
 <table class="entries libraries">
-<% draw_tree.call(cs, tree) %>
+<%    draw_tree(cs) do |c, indent| %>
+<tr>
+<td class="signature" style="text-indent: <%= indent * 1.0%>em;">
+<span style="display:none"><%= "&nbsp;" * indent %></span>
+<%= class_link(c.name, c.name) %>
+</td>
+<td class="description"><%= compile_rd(c.synopsis_source) %></td>
+</tr>
+<%    end %>
 </table>
 <%
     end

data/data/bitclust/template.offline/library

@@ -11,46 +11,34 @@
 
 <%
     headline_push
-    required_classes = (@entry.sublibraries & @entry.requires).map{|lib| lib.classes }.flatten
-    all_classes = (@entry.classes + required_classes).uniq.sort
-    err_classes = all_classes.select {|c| c.error_class? }.sort
-    modules = all_classes.select{|c| c.module? }.sort
-    objects = all_classes.select{|c| c.object? }.sort
-    classes = (all_classes - err_classes - modules - objects).sort
-
-    class_tree = classes.group_by{|c| c.superclass }
-    class_root = class_tree.keys.select{|c| !c || !classes.include?(c)}
-    class_root.map!{|c| class_tree[c] }.flatten!
-    err_class_tree = err_classes.group_by{|c| c.superclass }
-    err_class_root = err_class_tree.keys.select{|c| !c || !err_classes.include?(c)}
-    err_class_root.map!{|c| err_class_tree[c] }.flatten!
+    all_classes = @entry.all_classes
+    err_classes = @entry.all_error_classes.sort
+    modules = @entry.all_modules
+    objects = @entry.all_objects
+    classes = all_classes - err_classes - modules - objects
 %>
 
 
 <%= headline(_("Abstract")) %>
 <%= compile_rd(@entry.source) %>
-<% draw_tree = proc do |list, tree, indent = 0| %>
-<tr>
-<%   list.each do |c| %>
-<td class="signature" style="text-indent: <%= indent * 1.0%>em;"><span style="display:none"><%= "&nbsp;" * indent %></span>
-<%=    class_link(c.name, c.name) %></td>
-<td class="description"><%= compile_rd(c.synopsis_source) %></td>
-</tr>
-<%
-       tree && tree[c] && draw_tree.call(tree[c], tree, indent + 1)
-     end
-   end
-%>
 <%
-  [[class_root,     class_tree    ,  _('Classes')],
-   [modules,        nil           ,  _('Modules')],
-   [objects,        nil           ,  _('Objects')],
-   [err_class_root, err_class_tree,  _('Exception Classes')]].each do |cs, tree, msg|
+  [[classes,      _('Classes')],
+   [modules,      _('Modules')],
+   [objects,      _('Objects')],
+   [err_classes,  _('Exception Classes')]].each do |cs, msg|
     unless cs.empty?
 %>
 <%= headline(msg) %>
 <table class="entries libraries">
-<% draw_tree.call(cs, tree) %>
+<%    draw_tree(cs) do |c, indent| %>
+<tr>
+<td class="signature" style="text-indent: <%= indent * 1.0%>em;">
+<span style="display:none"><%= "&nbsp;" * indent %></span>
+<%= class_link(c.name, c.name) %>
+</td>
+<td class="description"><%= compile_rd(c.synopsis_source) %></td>
+</tr>
+<%    end %>
 </table>
 <%
     end

data/data/bitclust/template/library

@@ -13,46 +13,34 @@
 
 <%
     headline_push
-    required_classes = (@entry.sublibraries & @entry.requires).map{|lib| lib.classes }.flatten
-    all_classes = (@entry.classes + required_classes).uniq.sort
-    err_classes = all_classes.select {|c| c.error_class? }.sort
-    modules = all_classes.select{|c| c.module? }.sort
-    objects = all_classes.select{|c| c.object? }.sort
-    classes = (all_classes - err_classes - modules - objects).sort
-
-    class_tree = classes.group_by{|c| c.superclass }
-    class_root = class_tree.keys.select{|c| !c || !classes.include?(c)}
-    class_root.map!{|c| class_tree[c] }.flatten!
-    err_class_tree = err_classes.group_by{|c| c.superclass }
-    err_class_root = err_class_tree.keys.select{|c| !c || !err_classes.include?(c)}
-    err_class_root.map!{|c| err_class_tree[c] }.flatten!
+    all_classes = @entry.all_classes
+    err_classes = @entry.all_error_classes.sort
+    modules = @entry.all_modules
+    objects = @entry.all_objects
+    classes = all_classes - err_classes - modules - objects
 %>
 
 
 <%= headline(_("Abstract")) %>
 <%= compile_rd(@entry.source) %>
-<% draw_tree = proc do |list, tree, indent = 0| %>
-<tr>
-<%   list.each do |c| %>
-<td class="signature" style="text-indent: <%= indent * 1.0%>em;"><span style="display:none"><%= "&nbsp;" * indent %></span>
-<%=    class_link(c.name, c.name) %></td>
-<td class="description"><%= compile_rd(c.synopsis_source) %></td>
-</tr>
-<%
-       tree && tree[c] && draw_tree.call(tree[c], tree, indent + 1)
-     end
-   end
-%>
 <%
-  [[class_root,     class_tree    ,  _('Classes')],
-   [modules,        nil           ,  _('Modules')],
-   [objects,        nil           ,  _('Objects')],
-   [err_class_root, err_class_tree,  _('Exception Classes')]].each do |cs, tree, msg|
+  [[classes,      _('Classes')],
+   [modules,      _('Modules')],
+   [objects,      _('Objects')],
+   [err_classes,  _('Exception Classes')]].each do |cs, msg|
     unless cs.empty?
 %>
 <%= headline(msg) %>
 <table class="entries libraries">
-<% draw_tree.call(cs, tree) %>
+<%    draw_tree(cs) do |c, indent| %>
+<tr>
+<td class="signature" style="text-indent: <%= indent * 1.0%>em;">
+<span style="display:none"><%= "&nbsp;" * indent %></span>
+<%= class_link(c.name, c.name) %>
+</td>
+<td class="description"><%= compile_rd(c.synopsis_source) %></td>
+</tr>
+<%    end %>
 </table>
 <%
     end

data/lib/bitclust/database.rb

@@ -43,7 +43,7 @@ module BitClust
       @in_transaction = false
       @properties_dirty = false
     end
-    
+
     def dummy?
       not @prefix
     end

data/lib/bitclust/libraryentry.rb

@@ -114,6 +114,14 @@ module BitClust
       @all_error_classes ||= all_classes.select{|c| c.error_class? }
     end
 
+    def all_modules
+      @all_modules ||= all_classes.select{|c| c.module? }.sort
+    end
+
+    def all_objects
+      @all_objects ||= all_classes.select{|c| c.object? }.sort
+    end
+
     def require(lib)
       requires().push lib
     end

data/lib/bitclust/nameutils.rb

@@ -18,8 +18,8 @@ module BitClust
     LIBNAME_RE     = %r<[\w\-]+(/[\w\-]+)*>
     CONST_RE       = /[A-Z]\w*/
     CONST_PATH_RE  = /#{CONST_RE}(?:::#{CONST_RE})*/
-    CLASS_NAME_RE  = /(?:#{CONST_RE}|fatal)/
-    CLASS_PATH_RE  = /(?:#{CONST_PATH_RE}|fatal)/
+    CLASS_NAME_RE  = /(?:#{CONST_RE}|fatal|ARGF.class)/
+    CLASS_PATH_RE  = /(?:#{CONST_PATH_RE}|fatal|ARGF.class)/
     METHOD_NAME_RE = /\w+[?!=]?|===|==|=~|<=>|<=|>=|!=|!|!@|!~|\[\]=|\[\]|\*\*|>>|<<|\+@|\-@|[~+\-*\/%&|^<>`]/
     TYPEMARK_RE    = /(?:\.|\#|\.\#|::|\$)/
     METHOD_SPEC_RE = /#{CLASS_PATH_RE}#{TYPEMARK_RE}#{METHOD_NAME_RE}/
@@ -50,6 +50,7 @@ module BitClust
     end
 
     def method_spec?(str)
+      return false if str == "ARGF.class"
       (/\A#{METHOD_SPEC_RE}\z/o =~ str) ? true : false
     end
 
@@ -120,7 +121,8 @@ module BitClust
 
     # private module function
     def split_method_id(id)
-      return *id.split(%r<[/\.]>, 4)
+      c, rest = id.split("/")
+      return *[c, *rest.split(%r<[/\.]>, 3)]
     end
 
     NAME_TO_MARK = {

data/lib/bitclust/rrdparser.rb

@@ -193,21 +193,21 @@ module BitClust
 
     def read_includes(f, reopen = false)
       f.while_match(/\Ainclude\s/) do |line|
-tty_warn "#{line.location}: dynamic include is not implemented yet" if reopen
+        tty_warn "#{line.location}: dynamic include is not implemented yet" if reopen
         @context.include line.split[1]          unless reopen # FIXME
       end
     end
 
     def read_extends(f, reopen = false)
       f.while_match(/\Aextend\s/) do |line|
-tty_warn "#{line.location}: dynamic extend is not implemented yet" if reopen
+        tty_warn "#{line.location}: dynamic extend is not implemented yet" if reopen
         @context.extend line.split[1]           unless reopen # FIXME
       end
     end
 
-def tty_warn(msg)
-  $stderr.puts msg if $stderr.tty?
-end
+    def tty_warn(msg)
+      $stderr.puts msg if $stderr.tty?
+    end
 
     def read_level2_blocks(f)
       read_entries f

data/lib/bitclust/runner.rb

@@ -5,15 +5,20 @@ unless Object.const_defined?(:Encoding)
   $KCODE = 'UTF-8'
 end
 
-def srcdir_root
+def libdir
   Pathname.new(__FILE__).realpath.dirname.parent.cleanpath
 end
 
-$LOAD_PATH.unshift((srcdir_root() + 'lib').to_s)
+$LOAD_PATH.unshift(libdir.to_s)
 
 require 'bitclust'
 require 'bitclust/subcommand'
 
+subcommands_dir = libdir + "bitclust/subcommands"
+Dir.glob(File.join(subcommands_dir.to_s, "*.rb")) do |entry|
+  require "bitclust/subcommands/#{File.basename(entry, ".rb")}"
+end
+
 module BitClust
   class Runner
     def initialize
@@ -66,15 +71,15 @@ Global Options:
         exit 0
       }
       @subcommands = {
-        'init'     => BitClust::InitCommand.new,
-        'list'     => BitClust::ListCommand.new,
-        'lookup'   => BitClust::LookupCommand.new,
+        'init'     => BitClust::Subcommands::InitCommand.new,
+        'list'     => BitClust::Subcommands::ListCommand.new,
+        'lookup'   => BitClust::Subcommands::LookupCommand.new,
         'search'   => BitClust::Searcher.new,
-        'query'    => BitClust::QueryCommand.new,
-        'update'   => BitClust::UpdateCommand.new,
-        'property' => BitClust::PropertyCommand.new,
-        'setup'    => BitClust::SetupCommand.new,
-        'server'   => BitClust::ServerCommand.new,
+        'query'    => BitClust::Subcommands::QueryCommand.new,
+        'update'   => BitClust::Subcommands::UpdateCommand.new,
+        'property' => BitClust::Subcommands::PropertyCommand.new,
+        'setup'    => BitClust::Subcommands::SetupCommand.new,
+        'server'   => BitClust::Subcommands::ServerCommand.new,
       }
     end
 

data/lib/bitclust/screen.rb

@@ -458,6 +458,29 @@ module BitClust
     def body
       run_template('library')
     end
+
+    def draw_tree(cs, &block)
+      return if cs.empty?
+      if cs.first.class?
+        tree = cs.group_by{|c| c.superclass }
+        tree.each {|key, list| list.sort_by!{|c| c ? c.name : "" } }
+        roots = tree.keys.select{|c| !c || !cs.include?(c) }
+        roots.map!{|c| tree[c] }.flatten!
+      else
+        tree = {}
+        roots = cs
+      end
+      draw_treed_entries(roots, tree, &block)
+    end
+
+    private
+
+    def draw_treed_entries(entries, tree, indent = 0, &block)
+      entries.each do |c|
+        yield c, indent
+        draw_treed_entries(tree[c], tree, indent + 1, &block) if tree[c]
+      end
+    end
   end
 
   class ClassIndexScreen < IndexScreen

data/lib/bitclust/subcommand.rb

@@ -24,733 +24,10 @@ module BitClust
       exit 1
     end
   end
+end
 
-
-  class InitCommand < Subcommand
-
-    def initialize
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} init [KEY=VALUE ...]"
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
-
-    STANDARD_PROPERTIES = %w( encoding version )
-
-    def exec(db, argv)
-      db.init
-      db.transaction {
-        argv.each do |kv|
-          k, v = kv.split('=', 2)
-          db.propset k, v
-        end
-      }
-      fail = false
-      STANDARD_PROPERTIES.each do |key|
-        unless db.propget(key)
-          $stderr.puts "#{File.basename($0, '.*')}: warning: standard property `#{key}' not given"
-          fail = true
-        end
-      end
-      if fail
-        $stderr.puts "---- Current Properties ----"
-        db.properties.each do |key, value|
-          $stderr.puts "#{key}=#{value}"
-        end
-      end
-    end
-
-  end
-
-
-  class UpdateCommand < Subcommand
-
-    def initialize
-      @root = nil
-      @library = nil
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} update [<file>...]"
-        opt.on('--stdlibtree=ROOT', 'Process stdlib source directory tree.') {|path|
-          @root = path
-        }
-        opt.on('--library-name=NAME', 'Use NAME for library name in file mode.') {|name|
-          @library = name
-        }
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
-
-    def parse(argv)
-      super
-      if not @root and argv.empty?
-        error "no input file given"
-      end
-    end
-
-    def exec(db, argv)
-      db.transaction {
-        if @root
-          db.update_by_stdlibtree @root
-        end
-        argv.each do |path|
-          db.update_by_file path, @library || guess_library_name(path)
-        end
-      }
-    end
-
-    private
-
-    def guess_library_name(path)
-      if %r<(\A|/)src/> =~ path
-        path.sub(%r<.*(\A|/)src/>, '').sub(/\.rd\z/, '')
-      else
-        path
-      end
-    end
-
-    def get_c_filename(path)
-      File.basename(path, '.rd')
-    end
-
-  end
-
-
-  class ListCommand < Subcommand
-
-    def initialize
-      @mode = nil
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} list (--library|--class|--method|--function)"
-        opt.on('--library', 'List libraries.') {
-          @mode = :library
-        }
-        opt.on('--class', 'List classes.') {
-          @mode = :class
-        }
-        opt.on('--method', 'List methods.') {
-          @mode = :method
-        }
-        opt.on('--function', 'List functions.') {
-          @mode = :function
-        }
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
-
-    def parse(argv)
-      super
-      unless @mode
-        error 'one of (--library|--class|--method|--function) is required'
-      end
-    end
-
-    def exec(db, argv)
-      case @mode
-      when :library
-        db.libraries.map {|lib| lib.name }.sort.each do |name|
-          puts name
-        end
-      when :class
-        db.classes.map {|c| c.name }.sort.each do |name|
-          puts name
-        end
-      when :method
-        db.classes.sort_by {|c| c.name }.each do |c|
-          c.entries.sort_by {|m| m.id }.each do |m|
-            puts m.label
-          end
-        end
-      when :function
-        db.functions.sort_by {|f| f.name }.each do |f|
-          puts f.name
-        end
-      else
-        raise "must not happen: @mode=#{@mode.inspect}"
-      end
-    end
-
-  end
-
-
-  class LookupCommand < Subcommand
-
-    def initialize
-      @format = :text
-      @type = nil
-      @key = nil
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} lookup (--library|--class|--method|--function) [--html] <key>"
-        opt.on('--library=NAME', 'Lookup library.') {|name|
-          @type = :library
-          @key = name
-        }
-        opt.on('--class=NAME', 'Lookup class.') {|name|
-          @type = :class
-          @key = name
-        }
-        opt.on('--method=NAME', 'Lookup method.') {|name|
-          @type = :method
-          @key = name
-        }
-        opt.on('--function=NAME', 'Lookup function.') {|name|
-          @type = :function
-          @key = name
-        }
-        opt.on('--html', 'Show result in HTML.') {
-          @format = :html
-        }
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
-
-    def parse(argv)
-      super
-      unless @type
-        error "one of --library/--class/--method/--function is required"
-      end
-      unless argv.empty?
-        error "too many arguments"
-      end
-    end
-
-    def exec(db, argv)
-      entry = fetch_entry(db, @type, @key)
-      puts fill_template(get_template(@type, @format), entry)
-    end
-
-    def fetch_entry(db, type, key)
-      case type
-      when :library
-        db.fetch_library(key)
-      when :class
-        db.fetch_class(key)
-      when :method
-        db.fetch_method(BitClust::MethodSpec.parse(key))
-      when :function
-        db.fetch_function(key)
-      else
-        raise "must not happen: #{type.inspect}"
-      end
-    end
-
-    def fill_template(template, entry)
-      ERB.new(template).result(binding())
-    end
-
-    def get_template(type, format)
-      template = TEMPLATE[type][format]
-      BitClust::TextUtils.unindent_block(template.lines).join('')
-    end
-
-    TEMPLATE = {
-      :library => {
-        :text => <<-End,
-           type: library
-           name: <%= entry.name %>
-           classes: <%= entry.classes.map {|c| c.name }.sort.join(', ') %>
-           methods: <%= entry.methods.map {|m| m.name }.sort.join(', ') %>
-
-           <%= entry.source %>
-           End
-        :html => <<-End
-           <dl>
-           <dt>type</dt><dd>library</dd>
-           <dt>name</dt><dd><%= entry.name %></dd>
-           <dt>classes</dt><dd><%= entry.classes.map {|c| c.name }.sort.join(', ') %></dd>
-           <dt>methods</dt><dd><%= entry.methods.map {|m| m.name }.sort.join(', ') %></dd>
-           </dl>
-           <%= compile_rd(entry.source) %>
-           End
-      },
-      :class   => {
-        :text => <<-End,
-           type: class
-           name: <%= entry.name %>
-           library: <%= entry.library.name %>
-           singleton_methods: <%= entry.singleton_methods.map {|m| m.name }.sort.join(', ') %>
-           instance_methods: <%= entry.instance_methods.map {|m| m.name }.sort.join(', ') %>
-           constants: <%= entry.constants.map {|m| m.name }.sort.join(', ') %>
-           special_variables: <%= entry.special_variables.map {|m| '$' + m.name }.sort.join(', ') %>
-
-           <%= entry.source %>
-           End
-        :html => <<-End
-           <dl>
-           <dt>type</dt><dd>class</dd>
-           <dt>name</dt><dd><%= entry.name %></dd>
-           <dt>library</dt><dd><%= entry.library.name %></dd>
-           <dt>singleton_methods</dt><dd><%= entry.singleton_methods.map {|m| m.name }.sort.join(', ') %></dd>
-           <dt>instance_methods</dt><dd><%= entry.instance_methods.map {|m| m.name }.sort.join(', ') %></dd>
-           </dl>
-           <%= compile_rd(entry.source) %>
-           End
-      },
-      :method  => {
-        :text => <<-End,
-           type: <%= entry.type %>
-           name: <%= entry.name %>
-           names: <%= entry.names.sort.join(', ') %>
-           visibility: <%= entry.visibility %>
-           kind: <%= entry.kind %>
-           library: <%= entry.library.name %>
-
-           <%= entry.source %>
-           End
-        :html => <<-End
-           <dl>
-           <dt>type</dt><dd><%= entry.type %></dd>
-           <dt>name</dt><dd><%= entry.name %></dd>
-           <dt>names</dt><dd><%= entry.names.sort.join(', ') %></dd>
-           <dt>visibility</dt><dd><%= entry.visibility %></dd>
-           <dt>kind</dt><dd><%= entry.kind %></dd>
-           <dt>library</dt><dd><%= entry.library.name %></dd>
-           </dl>
-           <%= compile_rd(entry.source) %>
-           End
-      },
-      :function => {
-        :text => <<-End,
-           kind: <%= entry.kind %>
-           header: <%= entry.header %>
-           filename: <%= entry.filename %>
-
-           <%= entry.source %>
-           End
-        :html => <<-End
-           <dl>
-           <dt>kind</dt><dd><%= entry.kind %></dd>
-           <dt>header</dt><dd><%= entry.header %></dd>
-           <dt>filename</dt><dd><%= entry.filename %></dd>
-           </dl>
-           <%= compile_rd(entry.source) %>
-           End
-      }
-    }
-
-    def compile_rd(src)
-      umap = BitClust::URLMapper.new(:base_url => 'http://example.com',
-                                     :cgi_url  => 'http://example.com/view')
-      compiler = BitClust::RDCompiler.new(umap, 2)
-      compiler.compile(src)
-    end
-
-  end
-
-
-  class QueryCommand < Subcommand
-
-    def initialize
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} query <ruby-script>"
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
-
-    def parse(argv)
-    end
-
-    def exec(db, argv)
-      argv.each do |query|
-        #pp eval(query)   # FIXME: causes ArgumentError
-        p eval(query)
-      end
-    end
-  end
-
-
-  class PropertyCommand < Subcommand
-
-    def initialize
-      @mode = nil
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} property [options]"
-        opt.on('--list', 'List all properties.') {
-          @mode = :list
-        }
-        opt.on('--get', 'Get property value.') {
-          @mode = :get
-        }
-        opt.on('--set', 'Set property value.') {
-          @mode = :set
-        }
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
-
-    def parse(argv)
-      super
-      unless @mode
-        error "one of (--list|--get|--set) is required"
-      end
-      case @mode
-      when :list
-        unless argv.empty?
-          error "--list requires no argument"
-        end
-      when :get
-        ;
-      when :set
-        unless argv.size == 2
-          error "--set requires just 2 arguments"
-        end
-      else
-        raise "must not happen: #{@mode}"
-      end
-    end
-
-    def exec(db, argv)
-      case @mode
-      when :list
-        db.properties.each do |key, val|
-          puts "#{key}=#{val}"
-        end
-      when :get
-        argv.each do |key|
-          puts db.propget(key)
-        end
-      when :set
-        key, val = *argv
-        db.transaction {
-          db.propset key, val
-        }
-      else
-        raise "must not happen: #{@mode}"
-      end
-    end
-
-  end
-
-  class SetupCommand < Subcommand
-
-    REPOSITORY_PATH = "http://jp.rubyist.net/svn/rurema/doctree/trunk"
-
-    def initialize
-      @prepare = nil
-      @cleanup = nil
-      @versions = ["1.8.7", "1.9.3"]
-      @parser = OptionParser.new {|opt|
-        opt.banner = "Usage: #{File.basename($0, '.*')} setup [options]"
-        opt.on('--prepare', 'Prepare config file and checkout repository. Do not create database.') {
-          @prepare = true
-        }
-        opt.on('--cleanup', 'Cleanup datebase before create database.') {
-          @cleanup = true
-        }
-        opt.on('--versions=V1,V2,...', "Specify versions. [#{@versions.join(',')}]") {|versions|
-          @versions = versions.split(",")
-        }
-        opt.on('--help', 'Prints this message and quit.') {
-          puts opt.help
-          exit 0
-        }
-      }
-    end
-
-    def exec(db, argv)
-      prepare
-      return if @prepare
-      @config[:versions].each do |version|
-        puts "Generating database for Ruby#{version}..."
-        prefix = "#{@config[:database_prefix]}-#{version}"
-        FileUtils.rm_rf(prefix) if @cleanup
-        init_argv = ["version=#{version}", "encoding=#{@config[:encoding]}"]
-        db = BitClust::MethodDatabase.new(prefix)
-        InitCommand.new.exec(db, init_argv)
-        update_method_database(prefix, ["--stdlibtree=#{@config[:stdlibtree]}"])
-        argv = Pathname(@config[:capi_src]).children.select(&:file?).map{|v| v.realpath.to_s }
-        update_function_database(prefix, argv)
-      end
-    end
-
-    private
-
-    def prepare
-      home_directory = Pathname(ENV["HOME"])
-      config_dir = home_directory + ".bitclust"
-      config_dir.mkpath
-      config_path = config_dir + "config"
-      rubydoc_dir = config_dir + "rubydoc"
-      @config = {
-        :database_prefix => (config_dir + "db").to_s,
-        :encoding => "utf-8",
-        :versions => @versions,
-        :default_version => @versions.max,
-        :stdlibtree => (rubydoc_dir + "refm/api/src").to_s,
-        :capi_src => (rubydoc_dir + "refm/capi/src/").to_s,
-        :baseurl => "http://localhost:10080",
-        :port => "10080",
-        :pid_file => "/tmp/bitclust.pid",
-      }
-      if config_path.exist?
-        @config = YAML.load_file(config_path)
-        unless @config[:versions].sort == @versions.sort
-          print("overwrite config file? > [y/N]")
-          if /\Ay\z/i =~ $stdin.gets.chomp
-            @config[:versions] = @versions
-            @config[:default_version] = @versions.max
-            generate_config(config_path, @config)
-          end
-        end
-      else
-        generate_config(config_path, @config)
-      end
-      checkout(rubydoc_dir)
-    end
-
-    def generate_config(path, config)
-      path.open("w+", 0644) do |file|
-        file.puts config.to_yaml
-      end
-    end
-
-    def checkout(rubydoc_dir)
-      # FIXME Is this working on Windows?
-      unless system("which svn > /dev/null")
-        warn "svn command is not found. Please install Subversion."
-        exit 1
-      end
-      system("svn", "co", REPOSITORY_PATH, rubydoc_dir.to_s)
-    end
-
-    def update_method_database(prefix, argv)
-      db = BitClust::MethodDatabase.new(prefix)
-      cmd = UpdateCommand.new
-      cmd.parse(argv)
-      cmd.exec(db, argv)
-    end
-
-    def update_function_database(prefix, argv)
-      db = BitClust::FunctionDatabase.new(prefix)
-      cmd = UpdateCommand.new
-      cmd.parse(argv)
-      cmd.exec(db, argv)
-    end
-
-  end
-
-  class ServerCommand < Subcommand
-
-    def initialize
-      require 'webrick'
-      require 'uri'
-
-      @params = {
-        :BindAddress => "0.0.0.0",
-        :Port => 10080
-      }
-      @baseurl = nil
-      @dbpath = nil
-      @srcdir = @datadir = @themedir = @theme = @templatedir = nil
-      @encoding = 'utf-8'   # encoding of view
-      if Object.const_defined?(:Encoding)
-        Encoding.default_external = @encoding
-      end
-
-      @debugp = false
-      @autop = false
-      @browser = nil
-      @pid_file = nil
-      @capi = false
-
-      @parser = OptionParser.new
-      @parser.banner = "#{$0} [--bind-address=ADDR] [--port=NUM] --baseurl=URL --database=PATH [--srcdir=PATH] [--datadir=PATH] [--themedir=PATH] [--debug] [--auto] [--browser=BROWSER] [--pid-file=PATH] [--capi]"
-      @parser.on('--bind-address=ADDR', 'Bind address') {|addr|
-        @params[:BindAddress] = addr
-      }
-      @parser.on('--port=NUM', 'Listening port number') {|num|
-        @params[:Port] = num.to_i
-      }
-      @parser.on('--baseurl=URL', 'The base URL to host.') {|url|
-        @baseurl = url
-      }
-      @parser.on('--database=PATH', 'MethodDatabase root directory.') {|path|
-        @dbpath = path
-      }
-      @parser.on('--srcdir=PATH', 'BitClust source directory.') {|path|
-        @set_srcdir.call path
-      }
-      @parser.on('--datadir=PATH', 'BitClust data directory.') {|path|
-        @datadir = path
-      }
-      @parser.on('--templatedir=PATH', 'Template directory.') {|path|
-        @templatedir = path
-      }
-      @parser.on('--themedir=PATH', 'BitClust theme directory.') {|path|
-        @themedir = path
-      }
-      @parser.on('--theme=THEME', 'BitClust theme.') {|th|
-        @theme = th
-      }
-      @parser.on('--[no-]debug', 'Debug mode.') {|flag|
-        @debugp = flag
-      }
-      @parser.on('--[no-]auto', 'Auto mode.') {|flag|
-        @autop = flag
-      }
-      @parser.on('--browser=BROWSER', 'Open with the browser.') {|path|
-        @browser = path
-      }
-      @parser.on('--pid-file=PATH', 'Write pid of the daemon to the specified file.') {|path|
-        @pid_file = path
-      }
-      @parser.on('--help', 'Prints this message and quit.') {
-        puts @parser.help
-        exit 0
-      }
-      @parser.on('--capi', 'see also FunctionDatabase.') {|path|
-        @capi = true
-      }
-    end
-
-    def parse(argv)
-      super
-      load_config_file
-      set_srcdir(srcdir_root) unless @srcdir
-
-      unless @baseurl
-        $stderr.puts "missing base URL.  Use --baseurl or check ~/.bitclust/config"
-        exit 1
-      end
-      unless @dbpath || @autop
-        $stderr.puts "missing database path.  Use --database"
-        exit 1
-      end
-      unless @datadir
-        $stderr.puts "missing datadir.  Use --datadir"
-        exit 1
-      end
-      unless @themedir
-        $stderr.puts "missing themedir.  Use --themedir"
-        exit 1
-      end
-      if @pid_file
-        if File.exist?(@pid_file)
-          $stderr.puts "There is still #{@pid_file}.  Is another process running?"
-          exit 1
-        end
-        @pid_file = File.expand_path(@pid_file)
-      end
-    end
-
-    def exec(db, argv)
-      require 'bitclust/app'
-      if @debugp
-        @params[:Logger] = WEBrick::Log.new($stderr, WEBrick::Log::DEBUG)
-        @params[:AccessLog] = [
-          [ $stderr, WEBrick::AccessLog::COMMON_LOG_FORMAT  ],
-          [ $stderr, WEBrick::AccessLog::REFERER_LOG_FORMAT ],
-          [ $stderr, WEBrick::AccessLog::AGENT_LOG_FORMAT   ],
-       ]
-      else
-        @params[:Logger] = WEBrick::Log.new($stderr, WEBrick::Log::INFO)
-        @params[:AccessLog] = []
-      end
-      basepath = URI.parse(@baseurl).path
-      server = WEBrick::HTTPServer.new(@params)
-
-      if @autop
-        app = BitClust::App.new(
-          :dbpath => Dir.glob("#{@database_prefix}-*"),
-          :baseurl => @baseurl,
-          :datadir => @datadir,
-          :templatedir => @templatedir,
-          :theme => @theme,
-          :encoding => @encoding,
-          :capi => @capi
-        )
-        app.interfaces.each do |version, interface|
-          server.mount(File.join(basepath, version), interface)
-        end
-        server.mount(File.join(basepath, '/'), app)
-      else
-        viewpath = File.join(basepath, 'view')
-        app = BitClust::App.new(
-          :viewpath => viewpath,
-          :dbpath => @dbpath,
-          :baseurl => @baseurl,
-          :datadir => @datadir,
-          :templatedir => @templatedir,
-          :theme => @theme,
-          :encoding => @encoding,
-          :capi => @capi
-        )
-        app.interfaces.each do |viewpath, interface|
-          server.mount viewpath, interface
-        end
-        # Redirect from '/' to "#{viewpath}/"
-        server.mount('/', app)
-      end
-
-      server.mount File.join(basepath, 'theme/'), WEBrick::HTTPServlet::FileHandler, @themedir
-
-      if @debugp
-        trap(:INT) { server.shutdown }
-      else
-        WEBrick::Daemon.start do
-          trap(:TERM) {
-            server.shutdown
-            begin
-              File.unlink @pid_file if @pid_file
-            rescue Errno::ENOENT
-            end
-          }
-          File.open(@pid_file, 'w') {|f| f.write Process.pid } if @pid_file
-        end
-      end
-      exit if $".include?("exerb/mkexy.rb")
-      if @autop && !@browser
-        case RUBY_PLATFORM
-        when /mswin/
-          @browser = "start"
-        end
-      end
-      system("#{browser} http://localhost:#{params[:Port]}/") if @browser
-      server.start
-    end
-
-    private
-
-    def srcdir_root
-      Pathname.new(__FILE__).realpath.dirname.parent.parent.cleanpath
-    end
-
-    def set_srcdir(dir)
-      @srcdir ||= dir
-      @datadir ||= "#{@srcdir}/data/bitclust"
-      @themedir ||= "#{@srcdir}/theme"
-    end
-
-    def load_config_file
-      home_directory = Pathname(ENV['HOME'])
-      config_path = home_directory + ".bitclust/config"
-      if config_path.exist?
-        config = YAML.load_file(config_path)
-        @baseurl  ||= config[:baseurl]
-        @dbpath   ||= "#{config[:database_prefix]}-#{config[:default_version]}"
-        @port     ||= config[:port]
-        @pid_file ||= config[:pid_file]
-        @database_prefix ||= config[:database_prefix]
-      end
-    end
-
+module BitClust
+  module Subcommands
   end
-
 end
+