bitclust-core 0.5.0

data/data/bitclust/template/library-index

@@ -0,0 +1,35 @@
+<% @title = _('Library Index') %>
+<p>
+<%= manual_home_link() %>
+&gt; <%= _("All Libraries") %>
+</p>
+<%= search_form() %>
+
+<%
+    headline_init
+%>
+<%= headline(_("Library Index")) %>
+<table class="entries libraries">
+<%
+    headline_push
+    lib = @entries.detect {|lib| lib.id == '_builtin' }
+%>
+<tr>
+<td class="signature"><%= library_link(lib.name, _('Builtin Library')) %></td>
+<td class="description"><%= compile_rd(lib.synopsis_source) %></td>
+</tr>
+<%
+    @entries.each do |lib|
+      next if lib.id == '_builtin'
+      next if lib.is_sublibrary
+%>
+<tr>
+<td class="signature"><%= library_link(lib.name) %></td>
+<td class="description"><%= compile_rd(lib.synopsis_source) %></td>
+</tr>
+<%
+    end
+    headline_pop
+%>
+</table>
+

data/data/bitclust/template/method

@@ -0,0 +1,24 @@
+<%
+    entry = @entries.sort.first
+    @title = "#{entry.type_label} #{entry.label}"
+%>
+<p>
+<%= manual_home_link() %>
+&gt; <a href="<%= library_index_url() %>"><%= _('All Libraries') %></a>
+&gt; <%= friendly_library_link(entry.library.name) %>
+&gt; <%= class_link(entry.klass.name, _(entry.klass.type.to_s + ' %s', entry.klass.name)) %>
+&gt; <% if entry.typename == :special_variable %>$<% end %><%=h entry.name %>
+<% unless entry.really_public? %>(<%= entry.visibility %>)<% end %>
+</p>
+<%= search_form() %>
+
+
+<% headline_init %>
+<%= headline("#{entry.type_label} #{entry.label}") %>
+<% headline_push %>
+<dl class="methodlist">
+<% @entries.sort.each do |ent| %>
+<%= compile_method(ent) %>
+<% end %>
+</dl>
+

data/data/bitclust/template/opensearchdescription

@@ -0,0 +1,10 @@
+<?xml version="1.0"  encoding="<%=h encoding() %>"?>
+<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/"
+                       xmlns:moz="http://www.mozilla.org/2006/browser/search/">
+  <ShortName><%= _('Ruby %s Reference Manual', ruby_version()) %></ShortName>
+  <Description><%= _('Ruby %s Reference Manual', ruby_version()) %></Description>
+  <Image height="16" width="16">data:image/png,%89PNG%0D%0A%1A%0A%00%00%00%0DIHDR%00%00%00%10%00%00%00%10%08%02%00%00%00%90%91h6%00%00%00%04gAMA%00%00%B1%8F%0B%FCa%05%00%00%00%06tRNS%00%FF%00%FF%00%FF7X%1B%7D%00%00%00TIDAT(%CFc%F8%0F%06%0C%C4%01%90J%88jc%E3U%10%84%A9%08Y%0AC%03P%08%03%19%C3d%D150%80%A5%D3PUC%B8%08%05%98%1A%D0%7C%F3%9FH%0D%98%8C%A1%A7%81%04O%93%10%AC%24G%1CiI%83%E4%C4w%86%10%80%A8%86j%20)y%03%00%B7%DF%E3P%F6%95%E2%F8%00%00%00%00IEND%AEB%60%82</Image>
+  <InputEncoding><%=h encoding() %></InputEncoding>
+  <Url type="text/html" method="get" template="<%=h search_full_url() %>?q={searchTerms}"/>
+  <moz:SearchForm><%=h search_full_url() %></moz:SearchForm>
+</OpenSearchDescription>

data/data/bitclust/template/search

