bitclust-core 0.5.0

data/lib/bitclust/exception.rb

@@ -0,0 +1,38 @@
+#
+# bitclust/exception.rb
+#
+# Copyright (c) 2006-2007 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+module BitClust
+  class Error                   < StandardError; end
+  class RequestError            < Error; end
+  class NotInTransaction        < Error; end
+  class DocumentError           < Error; end
+  class ScanError               < DocumentError; end
+  class ParseError              < DocumentError; end
+  class WrongInclude            < DocumentError; end
+  class InvalidLink             < DocumentError; end
+  class InvalidAncestor         < DocumentError; end
+  class UserError               < Error; end
+  class InvalidDatabase         < UserError; end
+  class InvalidKey              < UserError; end
+  class InvalidScheme           < UserError; end
+  class NotFoundError           < UserError; end
+  class LibraryNotFound         < NotFoundError; end
+  class ClassNotFound           < NotFoundError; end
+  class MethodNotFound          < NotFoundError; end
+  class FunctionNotFound        < NotFoundError; end
+  class DocNotFound             < NotFoundError; end
+
+  module WriterError; end
+  class DocumentError
+    include WriterError
+  end
+  class UserError
+    include WriterError
+  end
+end

data/lib/bitclust/functiondatabase.rb

@@ -0,0 +1,115 @@
+#
+# bitclust/functiondatabase.rb
+#
+# Copyright (c) 2006-2008 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+require 'bitclust/database'
+require 'bitclust/functionentry'
+require 'bitclust/completion'
+require 'bitclust/functionreferenceparser'
+require 'bitclust/exception'
+
+module BitClust
+
+  class FunctionDatabase < Database
+
+    include Completion
+
+    def initialize(prefix)
+      super
+      @dirty_functions = {}
+      @functionmap = {}
+      @function_extent_loaded = false
+    end
+
+    def commit
+      each_dirty_function do |f|
+        f.save
+      end
+      clear_dirty
+      #save_completion_index
+    end
+    private :commit
+
+    def dirty_function(f)
+      @dirty_functions[f] = true
+    end
+
+    def dirty?
+      not @dirty_functions.empty?
+    end
+
+    def each_dirty_function(&block)
+      @dirty_functions.each_key(&block)
+    end
+
+    def clear_dirty
+      @dirty_functions.clear
+    end
+
+    def update_by_file(path, filename)
+      check_transaction
+      FunctionReferenceParser.new(self).parse_file(path, filename, properties())
+    end
+
+    def search_functions(pattern)
+      fs = _search_functions(pattern)
+      if fs.empty?
+        raise FunctionNotFound, "no such function: #{pattern}"
+      end
+      fs
+    end
+
+    def open_function(id)
+      check_transaction
+      if exist?("function/#{id}")
+        f = load_function(id)
+        f.clear
+      else
+        f = (@functionmap[id] ||= FunctionEntry.new(self, id))
+      end
+      yield f
+      dirty_function f
+      f
+    end
+
+    def fetch_function(id)
+      load_function(id) or
+          raise FunctionNotFound, "function not found: #{id.inspect}"
+    end
+
+    def load_function(id)
+      @functionmap[id] ||=
+          begin
+            return nil unless exist?("function/#{id}")
+            FunctionEntry.new(self, id)
+          end
+    end
+    private :load_function
+
+    def functions
+      functionmap().values
+    end
+
+    def functionmap
+      return @functionmap if @function_extent_loaded
+      id_extent(FunctionEntry).each do |id|
+        @functionmap[id] ||= FunctionEntry.new(self, id)
+      end
+      @function_extent_loaded = true
+      @functionmap
+    end
+    private :functionmap
+
+    def id_extent(entry_class)
+      entries(entry_class.type_id.to_s)
+    end
+    private :id_extent
+
+  end
+
+end

data/lib/bitclust/functionentry.rb

@@ -0,0 +1,81 @@
+#
+# bitclust/functionentry.rb
+#
+# Copyright (c) 2006-2008 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+require 'bitclust/entry'
+require 'bitclust/exception'
+
+module BitClust
+
+  class FunctionEntry < Entry
+
+    def FunctionEntry.type_id
+      :function
+    end
+
+    def initialize(db, id)
+      super db
+      @id = id
+      init_properties
+    end
+
+    def inspect
+      "\#<function #{@id}>"
+    end
+
+    def name_match?(re)
+      re =~ name()
+    end
+
+    def <=>(other)
+      @id.casecmp(other.id)
+    end
+
+    persistent_properties {
+      property :filename,   'String'
+      property :macro,      'bool'
+      property :private,    'bool'
+      property :type,       'String'
+      property :name,       'String'
+      property :params,     'String'
+      property :source,     'String'
+    }
+
+    attr_reader :id
+    remove_method :name
+    alias name id
+    alias label id
+
+    alias macro? macro
+    alias private? private
+
+    def public?
+      not private?
+    end
+
+    def callable?
+      not params().empty?
+    end
+
+    def type_label
+      macro? ? 'macro' : 'function'
+    end
+    alias kind type_label
+
+    def header
+      if callable?
+        base = "#{type()} #{name()}#{params()}"
+      else
+        base = "#{type()} #{name()}"
+      end
+      "#{private? ? 'static ' : ''}#{base}"
+    end
+
+  end
+
+end

data/lib/bitclust/functionreferenceparser.rb

