bitclust-core 0.5.0

data/lib/bitclust/refsdatabase.rb

@@ -0,0 +1,66 @@
+#
+# bitclust/refsdatabase.rb
+#
+# This program is free software.
+# You can distribute this program under the Ruby License.
+#
+
+module BitClust
+  class RefsDatabase
+    def self.load(src)
+      if src.respond_to?(:to_str)
+        buf = fopen(src.to_str, 'r:UTF-8'){|f| f.read}
+      elsif src.respond_to?(:to_io)
+        buf = src.to_io.read
+      else
+        buf = src.read
+      end
+
+      refs = self.new
+      buf.each_line{|l|
+        if /((?:\\,|[^,])+),((?:\\,|[^,])+),((?:\\,|[^,])+),((?:\\,|[^,])+)\n/ =~ l
+          type, id, linkid, desc = [$1, $2, $3, $4].map{|e| e.gsub(/\\(.)/){|s| $1 == ',' ? ',' : s } }
+          refs[type, id, linkid] = desc          
+        end
+      }
+      refs
+    end
+
+    def initialize
+      @h = {}
+    end
+
+    def []=(type, mid, linkid, desc)
+      @h[[type.to_s, mid, linkid]] = desc
+    end
+
+    def [](type, mid, linkid)
+      @h[[type.to_s, mid, linkid]]
+    end
+
+    def save(s)
+      if s.respond_to?(:to_str)
+        path = s.to_str
+        io = fopen(path, 'w:UTF-8')
+      elsif s.respond_to?(:to_io)
+        io = s.to_io
+      else
+        io = s
+      end
+
+      @h.each{|k, v|
+        io.write(  [k, v].flatten.map{|e| e.gsub(/,/, '\\,') }.join(',') + "\n" )
+      }
+    end
+
+    def extract(entry)
+      entry.source.each_line{|l|
+        if /\A={1,6}\[a:(\w+)\] *(.*)/ =~ l
+          entry.labels.each{|name|
+            self[entry.class.type_id, name, $1] = $2
+          }
+        end
+      }
+    end
+  end
+end

data/lib/bitclust/requesthandler.rb