@@ -0,0 +1,57 @@
+<p>
+<%= manual_home_link() %>
+&gt; <%=h _('Search Results') %>
+</p>
+<%
+    headline_init
+%>
+<%= headline(_('Search Results')) %>
+<form method="get" action="" name="f">
+<input value="<%=h @query %>" name="q" size="41">
+<input value="<%= _('Search') %>" type="submit">
+</form>
+<p>
+
+<table class="entries">
+<tr>
+    <td></td>
+    <td style="text-align:right" nowrap="nowrap">
+        <%=h _('%d Results', @entries.size) %> <%=h '(%.3f sec)' % @elapsed_time %>
+    </td>
+</tr>
+<% unless @entries.empty? %>
+<tr>
+    <th><%=h _('Entry') %></th>
+    <th colspan="2"><%=h _('Description') %></th>
+</tr>
+<% end %>
+<%
+        headline_push
+        @entries.each do |e|
+          foreach_method_chunk(e.source) do |sigs, src| %>
+<tr>
+<%          case e.type_id
+            when :method  %>
+<td class="signature"><%=
+              case e.type
+              when :special_variable
+                e.names.map {|name| method_link(e.spec_string, '$' + name) }
+              else
+                sigs.map {|sig|
+                  method_link(e.spec_string,
+                              e.klass.name + e.typemark + sig.to_s)
+                }
+              end.join("<br>\n") %></td>
+<td class="description"><%= compile_rd(src) %></td>
+<%          when :class   %>
+<td class="signature"><%= class_link e.name %></td>
+<td class="description"><%= compile_rd(src) %></td>
+<%          end           %>
+</tr>
+<%
+          end
+        end
+        headline_pop
+%>
+</table>
+

data/lib/bitclust.rb

@@ -0,0 +1,9 @@
+require 'bitclust/requesthandler'
+require 'bitclust/screen'
+require 'bitclust/server'
+require 'bitclust/searcher'
+require 'bitclust/methoddatabase'
+require 'bitclust/functiondatabase'
+require 'bitclust/rrdparser'
+require 'bitclust/exception'
+require 'bitclust/version'

data/lib/bitclust/app.rb

