bitclust-core 0.5.3 → 0.5.4

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

@@ -1,66 +0,0 @@
-#
-# 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/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/lib/bitclust/requesthandler.rb

@@ -1,330 +0,0 @@
-#
-# 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/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/lib/bitclust/ridatabase.rb

@@ -1,349 +0,0 @@
-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