@@ -0,0 +1,330 @@
+#
+# bitclust/requesthandler.rb
+#
+# Copyright (c) 2006-2008 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+require 'bitclust/compat'
+require 'bitclust/screen'
+require 'bitclust/methodid'
+require 'bitclust/nameutils'
+require 'bitclust/simplesearcher'
+
+module BitClust
+
+  class RequestHandler
+
+    def initialize(db, manager)
+      if db.is_a? Array
+        @db, @cdb = db
+      else
+        @db = db
+      end
+      @screenmanager = manager
+      @conf = { :database => @db }
+    end
+
+    def handle(webrick_req)
+      _handle(Request.new(webrick_req))
+    rescue WEBrick::HTTPStatus::Status
+      raise
+    rescue BitClust::NotFoundError => err
+      return not_found_response(err)
+    rescue => err
+      return error_response(err)
+    end
+
+    private
+
+    def _handle(req)
+      return handle_doc(req) unless req.defined_type?
+      mid = "handle_#{req.type_id}"
+      unless respond_to?(mid, true)
+        raise RequestError, "wrong request: type_id=#{req.type_id}"
+      end
+      funcall(mid, req)
+    end
+
+    def error_response(err)
+      ErrorScreen.new(err).response
+    end
+
+    def not_found_response(err)
+      NotFoundScreen.new(err).response
+    end
+
+    def handle_library(req)
+      return library_index() unless req.library_name
+      lib = @db.fetch_library(req.library_name)
+      @screenmanager.library_screen(lib, @conf).response
+    end
+
+    def handle_class(req)
+      return class_index() unless req.class_name
+      c =  @db.fetch_class(req.class_name)
+      h = @conf.dup
+      h[:level] = req.ancestors_level
+      @screenmanager.class_screen(c, h).response
+    end
+
+    def handle_method(req)
+      ms = @db.fetch_methods(req.method_spec)
+      raise MethodNotFound.new(req.method_spec.to_s) if ms.nil? || ms.empty?
+      @screenmanager.method_screen(ms, @conf).response
+    end
+
+    def library_index
+      @screenmanager.library_index_screen(@db.libraries.sort, @conf).response
+    end
+
+    def class_index
+      @screenmanager.class_index_screen(@db.classes.sort, @conf).response
+    end
+
+    def handle_opensearchdescription(req)
+      @screenmanager.opensearchdescription_screen(req.full_uri, @conf).response
+    end
+
+    def handle_search(req)
+      ret = []
+      q0 = req.query['q'] || ''
+      q = URI.unescape(q0)
+      start = Time.now.to_i
+      ret = SimpleSearcher.search_pattern(@db, q)
+      elapsed_time = Time.now.to_f - start.to_f
+      c = @conf.dup
+      c[:q] = q0
+      c[:elapsed_time] = elapsed_time
+      @screenmanager.search_screen(ret, c).response
+    end
+
+    def handle_doc(req)
+      d = @db.fetch_doc(req.doc_name || 'index' )
+      @screenmanager.doc_screen(d, @conf).response
+    end
+    
+    def handle_function(req)
+      return function_index() unless req.function_name
+      f = @cdb.fetch_function(req.function_name)
+      @screenmanager.function_screen(f, @conf).response
+    end
+
+    def function_index
+      @screenmanager.function_index_screen(@cdb.functions.sort, @conf).response
+    end
+
+  end
+
+  class RackRequestHandler < RequestHandler
+    def handle(rack_req)
+      _handle(RackRequest.new(rack_req))
+    rescue BitClust::NotFoundError => err
+      return not_found_response(err)
+    rescue => err
+      return error_response(err)
+    end
+  end
+
+  class Request
+
+    include NameUtils
+
+    def initialize(wreq)
+      @wreq = wreq
+    end
+
+    def library?
+      type_id() == :library
+    end
+
+    def class?
+      type_id() == :class
+    end
+
+    def method?
+      type_id() == :method
+    end
+
+    def doc_name
+      name = path_info.sub(%r!\A/!, '')
+      name unless name.empty?
+    end
+
+    def library_name
+      raise '#library_name called but not library request' unless library?
+      id = type_param()
+      return nil unless id
+      name = libid2name(id)
+      unless libname?(name)
+        raise InvalidKey, "invalid library name: #{name.inspect}"
+      end
+      name
+    end
+
+    def class_name
+      raise '#class_name called but not class request' unless class?
+      id = type_param()
+      return nil unless id
+      name = classid2name(id)
+      unless classname?(name)
+        raise InvalidKey, "invalid class name: #{name.inspect}"
+      end
+      name
+    end
+
+    def method_spec
+      return nil unless method?
+      param = type_param()
+      return nil unless param
+      cid, typechar, mencoded = param.split('/', 3)
+      raise InvalidKey, 'missing class name' unless cid
+      raise InvalidKey, 'missing type name' unless typechar
+      raise InvalidKey, 'missing method name' unless mencoded
+      unless typechar?(typechar)
+        raise InvalidKey, "invalid method-type ID: #{typechar.inspect}"
+      end
+      cname = classid2name(cid)
+      tmark = typechar2mark(typechar)
+      mname = decodename_url(mencoded)
+      unless classname?(cname)
+        raise InvalidKey, "invalid class name: #{cname.inspect}"
+      end
+      case tmark
+      when '$'
+        unless gvarname?('$' + mname)
+          raise InvalidKey, "invalid variable name: #{('$' + mname).inspect}"
+        end
+      when '.', '#', '.#', '::'
+        unless methodname?(mname)
+          raise InvalidKey, "invalid method name: #{mname.inspect}"
+        end
+      end
+      MethodSpec.new(cname, tmark, mname)
+    end
+
+    def defined_type?
+      type, param = parse_path_info()
+      case type
+      when 'library', 'class', 'method', 'function', 'search', 'opensearchdescription'
+        true
+      else
+        false
+      end
+    end
+
+    def type_id
+      type, param = parse_path_info()
+      type.intern if type
+    end
+
+    def function?
+      type_id() == :function
+    end
+
+    def function_name
+      raise '#function_name called but not function request' unless function?
+      id = type_param()
+      return nil unless id
+      name = id
+      unless functionname?(name)
+        raise InvalidKey, "invalid function name: #{name.inspect}"
+      end
+      name
+    end
+
+    def ancestors_level
+      ret = query['a'].to_i
+      if ret < 0
+        0
+      else
+        ret
+      end
+    end
+
+    def query
+      @wreq.query
+    end
+
+    def full_uri
+      @wreq.request_uri
+    end
+
+    private
+
+    def type_param
+      type, param = parse_path_info()
+      return nil unless param
+      return nil if param.empty?
+      param
+    end
+
+    def parse_path_info
+      return nil unless path_info
+      _, type, param = path_info.split('/', 3)
+      param = nil if not param or param.empty?
+      return type, param
+    end
+
+    def path_info
+      @wreq.path_info
+    end
+
+  end
+
+  class RackRequest < Request
+
+    def initialize(rack_req)
+      @rack_req = rack_req
+    end
+
+    def query
+      @rack_req.params
+    end
+
+    def path_info
+      @rack_req.env["PATH_INFO"]
+    end
+
+    def full_uri
+      URI.parse(@rack_req.url)
+    end
+  end
+
+  class Screen   # reopen
+    def response
+      Response.new(self)
+    end
+  end
+
+
+  class Response
+
+    def initialize(screen)
+      @screen = screen
+    end
+
+    def update(webrick_res)
+      webrick_res.status = @screen.status if @screen.status
+      webrick_res['Content-Type'] = @screen.content_type
+      # webrick_res['Last-Modified'] = @screen.last_modified
+      body = @screen.body
+      webrick_res['Content-Length'] = body.bytesize
+      webrick_res.body = body
+    end
+
+    def rack_finish
+      [
+        @screen.status || 200,
+        {
+          'Content-Type' => @screen.content_type,
+        },
+        @screen.body
+      ]
+    end
+
+  end
+
+end

