bitclust-core 0.5.3 → 0.5.4

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/lib/bitclust/server.rb

@@ -1,59 +0,0 @@
-#
-# bitclust/server.rb
-#
-# Copyright (c) 2006-2008 Minero Aoki
-#
-# This program is free software.
-# You can distribute/modify this program under the Ruby License.
-#
-
-require 'bitclust/methoddatabase'
-require 'bitclust/functiondatabase'
-require 'bitclust/libraryentry'
-require 'bitclust/classentry'
-require 'bitclust/methodentry'
-require 'bitclust/docentry'
-require 'drb'
-require 'webrick/server'
-
-module BitClust
-
-  class Server
-
-    def initialize(db)
-      @db = db
-    end
-
-    def listen(url, foreground = false)
-      WEBrick::Daemon.start unless foreground
-      DRb.start_service url, @db
-      DRb.thread.join
-    end
-
-  end
-
-  class Database   # reopen
-    include DRb::DRbUndumped
-  end
-
-  class Entry   # reopen
-    include DRb::DRbUndumped
-  end
-
-  class SearchResult   # reopen
-    include DRb::DRbUndumped
-  end
-
-end
-
-class Object
-  def _remote_object?
-    false
-  end
-end
-
-class DRb::DRbObject
-  def _remote_object?
-    true
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/lib/bitclust/simplesearcher.rb

@@ -1,84 +0,0 @@
-require 'bitclust/nameutils'
-require 'bitclust/methodid'
-
-module BitClust
-  module SimpleSearcher
-    include NameUtils
-
-    module_function
-    
-    def search_pattern(db, pat)
-      pat = to_pattern(pat)
-      return [] if pat.empty? or /\A\s+\z/ =~ pat
-      cname, type, mname = parse_method_spec_pattern(pat)
-      ret = cs = ms = []
-      if cname and not cname.empty?
-        if mname
-          ms = find_class_method(db, cname, type, mname)
-          cs += find_class(db, cname + '::' + mname) if /\A[A-Z]/ =~ mname
-        else
-          cs = find_class(db, cname)
-        end
-      elsif type == '$'
-        ms = find_special_vars(db, mname)
-      else
-        ms = find_methods(db, mname)        
-      end
-      ms = ms.sort_by{|e| [e.library.name, e.klass.name] }
-      cs = cs.sort_by{|e| [e.library.name] }
-      cs + ms
-    end
-
-    def find_class(db, cname)
-      db.classes.find_all{|c| /\b#{Regexp.escape(cname)}\w*\z/ =~ c.name }
-    end
-    
-    def find_class_method(db, cname, type, mname)
-      ret = []
-      db.classes.each{|c|
-        if /\b#{Regexp.escape(cname)}/ =~ c.name
-          ret += c.methods.find_all{|m|
-            m.names.any?{|n| /\A#{Regexp.escape(mname)}/ =~ n }
-          }
-        end
-      }
-      ret
-    end
-
-    def find_methods(db, mname)
-      db.methods.find_all{|m|
-        m.names.any?{|n| /\A#{Regexp.escape(mname)}/ =~ n }
-      }
-    end
-
-    def find_special_vars(db, mname)
-      db.get_class('Kernel').special_variables.find_all{|m|
-        m.names.any?{|n| /\A#{Regexp.escape(mname)}/ =~ n }
-      }
-    end
-
-    def to_pattern(pat)
-      pat = pat.to_str
-      pat = pat[/\A\s*(.*?)\s*\z/, 1]                  
-    end
-    
-    def parse_method_spec_pattern(pat)
-      if /\s/ =~ pat
-        return parse_method_spec_pattern0(pat)
-      end
-      return pat, nil, nil if /\A[A-Z]\w*\z/ =~ pat
-      return nil, '$', $1  if /\$(\S*)/ =~ pat
-      _m, _t, _c = pat.reverse.split(/(::|[\#,]\.|\.[\#,]|[\#\.\,])/, 2)
-      c = _c.reverse if _c
-      t = _t.tr(',', '#').sub(/\#\./, '.#') if _t
-      m = _m.reverse
-      return c, t, m
-    end
-
-    def parse_method_spec_pattern0(q)
-      q = q.scan(/\S+/)[0..1]
-      q = q.reverse unless /\A[A-Z]/ =~ q[0]
-      return q[0], nil, q[1]
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/lib/bitclust/subcommand.rb

@@ -1,746 +0,0 @@
-require 'pathname'
-
-require 'bitclust'
-require 'erb'
-require 'find'
-require 'pp'
-require 'optparse'
-require 'yaml'
-
-module BitClust
-
-  class Subcommand
-    def parse(argv)
-      @parser.parse! argv
-    end
-
-    def help
-      @parser.help
-    end
-
-    # TODO refactor
-    def error(message)
-      $stderr.puts "#{File.basename($0, '.*')}: error: #{message}"
-      exit 1
-    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.2", "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] == @versions
-          @config[:versions] = @versions
-          @config[:default_version] = @versions.max
-        end
-        generate_config(config_path, @config)
-      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)
-      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 = {
-        :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("db-*"),
-          :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]
-      end
-    end
-
-  end
-
-end