@@ -0,0 +1,129 @@
+require 'bitclust'
+require 'bitclust/interface'
+
+module BitClust
+
+  class App
+
+    def initialize(options)
+      @options = options
+      dbpath = options[:dbpath]
+      baseurl = options[:baseurl] || ''
+      datadir = options[:datadir] || File.expand_path('../../data/bitclust', File.dirname(__FILE__))
+      encoding = options[:encoding] || 'utf-8'
+      viewpath = options[:viewpath]
+      capi = options[:capi]
+      if options[:rack]
+        request_handler_class = BitClust::RackRequestHandler
+      else
+        request_handler_class = BitClust::RequestHandler
+      end
+      @interfaces = {}
+      case dbpath
+      when String
+        dbpath = File.expand_path(dbpath)
+        db = BitClust::MethodDatabase.new(dbpath)
+        if capi
+          db = [db, BitClust::FunctionDatabase.new(dbpath)]
+        end
+        manager = BitClust::ScreenManager.new(
+          :base_url => baseurl,
+          :cgi_url => File.join(baseurl, viewpath),
+          :datadir => datadir,
+          :templatedir => options[:templatedir],
+          :theme => options[:theme],
+          :encoding => encoding
+          )
+        handler = request_handler_class.new(db, manager)
+        @interfaces[viewpath] = BitClust::Interface.new { handler }
+      when Array
+        dbpaths = dbpath
+        @versions = []
+        dbpaths.each do |dbpath|
+          next unless /db-([\d_]+)/ =~ dbpath
+          dbpath = File.expand_path(dbpath)
+          version = $1.tr("_", ".")
+          @versions << version
+          if viewpath
+            version_viewpath = File.join(version, viewpath)
+          else
+            version_viewpath = version
+          end
+          db = BitClust::MethodDatabase.new(dbpath)
+          if capi
+            db = [db, BitClust::FunctionDatabase.new(dbpath)]
+          end
+          manager = BitClust::ScreenManager.new(
+            :base_url => baseurl,
+            :cgi_url => File.join(baseurl, version_viewpath),
+            :datadir => datadir,
+            :templatedir => options[:templatedir],
+            :theme => options[:theme],
+            :encoding => encoding
+            )
+          handler = request_handler_class.new(db, manager)
+          @interfaces[version_viewpath] = BitClust::Interface.new { handler }
+          $bitclust_context_cache = nil # clear cache
+        end
+      end
+    end
+
+    attr_reader :interfaces, :versions
+
+    def index(req)
+      case
+      when @interfaces.size == 1 && viewpath = @options[:viewpath]
+        # Redirect from '/' to "#{viewpath}/"
+        @index = "<html><head><meta http-equiv='Refresh' content='0;URL=#{viewpath}'></head></html>"
+      when 1 < @interfaces.size
+        request_path = case
+                       when req.respond_to?(:path_info)
+                         req.path_info
+                       when req.respond_to?(:path)
+                         req.path_info
+                       end
+        if @versions.any?{|version| %r|\A/?#{version}/?\z| =~ request_path }
+          viewpath = File.join(request_path, @options[:viewpath])
+          @index = "<html><head><meta http-equiv='Refresh' content='0;URL=#{viewpath}'></head></html>"
+        else
+          links = "<ul>"
+          @interfaces.keys.sort.each do |v|
+            if @options[:viewpath]
+              version = v.sub(@options[:viewpath], '')
+            else
+              version = v
+            end
+            url = v
+            links << %Q(<li><a href="#{url}/">#{version}</a></li>)
+          end
+          links << "</ul>"
+          if File.exist?("readme.html")
+            @index = File.read("readme.html").sub(%r!\./bitclust!, '').sub(/<!--links-->/) { links }
+          else
+            @index = "<html><head><title>bitclust</title></head><body>#{links}</body></html>"
+          end
+        end
+      end
+    end
+
+    def get_instance(server)
+      self
+    end
+
+    def service(req, res)
+      unless  %r|/#{File.basename(@options[:baseurl])}/?\z| =~ req.path
+        raise WEBrick::HTTPStatus::NotFound
+      end
+      res.body = index(req)
+      res['Content-Type'] = 'text/html; charset=utf-8'
+    end
+
+    def call(env)
+      [
+        200,
+        {'Content-Type' => 'text/html; charset=utf-8'},
+        index(Rack::Request.new(env))
+      ]
+    end
+  end
+end

data/lib/bitclust/classentry.rb

@@ -0,0 +1,425 @@
+#
+# bitclust/classentry.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
+
+  # Represents a class, a module and a singleton object.
+  class ClassEntry < Entry
+
+    include Enumerable
+
+    def ClassEntry.type_id
+      :class
+    end
+
+    def initialize(db, id)
+      super db
+      @id = id
+      if saved?
+        @entries = nil
+        @ancestors_checked = true
+        @s_ancestors_checked = true
+      else
+        @entries = []
+        @ancestors_checked = false
+        @s_ancestors_checked = false
+      end
+      init_properties
+    end
+
+    attr_reader :id
+
+    def ==(other)
+      @id == other.id
+    end
+
+    alias eql? ==
+
+    def hash
+      @id.hash
+    end
+
+    def <=>(other)
+      @id <=> other.id
+    end
+
+    def name
+      classid2name(@id)
+    end
+
+    def name?(n)
+      name() == n
+    end
+
+    # Return the real class name
+    def realname
+      alias? ? aliasof.name : name
+    end
+    
+    def name_match?(re)
+      re =~ name()
+    end
+
+    alias label name
+
+    # FIXME: implement class alias
+    def labels
+      [label()]
+    end
+
+    persistent_properties {
+      property :type,       'Symbol'         # :class | :module | :object
+      property :superclass, 'ClassEntry'
+      property :included,   '[ClassEntry]'
+      property :extended,   '[ClassEntry]'
+      property :library,    'LibraryEntry'
+      property :aliases,    '[ClassEntry]'
+      property :aliasof,    'ClassEntry'
+      property :source,     'String'
+    }
+
+    def save
+      super
+      save_index
+    end
+
+    def inspect
+      "\#<#{type()} #{@id}>"
+    end
+
+    def dummy?
+      not type()
+    end
+
+    def class?
+      type() == :class
+    end
+
+    def module?
+      type() == :module
+    end
+
+    def object?
+      type() == :object
+    end
+
+    def alias?
+      !! aliasof()
+    end
+
+    def include(m)
+      included().push m
+    end
+
+    def extend(m)
+      extended().push m
+    end
+
+    # Add a alias +c+ to the alias list.
+    def alias(c)
+      aliases().push c
+    end
+
+    def check_ancestor_type
+      s = superclass()
+      if s and not s.class? and not s.dummy?
+        raise InvalidAncestor, "#{name()} inherits #{s.name} but it is a #{s.type} (class expected)"
+      end
+      included().each do |c|
+        unless c.module? or c.dummy?
+          raise InvalidAncestor, "#{name()} includes #{c.name} but it is a #{c.type} (module expected)"
+        end
+      end
+      extended().each do |c|
+        unless c.module? or c.dummy?
+          raise InvalidAncestor, "#{name()} extends #{c.name} but it is a #{c.type} (module expected)"
+        end
+      end
+    end
+
+    def check_ancestors_link(path = [])
+      return if @ancestors_checked
+      if path.include?(name())
+        raise InvalidLink, "ancestor link looped: #{path_string(path)}"
+      end
+      ([superclass()] + included()).compact.each do |c|
+        path.push name()
+        c.check_ancestors_link path
+        path.pop
+      end
+      @ancestors_checked = true
+    end
+
+    def check_singleton_ancestors_link(path = [])
+      return if @s_ancestors_checked
+      extended().each do |c|
+        path.push name()
+        c.check_singleton_ancestors_link path
+        path.pop
+      end
+      @s_ancestors_checked = true
+    end
+
+    def ancestors
+      @ancestors ||=
+          [ self, included().map {|m| m.ancestors },
+            superclass() ? superclass().ancestors : [] ].flatten
+    end
+
+    def included_modules
+      list = ancestors().select {|c| c.module? }
+      list.delete self
+      list
+    end
+
+    def extended_modules
+      ancestors().select {|c| c.class? }.map {|c| c.extended }.flatten
+    end
+
+    def entries(level = 0)
+      @entries ||= @db.entries("method/#{@id}")\
+          .map {|ent| MethodEntry.new(@db, "#{@id}/#{ent}") }
+      ret = @entries
+      ancestors[1..level].each{|c| ret += c.entries }
+      ret 
+    end
+
+    alias methods entries
+
+    def each(&block)
+      entries().each(&block)
+    end
+
+    def add_method(m)
+      # FIXME: check duplication?
+      entries().push m
+    end
+
+    Parts = Struct.new(:singleton_methods, :private_singleton_methods,
+                       :instance_methods,  :private_instance_methods,
+                       :module_functions,
+                       :constants, :special_variables,
+                       :added)
+
+    def partitioned_entries(level = 0)
+      s = []; spv = []
+      i = []; ipv = []
+      mf = []
+      c = []; v = []
+      added = []
+      entries(level).sort_by{|e| e.name}.each do |m|
+        case m.kind
+        when :defined, :redefined
+          case m.type
+          when :singleton_method
+            (m.public? ? s : spv).push m
+          when :instance_method
+            (m.public? ? i : ipv).push m
+          when :module_function
+            mf.push m
+          when :constant
+            c.push m
+          when :special_variable
+            v.push m
+          else
+            raise "must not happen: m.type=#{m.type.inspect} (#{m.inspect})"
+          end
+        when :added
+          added.push m
+        end
+      end
+      Parts.new(s,spv, i,ipv, mf, c, v, added)
+    end
+
+    def singleton_methods(level = 0)
+      # FIXME: inheritance
+      entries(level).select {|m| m.singleton_method? }.sort
+    end
+
+    def public_singleton_methods(level = 0)
+      # FIXME: inheritance
+      entries(level).select {|m| m.public_singleton_method? }.sort
+    end
+
+    def instance_methods(level = 0)
+      # FIXME: inheritance
+      entries(level).select {|m| m.instance_method? }.sort
+    end
+
+    def private_singleton_methods(level = 0)
+      # FIXME: inheritance
+      entries(level).select {|m| m.private_singleton_method? }.sort
+    end
+
+    def public_instance_methods(level = 0)
+      # FIXME: inheritance
+      entries(level).select {|m| m.public_instance_method? }.sort
+    end
+
+    def private_instance_methods(level = 0)
+      # FIXME: inheritance
+      entries(level).select {|m| m.private_instance_method? }.sort
+    end
+
+    alias private_methods   private_instance_methods
+
+    def constants(level = 0)
+      entries(level).select {|m| m.constant? }.sort
+    end
+
+    def special_variables
+      entries().select {|m| m.special_variable? }.sort
+    end
+
+    def singleton_method?(name, inherit = true)
+      if inherit
+        _smap().key?(name)
+      else
+        singleton_methods(false).detect {|m| m.name?(name) }
+      end
+    end
+
+    def instance_method?(name, inherit = true)
+      if inherit
+        _imap().key?(name)
+      else
+        instance_methods(false).detect {|m| m.name?(name) }
+      end
+    end
+
+    def constant?(name, inherit = true)
+      if inherit
+        ancestors().any? {|c| c.constant?(name, false) }
+      else
+        constants(false).detect {|m| m.name?(name) }
+      end
+    end
+
+    def special_variable?(name)
+      special_variables().detect {|m| m.name?(name) }
+    end
+
+    def get_methods(spec)
+      entries().select {|m| spec.match?(m) }
+    end
+
+    def get_method(spec)
+      entries().detect {|m| spec.match?(m) }
+    end
+
+    def fetch_methods(spec)
+      get_methods(spec) or
+          raise MethodNotFound, "no such method: #{spec}"
+    end
+
+    def fetch_method(spec)
+      get_method(spec) or
+          raise MethodNotFound, "no such method: #{spec}"
+    end
+
+    # internal use only
+    def match_entry(t, mname)
+      _index()[t + mname]
+    end
+
+    def singleton_method_names
+      # should remove module functions?
+      _index().keys.select {|name| /\A\./ =~ name }.map {|name| name[1..-1] }
+    end
+
+    def instance_method_names
+      _index().keys.select {|name| /\A\#/ =~ name }.map {|name| name[1..-1] }
+    end
+
+    def constant_names
+      _index().keys.select {|name| /\A\:/ =~ name }.map {|name| name[1..-1] }
+    end
+
+    def special_variable_names
+      special_variables().map {|m| m.names }.flatten
+    end
+
+    def inherited_method_specs
+      cname = name()
+      _index().map {|mname, specstr| MethodSpec.parse(specstr) }\
+          .reject {|spec| spec.klass == cname }.uniq
+    end
+
+    def clear_cache
+      @_smap = @_imap = @_cmap = nil
+    end
+
+    # internal use only
+    def _smap
+      @_smap ||= makemap('s', extended_modules(), singleton_methods())
+    end
+
+    # internal use only
+    def _imap
+      @_imap ||= makemap('i', included_modules(), instance_methods())
+    end
+
+    # internal use only
+    def _cmap
+      @_cmap ||= makemap('c', included_modules(), constants())
+    end
+
+    private
+
+    def makemap(typechar, inherited_modules, ents)
+      if alias?
+        return aliasof().__send__("_#{typechar}map").dup
+      end
+      s = superclass()
+      map = s ? s.__send__("_#{typechar}map").dup : {}
+      inherited_modules.each do |mod|
+        map.update mod.__send__("_#{typechar == 'c' ? 'c' : 'i'}map")
+      end
+      defined, undefined = *ents.partition {|m| m.defined? }
+      (undefined + defined).each do |m|
+        m.names.each do |name|
+          map[name] = m.spec_string
+        end
+      end
+      map
+    end
+
+    def save_index
+      @db.makepath "method/#{@id}"
+      @db.atomic_write_open("method/#{@id}/=index") {|f|
+        writemap _smap(), '.', f
+        writemap _imap(), '#', f
+        writemap _cmap(), ':', f
+      }
+    end
+
+    def writemap(map, mark, f)
+      map.to_a.sort_by {|k,v| k }.each do |name, m|
+        f.puts "#{mark}#{name}\t#{m}"
+      end
+    end
+
+    def _index
+      @_index ||=
+          begin
+            h = {}
+            @db.foreach_line("method/#{@id}/=index") do |line|
+              name, spec = line.split
+              h[name] = spec
+            end
+            h
+          end
+    end
+
+  end
+
+end