data/lib/bitclust/ridatabase.rb

@@ -0,0 +1,349 @@
+require 'rdoc/ri/ri_reader'
+require 'rdoc/ri/ri_cache'
+require 'rdoc/ri/ri_paths'
+
+class ApplicationError < StandardError; end
+class RiClassNotFound < ApplicationError; end
+
+class RiDatabase
+  def RiDatabase.open_system_db
+    new(RI::Paths.path(true, false, false, false), RUBY_VERSION)
+  end
+
+  def RiDatabase.open(dir, version)
+    new(RI::Paths.path(false, false, false, false, dir), version)
+  end
+
+  def initialize(ripath, version)
+    @ripath = ripath
+    @reader = RI::RiReader.new(RI::RiCache.new(@ripath))
+    @version = version
+  end
+
+  attr_reader :version
+
+  def get_method(m)
+    @reader.get_method(m)
+  end
+
+  def current_class=(name)
+    @klass = lookup_class(name)
+    @singleton_methods = wrap_entries(@reader.singleton_methods(@klass))
+    @instance_methods = wrap_entries(@reader.instance_methods(@klass))
+  rescue RiClassNotFound
+    @klass = nil
+    @singleton_methods = []
+    @instance_methods = []
+  end
+
+  attr_reader :class
+  attr_reader :singleton_methods
+  attr_reader :instance_methods
+
+  def lookup_class(name)
+    ns = @reader.top_level_namespace.first
+    name.split('::').each do |const|
+      ns = ns.contained_class_named(const) or
+          raise RiClassNotFound, "no such class in RDoc database: #{name}"
+    end
+    ns
+  end
+
+  private
+
+  def wrap_entries(ents)
+    ents.map {|m|
+      [RiMethodEntry.new(m.name, m)] +
+      m.aliases.map {|a| RiMethodEntry.new(a.name, m) }
+    }.flatten.uniq
+  end
+end
+
+class Ent
+  def initialize(name, ent)
+    @name = name
+    @entry = ent
+  end
+
+  attr_reader :name
+  attr_reader :entry
+
+  def ==(other)
+    @name == other.name
+  end
+
+  alias eql? ==
+
+  def hash
+    @name.hash
+  end
+
+  def <=>(other)
+    @name <=> other.name
+  end
+end
+
+class BCMethodEntry < Ent
+  def bitclust?
+    true
+  end
+
+  def inspect
+    "\#<BitClust #{@name} #{@entry.inspect}>"
+  end
+
+  def fullname
+    "#{@entry.klass.name}#{@entry.typemark}#{@name}"
+  end
+
+  def id
+    if @entry.defined?
+      fullname()
+    else
+      "#{fullname()}.#{@entry.library.name}"
+    end
+  end
+end
+
+class RiMethodEntry < Ent
+  def bitclust?
+    false
+  end
+
+  def inspect
+    "\#<RDoc #{@name} #{@entry.fullname}>"
+  end
+
+  def singleton_method?
+    @entry.singleton_method?
+  end
+
+  def fullname
+    c, t, m = @entry.fullname.split(/([\.\#])/, 2)
+    "#{c}#{t}#{@name}"
+  end
+end
+
+
+module RI
+
+  class RiReader   # reopen
+    def singleton_methods(c)
+      c.singleton_methods.map {|ent| get_method(ent) }
+    end
+
+    def instance_methods(c)
+      c.instance_methods.map {|ent| get_method(ent) }
+    end
+  end
+
+  class ClassEntry   # reopen
+    def singleton_methods
+      @class_methods
+    end
+
+    attr_reader :instance_methods
+
+    def method_entries
+      @class_methods.sort_by {|m| m.name } +
+      @instance_methods.sort_by {|m| m.name }
+    end
+  end
+
+  class MethodEntry   # reopen
+    def fullname
+      "#{@in_class.full_name}#{@is_class_method ? '.' : '#'}#{@name}"
+    end
+
+    def singleton_method?
+      @is_class_method
+    end
+  end
+
+  class MethodDescription   # reopen
+    def fullname
+      name = full_name()
+      unless /\#/ =~ name
+        components = name.split('::')
+        m = components.pop
+        components.join('::') + '.' + m
+      else
+        name
+      end
+    end
+
+    def singleton_method?
+      @is_class_method ||= false
+      @is_class_method
+    end
+  end
+
+end
+
+
+module HTMLUtils
+
+  ESC = {
+    '&' => '&amp;',
+    '<' => '&lt;',
+    '>' => '&gt;',
+    '"' => '&quot;'
+  }
+
+  def escape(str)
+    t = ESC
+    str.gsub(/[&"<>]/) {|s| t[s] }
+  end
+  module_function :escape
+
+  UNESC = ESC.invert
+  UNESC['&nbsp;'] = ' '
+
+  def unescape(str)
+    t = UNESC
+    str.gsub(/&\w+;/) {|s| t[s] || s }
+  end
+  module_function :unescape
+
+end
+
+
+class Formatter
+
+  include HTMLUtils
+
+  def method_info(m)
+    @f = StringIO.new
+    describe_method m
+    @f.string
+  end
+
+  private
+
+  def line(s = nil)
+    if s
+      @f.puts s
+    else
+      @f.puts
+    end
+  end
+
+  def describe_method(m)
+    if m.params[0,1] == '('
+      line "--- #{m.full_name}#{trim_space(m.params)}"
+    else
+      m.params.lines.each do |sig|
+        line "--- #{trim_sig(sig)}\#@todo\n"
+      end
+    end
+    unless m.aliases.empty?
+      m.aliases.each do |a|
+        line "alias #{a.name}"
+      end
+    end
+    #line "\#@TODO rewrite me"
+    line
+    @f.puts format_elements(m.comment)
+    line
+  end
+
+  def trim_space(s)
+    s.sub(/\(\s+/, '(').sub(/\s+\)/, ')').sub(/\(\)/, '')
+  end
+
+  def trim_sig(s)
+    s = trim_space(s)
+    s.sub!(/\A[a-z]\w+\./, '')
+    s.sub!(/=>/, '->')
+    s.sub!(/(->.*)\bstr(ing)?\b/){ $1 + 'String' }
+    s.sub!(/(->.*)\bint(eger)?\b/){ $1 + 'Integer' }
+    s.sub!(/(->.*)\b(an_)?obj\b/){ $1 + 'object' }
+    s.sub!(/(->.*)\b(a_)?hash\b/){ $1 + 'Hash' }
+    s.sub!(/(->.*)\b(an_)?array\b/){ $1 + 'Array' }
+    s.sub!(/ or /, ' | ')    
+    s
+  end
+  
+  def format_elements(elems)
+    return "" unless elems
+    return "" if elems.empty?
+    elems.map {|elem| format_element(elem) }.join("\n\n")
+  end
+
+  def format_element(e)
+    case e
+    when SM::Flow::P, SM::Flow::LI
+      paragraph(e)
+    when SM::Flow::LIST
+      list(e)
+    when SM::Flow::VERB
+      verbatim(e)
+    when SM::Flow::H
+      headline(e)
+    when SM::Flow::RULE
+      ;
+    else
+      raise "unkwnown markup: #{e.class}"
+    end
+  end
+
+  def headline(e)
+    h = '==' + ('=' * e.level)
+    text = unescape(e.text)
+    "#{h} #{text}"
+  end
+
+  def paragraph(e)
+    wrap(unescape(remove_inline(e.body)))
+  end
+
+  def verbatim(e)
+    unescape(e.body.rstrip) #.gsub(/^/, '    ')
+  end
+
+  def list(e)
+    case e.type
+    when SM::ListBase::BULLET
+      e.contents.map {|item| "* #{format_element(e)}" }.join("\n")
+    when SM::ListBase::NUMBER,
+         SM::ListBase::LOWERALPHA,
+         SM::ListBase::UPPERALPHA
+      num = case e.type
+            when SM::ListBase::NUMBER     then '1'
+            when SM::ListBase::LOWERALPHA then 'a'
+            when SM::ListBase::UPPERALPHA then 'A'
+            end
+      e.contents.map {|item|
+        str = "#{num}. #{format_element(e)}"
+        num = num.succ
+        str
+      }.join("\n")
+    when SM::ListBase::LABELED
+      e.contents.map {|item| "#{item.label} #{format_element(e)}" }.join("\n")
+    when SM::ListBase::NOTE
+      e.contents.map {|item| "#{item.label}\t#{format_element(e)}" }.join("\n")
+    else
+      raise "unknown list type: #{e.type.inspect}"
+    end
+  end
+
+  def remove_inline(str)
+    str.gsub(/<\/?\w+>/, '')
+  end
+
+  def wrap(str)
+    width = 60
+    buf = ''
+    line = ''
+    str.split.each do |chunk|
+      line << chunk << ' '
+      if line.size > width
+        buf << line.strip << "\n"
+        line = ''
+      end
+    end
+    buf << line
+    buf.strip
+  end
+
+end