@@ -0,0 +1,76 @@
+#
+# bitclust/functionreferenceparser.rb
+#
+# Copyright (c) 2006-2007 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+require 'bitclust/exception'
+
+module BitClust
+
+  class FunctionReferenceParser
+
+    def FunctionReferenceParser.parse_file(path, params = {"version" => "1.9.0"})
+      parser = new(FunctionDatabase.dummy(params))
+      parser.parse_file(path, File.basename(path, ".rd"), params)
+    end
+
+    def initialize(db)
+      @db = db
+    end
+
+    def parse_file(path, filename, properties)
+      fopen(path, 'r:UTF-8') {|f|
+        return parse(f, filename)
+      }
+    end
+
+    def parse(f, filename)
+      @filename = filename
+      file_entries LineInput.new(f)
+      @db.functions
+    end
+
+    private
+
+    def file_entries(f)
+      f.skip_blank_lines
+      f.while_match(/\A---/) do |header|
+        entry header.sub(/\A---/, '').strip, f.break(/\A---/)
+        f.skip_blank_lines
+      end
+    end
+
+    def entry(header, body)
+      h = parse_header(header)
+      @db.open_function(h.name) {|f|
+        f.filename = @filename
+        f.macro = h.macro
+        f.private = h.private
+        f.type = h.type
+        f.name = h.name
+        f.params = h.params
+        f.source = body.join('')
+      }
+    end
+
+    def parse_header(header)
+      h = FunctionHeader.new
+      m = header.match(/\A\s*(MACRO\s+)?(static\s+)?(.+?\W)(\w+)(\(.*\))?\s*\z/)
+      raise ParseError, "syntax error: #{header.inspect}" unless m
+      h.macro = m[1] ? true : false
+      h.private = m[2] ? true : false
+      h.type = m[3].strip
+      h.name = m[4]
+      h.params = m[5].strip if m[5]
+      h
+    end
+
+  end
+
+  FunctionHeader = Struct.new(:macro, :private, :type, :name, :params)
+
+end

data/lib/bitclust/htmlutils.rb

@@ -0,0 +1,80 @@
+#
+# bitclust/htmlutils.rb
+#
+# Copyright (C) 2006-2008 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+require 'bitclust/nameutils'
+
+module BitClust
+
+  module HTMLUtils
+
+    include NameUtils
+
+    private
+
+    # make method anchor from MethodEntry
+    def link_to_method(m, specp = false)
+      label = specp ? m.label : m.short_label
+      a_href(@urlmapper.method_url(methodid2specstring(m.id)), label)
+    end
+
+    def library_link(name, label = nil, frag = nil)
+      a_href(@urlmapper.library_url(name) + fragment(frag), label || name)
+    end
+
+    def class_link(name, label = nil, frag = nil)
+      a_href(@urlmapper.class_url(name) + fragment(frag), label || name)
+    end
+
+    def method_link(spec, label = nil, frag = nil)
+      a_href(method_url(spec, frag), label || spec)
+    end
+
+    def method_url(spec, frag = nil)
+      @urlmapper.method_url(spec) + fragment(frag)
+    end
+
+    def function_link(name, label = nil, frag = nil)
+      a_href(@urlmapper.function_url(name) + fragment(frag), label || name)
+    end
+
+    def document_link(name, label = nil, frag = nil)
+      a_href(@urlmapper.document_url(name) + fragment(frag),
+             label || @option[:database].get_doc(name).title)
+    end
+
+    def fragment(str)
+      str ? '#' + str : ''
+    end
+
+    def a_href(url, label)
+      %Q(<a href="#{escape_html(url)}">#{escape_html(label)}</a>)
+    end
+
+    ESC = {
+      '&' => '&amp;',
+      '"' => '&quot;',
+      '<' => '&lt;',
+      '>' => '&gt;'
+    }
+
+    def escape_html(str)
+      table = ESC   # optimize
+      str.gsub(/[&"<>]/) {|s| table[s] }
+    end
+
+    ESCrev = ESC.invert
+
+    def unescape_html(str)
+      table = ESCrev   # optimize
+      str.gsub(/&\w+;/) {|s| table[s] }
+    end
+
+  end
+
+end

data/lib/bitclust/interface.rb

@@ -0,0 +1,87 @@
+#
+# bitclust/interface.rb
+#
+# Copyright (c) 2006-2007 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+require 'webrick/cgi'
+require 'webrick/httpservlet/abstract'
+begin
+  require 'fcgi'
+rescue LoadError
+end
+
+module BitClust
+
+  class Interface
+
+    def initialize(webrick_conf = {})
+      @webrick_conf = webrick_conf
+      @handler = ($bitclust_context_cache ||= yield)
+    end
+
+    # for WEBrick servlet
+    def get_instance(server)
+      WEBrickServlet.new(server, @handler)
+    end
+
+    def main
+      if fastcgi?
+        FCGI.new(@webrick_conf).main(@handler)
+      else
+        # CGI, mod_ruby
+        CGI.new(@webrick_conf).main(@handler)
+      end
+    end
+
+    # for rack
+    def call(env)
+      @handler.handle(Rack::Request.new(env)).rack_finish
+    end
+
+    private
+
+    def fastcgi?
+      defined?(::FCGI) and ::FCGI.fastcgi?
+    end
+
+    def mod_ruby?
+      false   # FIXME
+    end
+
+    class CGI < ::WEBrick::CGI
+      def main(handler)
+        @handler = handler
+        start
+      end
+
+      def do_GET(wreq, wres)
+        @handler.handle(wreq).update wres
+      end
+
+      alias do_POST do_GET
+    end
+
+    class FCGI < CGI
+      def main(handler)
+        @handler = handler
+        ::FCGI.each_cgi_request do |req|
+          start req.env, req.in, req.out
+        end
+      end
+    end
+
+    class WEBrickServlet < ::WEBrick::HTTPServlet::AbstractServlet
+      def do_GET(wreq, wres)
+        @options.first.handle(wreq).update wres
+      end
+
+      alias do_POST do_GET
+    end
+  
+  end
+
+end