bitclust-core 0.8.0 → 0.9.0

data/lib/bitclust/classentry.rb

@@ -64,7 +64,7 @@ module BitClust
     def realname
       alias? ? aliasof.name : name
     end
-    
+
     def name_match?(re)
       re =~ name()
     end
@@ -81,6 +81,8 @@ module BitClust
       property :superclass, 'ClassEntry'
       property :included,   '[ClassEntry]'
       property :extended,   '[ClassEntry]'
+      property :dynamically_included, '[ClassEntry]'
+      property :dynamically_extended, '[ClassEntry]'
       property :library,    'LibraryEntry'
       property :aliases,    '[ClassEntry]'
       property :aliasof,    'ClassEntry'
@@ -133,7 +135,7 @@ module BitClust
         ancestors.any?{|k| k.name == 'Exception' }
       end
     end
-    
+
     def include(m)
       included().push m
     end
@@ -142,6 +144,24 @@ module BitClust
       extended().push m
     end
 
+    # Add a module +m+ to the dynamically included module list.
+    def dynamic_include(m, lib)
+      if m.library != lib
+        message = "dynamically included module #{m.name} should be defined in the module #{lib.name}"
+        raise InvalidLibrary, message
+      end
+      dynamically_included().push m
+    end
+
+    # Add a module +m+ to the dynamically extended module list.
+    def dynamic_extend(m, lib)
+      if m.library != lib
+        message = "dynamically extended module #{m.name} should be defined in the module #{lib.name}"
+        raise InvalidLibrary, message
+      end
+      dynamically_extended().push m
+    end
+
     # Add a alias +c+ to the alias list.
     def alias(c)
       aliases().push c
@@ -208,7 +228,7 @@ module BitClust
           .map {|ent| MethodEntry.new(@db, "#{@id}/#{ent}") }
       ret = @entries
       ancestors[1..level].each{|c| ret += c.entries }
-      ret 
+      ret
     end
 
     alias methods entries
@@ -260,42 +280,42 @@ module BitClust
 
     def singleton_methods(level = 0)
       # FIXME: inheritance
-      entries(level).select {|m| m.singleton_method? }.sort
+      entries(level).select {|m| m.singleton_method? }.sort_by {|entry| entry.sort_key }
     end
 
     def public_singleton_methods(level = 0)
       # FIXME: inheritance
-      entries(level).select {|m| m.public_singleton_method? }.sort
+      entries(level).select {|m| m.public_singleton_method? }.sort_by {|entry| entry.sort_key }
     end
 
     def instance_methods(level = 0)
       # FIXME: inheritance
-      entries(level).select {|m| m.instance_method? }.sort
+      entries(level).select {|m| m.instance_method? }.sort_by {|entry| entry.sort_key }
     end
 
     def private_singleton_methods(level = 0)
       # FIXME: inheritance
-      entries(level).select {|m| m.private_singleton_method? }.sort
+      entries(level).select {|m| m.private_singleton_method? }.sort_by {|entry| entry.sort_key }
     end
 
     def public_instance_methods(level = 0)
       # FIXME: inheritance
-      entries(level).select {|m| m.public_instance_method? }.sort
+      entries(level).select {|m| m.public_instance_method? }.sort_by {|entry| entry.sort_key }
     end
 
     def private_instance_methods(level = 0)
       # FIXME: inheritance
-      entries(level).select {|m| m.private_instance_method? }.sort
+      entries(level).select {|m| m.private_instance_method? }.sort_by {|entry| entry.sort_key }
     end
 
     alias private_methods   private_instance_methods
 
     def constants(level = 0)
-      entries(level).select {|m| m.constant? }.sort
+      entries(level).select {|m| m.constant? }.sort_by {|entry| entry.sort_key }
     end
 
     def special_variables
-      entries().select {|m| m.special_variable? }.sort
+      entries().select {|m| m.special_variable? }.sort_by {|entry| entry.sort_key }
     end
 
     def singleton_method?(name, inherit = true)

data/lib/bitclust/docentry.rb

@@ -50,7 +50,7 @@ module BitClust
     def labels
       [label()]
     end
-    
+
     def name?(n)
       name() == n
     end
@@ -71,7 +71,7 @@ module BitClust
     def error_classes
       classes.select{|c| c.error_class? }
     end
-    
+
     def methods
       @db.methods
     end

data/lib/bitclust/entry.rb

@@ -205,6 +205,7 @@ module BitClust
     end
 
     def restore_entries(str, klass)
+      return [] if str.nil?
       str.split(',').map {|id| klass.load(@db, id) }
     end
 

data/lib/bitclust/exception.rb

@@ -17,6 +17,7 @@ module BitClust
   class WrongInclude            < DocumentError; end
   class InvalidLink             < DocumentError; end
   class InvalidAncestor         < DocumentError; end
+  class InvalidLibrary          < DocumentError; end
   class UserError               < Error; end
   class InvalidDatabase         < UserError; end
   class InvalidKey              < UserError; end

data/lib/bitclust/functionreferenceparser.rb

@@ -28,13 +28,14 @@ module BitClust
 
     def parse_file(path, filename, properties)
       fopen(path, 'r:UTF-8') {|f|
-        return parse(f, filename)
+        return parse(f, filename, properties)
       }
     end
 
-    def parse(f, filename)
+    def parse(f, filename, params = {})
       @filename = filename
-      file_entries LineInput.new(f)
+      s = Preprocessor.read(f, params)
+      file_entries LineInput.for_string(s)
       @db.functions
     end
 

data/lib/bitclust/generators/epub.rb

@@ -0,0 +1,118 @@
+require 'fileutils'
+require 'tmpdir'
+require 'erb'
+
+require 'bitclust/subcommands/statichtml_command'
+
+module BitClust
+  module Generators
+    class EPUB
+      def initialize(options = {})
+        @options = options.dup
+        @prefix           = options[:prefix]
+        @capi             = options[:capi]
+        @outputdir        = options[:outputdir]
+        @filename         = options[:filename]
+        @templatedir      = options[:templatedir]
+        @catalog          = options[:catalog]
+        @themedir         = options[:themedir]
+        @fs_casesensitive = options[:fs_casesensitive]
+        @keep             = options[:keep]
+        @verbose          = options[:verbose]
+      end
+
+      CONTENTS_DIR_NAME = 'OEBPS'
+
+      def generate
+        make_epub_directory do |epub_directory|
+          contents_directory = epub_directory + CONTENTS_DIR_NAME
+          copy_static_files(epub_directory)
+          generate_xhtml_files(contents_directory)
+          generate_contents_opf(epub_directory)
+          pack_epub(epub_directory)
+        end
+      end
+
+      private
+
+      def make_epub_directory
+        dir = Dir.mktmpdir("epub-", @outputdir)
+        yield Pathname.new(dir)
+      ensure
+        FileUtils.rm_rf(dir, :secure => true, :verbose => @verbose) unless @keep
+      end
+
+      def copy_static_files(epub_directory)
+        FileUtils.cp(@templatedir + "mimetype", epub_directory, :verbose => @verbose)
+        FileUtils.cp(@templatedir + "nav.xhtml", epub_directory, :verbose => @verbose)
+        meta_inf_directory = epub_directory + "META-INF"
+        FileUtils.mkdir_p(meta_inf_directory, :verbose => @verbose)
+        FileUtils.cp(@templatedir + "container.xml", meta_inf_directory, :verbose => @verbose)
+      end
+
+      def generate_xhtml_files(contents_directory)
+        argv = [
+          "--outputdir=#{contents_directory}",
+          "--templatedir=#{@templatedir}",
+          "--catalog=#{@catalog}",
+          "--themedir=#{@themedir}",
+          "--suffix=.xhtml",
+        ]
+        argv << "--fs-casesensitive" if @fs_casesensitive
+        argv << "--quiet" unless @verbose
+        options = {
+          :prefix => @prefix,
+          :capi   => @capi,
+        }
+        cmd = BitClust::Subcommands::StatichtmlCommand.new
+        cmd.parse(argv)
+        cmd.exec(argv, options)
+      end
+
+      def generate_contents_opf(epub_directory)
+        items = []
+        glob_relative_path(epub_directory, "#{CONTENTS_DIR_NAME}/class/*.xhtml").each do |path|
+          items << {
+            :id => decodename_package(path.basename(".*").to_s),
+            :path => path
+          }
+        end
+        items.sort_by!{|item| item[:path] }
+        contents = ERB.new(File.read(@templatedir + "contents"), nil, "-").result(binding)
+        File.open(epub_directory + "contents.opf", "w") do |f|
+          f.write contents
+        end
+      end
+
+      def pack_epub(epub_directory)
+        epub_filename = @outputdir + @filename
+        Dir.chdir(epub_directory.to_s) do
+          system("zip -0 -X #{epub_filename} mimetype")
+          system("zip -r #{epub_filename} ./* -x mimetype")
+        end
+      end
+
+      def glob_relative_path(path, pattern)
+        relative_paths = []
+        absolute_path_to_search = Pathname.new(path).realpath
+        Dir.glob(absolute_path_to_search + pattern) do |absolute_path|
+          absolute_path = Pathname.new(absolute_path)
+          relative_paths << absolute_path.relative_path_from(absolute_path_to_search)
+        end
+        relative_paths
+      end
+
+      def decodename_package(str)
+        if @fs_casesensitive
+          NameUtils.decodename_url(str)
+        else
+          NameUtils.decodename_fs(str)
+        end
+      end
+
+      def last_modified
+        Time.now.iso8601
+      end
+    end
+  end
+end

data/lib/bitclust/libraryentry.rb

@@ -24,6 +24,7 @@ module BitClust
     def initialize(db, id)
       super db
       @id = id
+      @name = libid2name(@id)
       if saved?
         @classmap = nil
         @methodmap = nil
@@ -36,7 +37,9 @@ module BitClust
       init_properties
     end
 
-    attr_reader :id
+    attr_reader :id, :name
+
+    alias label name
 
     def ==(other)
       @id == other.id
@@ -52,11 +55,6 @@ module BitClust
       @id.casecmp(other.id)
     end
 
-    def name
-      libid2name(@id)
-    end
-    alias label name
-
     def labels
       [label()]
     end

data/lib/bitclust/methodsignature.rb

@@ -59,7 +59,7 @@ module BitClust
       when /\A\$/   # gvar
         @name + (@type ? " -> #{@type}" : "")
       when "+@", "-@", "~", "!", "!@"  # unary operator
-        "#{@name.sub(/@/, '')}#{@params}" + (@type ? " -> #{@type}" : "")
+        "#{@name.sub(/@/, '')} self" + (@type ? " -> #{@type}" : "")
       when "[]"     # aref
         "self[#{@params}]" + (@type ? " -> #{@type}" : "")
       when "[]="    # aset

data/lib/bitclust/nameutils.rb

@@ -21,7 +21,7 @@ module BitClust
     CONST_PATH_RE  = /#{CONST_RE}(?:::#{CONST_RE})*/
     CLASS_NAME_RE  = /(?:#{CONST_RE}(?:::compatible)?|fatal|ARGF.class|main)/
     CLASS_PATH_RE  = /(?:#{CONST_PATH_RE}(?:::compatible)?|fatal|ARGF.class|main)/
-    METHOD_NAME_RE = /\w+[?!=]?|===|==|=~|<=>|<=|>=|!=|!|!@|!~|\[\]=|\[\]|\*\*|>>|<<|\+@|\-@|[~+\-*\/%&|^<>`]/
+    METHOD_NAME_RE = /\w+[?!=]?|===|==|=~|<=>|<=|>=|!=|!~|!@|!|\[\]=|\[\]|\*\*|>>|<<|\+@|\-@|[~+\-*\/%&|^<>`]/
     TYPEMARK_RE    = /(?:\.|\#|\.\#|::|\$)/
     METHOD_SPEC_RE = /#{CLASS_PATH_RE}#{TYPEMARK_RE}#{METHOD_NAME_RE}/
     GVAR_RE        = /\$(?:\w+|-.|\S)/
@@ -212,6 +212,14 @@ module BitClust
       str.gsub(/=[\da-h]{2}/ni) {|s| s[1,2].hex.chr }
     end
 
+    # string -> encoded string in a rdoc way
+    def encodename_rdocurl(str)
+      str = str.gsub(/[^A-Za-z0-9_.]/n) {|ch|
+        sprintf('-%02X', ch[0].ord)
+      }
+      str.sub(/\A-/, '')
+    end
+
     # case-sensitive ID -> encoded string (encode only [A-Z])
     def encodeid(str)
       str.gsub(/[A-Z]/n) {|ch| "-#{ch}" }.downcase
@@ -234,6 +242,9 @@ module BitClust
       }
     end
 
+    def html_filename(basename, suffix)
+      "#{basename}#{suffix}"
+    end
   end
 
 end

data/lib/bitclust/rdcompiler.rb

@@ -38,13 +38,23 @@ module BitClust
       }
     end
 
+    def compile_function(f, opt = nil)
+      @opt = opt
+      @type = :function
+      setup(f.source) {
+        entry
+      }
+    ensure
+      @opt = nil
+    end
+
     # FIXME
     def compile_method(m, opt = nil)
       @opt = opt
       @type = :method
       @method = m
       setup(m.source) {
-        method_entry
+        entry
       }
     ensure
       @opt = nil
@@ -63,13 +73,13 @@ module BitClust
       while @f.next?
         case @f.peek
         when /\A---/
-          method_entry_chunk
+          entry_chunk
         when /\A=+/
           headline @f.gets
-        when /\A\s+\*\s/
-          ulist
-        when /\A\s+\(\d+\)\s/
-          olist
+        when /\A(\s+)\*\s/, /\A(\s+)\(\d+\)\s/
+          @item_stack = []
+          item_list($1.size)
+          raise "@item_stack should be empty. #{@item_stack.inspect}" unless @item_stack.empty?
         when %r<\A//emlist\{>
           emlist
         when /\A:\s/
@@ -86,13 +96,13 @@ module BitClust
       end
     end
 
-    def method_entry
+    def entry
       while @f.next?
-        method_entry_chunk
+        entry_chunk
       end
     end
 
-    def method_entry_chunk
+    def entry_chunk
       @out.puts '<dl>' if @option[:force]
       first = true
       @f.while_match(/\A---/) do |line|
@@ -103,8 +113,8 @@ module BitClust
       @f.while_match(/\A:/) do |line|
         k, v = line.sub(/\A:/, '').split(':', 2)
         props[k.strip] = v.strip
-      end
-      @out.puts '<dd class="method-description">'
+      end if @type == :method
+      @out.puts %Q(<dd class="#{@type.to_s}-description">)
       while @f.next?
         case @f.peek
         when /\A===+/
@@ -113,14 +123,14 @@ module BitClust
           if @option[:force]
             break
           else
-            raise "method entry includes headline: #{@f.peek.inspect}"
+            raise "#{@type.to_s} entry includes headline: #{@f.peek.inspect}"
           end
         when /\A---/
           break
-        when /\A\s+\*\s/
-          ulist
-        when /\A\s+\(\d+\)\s/
-          olist
+        when /\A(\s+)\*\s/, /\A(\s+)\(\d+\)\s/
+          @item_stack = []
+          item_list($1.size)
+          raise "@item_stack should be empty. #{@item_stack.inspect}" unless @item_stack.empty?
         when /\A:\s/
           dlist
         when %r<\A//emlist\{>
@@ -132,12 +142,12 @@ module BitClust
         when /@todo/
           todo
         when /\A@[a-z]/
-          method_info
+          entry_info
         else
           if @f.peek.strip.empty?
             @f.gets
           else
-            method_entry_paragraph
+            entry_paragraph
           end
         end
       end
@@ -157,32 +167,45 @@ module BitClust
       "<h#{level} #{name}>#{label}</h#{level}>"
     end
 
-    def ulist
-      @out.puts '<ul>'
-      @f.while_match(/\A\s+\*\s/) do |line|
-        string '<li>'
-        string compile_text(line.sub(/\A\s+\*/, '').strip)
-        @f.while_match(/\A\s+[^\*\s]/) do |cont|
-          nl
-          string compile_text(cont.strip)
-        end
-        line '</li>'
+    def item_list(level = 0, indent = true)
+      open_tag = nil
+      close_tag = nil
+      pattern = nil
+      case @f.peek
+      when /\A(\s+)\*\s/
+        open_tag  =  "<ul>"
+        close_tag = "</ul>"
+      when /\A(\s+)\(\d+\)\s/
+        open_tag  = "<ol>"
+        close_tag = "</ol>"
       end
-      line '</ul>'
-    end
-
-    def olist
-      @out.puts '<ol>'
-      @f.while_match(/\A\s+\(\d+\)/) do |line|
-        string '<li>'
-        string compile_text(line.sub(/\A\s+\(\d+\)/, '').strip)
-        @f.while_match(/\A\s+(?!\(\d+\))\S/) do |cont|
-          string "\n"
-          string compile_text(cont.strip)
+      if indent
+        line open_tag
+        @item_stack.push(close_tag)
+      end
+      @f.while_match(/\A(\s+)(?:\*\s|\(\d+\))/) do |line|
+        string "<li>"
+        @item_stack.push("</li>")
+        string compile_text(line.sub(/\A(\s+)(?:\*|\(\d+\))/, '').strip)
+        if /\A(\s+)(?!\*\s|\(\d+\))\S/ =~ @f.peek
+          @f.while_match(/\A\s+(?!\*\s|\(\d+\))\S/) do |cont|
+            nl
+            string compile_text(cont.strip)
+          end
+          line @item_stack.pop # current level li
+        elsif /\A(\s+)(?:\*\s|\(\d+\))/ =~ @f.peek and level < $1.size
+          item_list($1.size)
+          line @item_stack.pop # current level ul or ol
+        elsif /\A(\s+)(?:\*\s|\(\d+\))/ =~ @f.peek and level > $1.size
+          line @item_stack.pop # current level li
+          line @item_stack.pop # current level ul or ol
+          line @item_stack.pop # previous level li
+          item_list($1.size, false)
+        else
+          line @item_stack.pop # current level li
         end
-        line '</li>'
       end
-      line '</ol>'
+      line @item_stack.pop unless @item_stack.empty?
     end
 
     def dlist
@@ -293,7 +316,7 @@ module BitClust
       line '</p>'
     end
 
-    def method_info
+    def entry_info
       line '<dl>'
       while @f.next? and /\A\@(?!see)\w+|\A$/ =~ @f.peek
         header = @f.gets
@@ -303,7 +326,7 @@ module BitClust
         case cmd
         when '@param', '@arg'
           name = header.slice!(/\A\s*\w+/) || '?'
-          line "<dt class='method-param'>[PARAM] #{escape_html(name.strip)}:</dt>"
+          line "<dt class='#{@type.to_s}-param'>[PARAM] #{escape_html(name.strip)}:</dt>"
         when '@raise'
           ex = header.slice!(/\A\s*[\w:]+/) || '?'
           line "<dt>[EXCEPTION] #{escape_html(ex.strip)}:</dt>"
@@ -318,15 +341,15 @@ module BitClust
     end
 
     # FIXME: parse @param, @return, ...
-    def method_entry_paragraph
+    def entry_paragraph
       line '<p>'
-      read_method_entry_paragraph(@f).each do |line|
+      read_entry_paragraph(@f).each do |line|
         line compile_text(line.strip)
       end
       line '</p>'
     end
 
-    def read_method_entry_paragraph(f)
+    def read_entry_paragraph(f)
       f.span(%r<\A(?!---|=|//emlist\{|@[a-z])\S>)
     end
 
@@ -342,6 +365,8 @@ module BitClust
       if first
         string '<span class="permalink">['
         string a_href(@urlmapper.method_url(methodid2specstring(@method.id)), "permalink")
+        string ']['
+        string rdoc_link(@method.id, @option[:database].properties["version"])
         string ']</span>'
       end
       if @method and not @method.defined?
@@ -370,7 +395,7 @@ module BitClust
       arg = _arg.rstrip
       case type
       when 'lib'
-      then protect(link) {
+        protect(link) {
           case arg
           when '/', '_index'
             label = 'All libraries'
@@ -379,20 +404,26 @@ module BitClust
           end
           library_link(arg, label, frag)
         }
-      when 'c'       then protect(link) { class_link(arg, label, frag) }
-      when 'm'       then protect(link) { method_link(complete_spec(arg), label || arg, frag) }
+      when 'c'
+        protect(link) { class_link(arg, label, frag) }
+      when 'm'
+        protect(link) { method_link(complete_spec(arg), label || arg, frag) }
       when 'f'
-      then protect(link) {
+        protect(link) {
           case arg
           when '/', '_index'
             arg, label = '', 'All C API'
           end
           function_link(arg, label || arg, frag)
         }
-      when 'd'       then protect(link) { document_link(arg, label, frag) }
-      when 'ref'     then protect(link) { reference_link(arg) }
-      when 'url'     then direct_url(arg)
-      when 'man'     then man_link(arg)
+      when 'd'
+        protect(link) { document_link(arg, label, frag) }
+      when 'ref'
+        protect(link) { reference_link(arg) }
+      when 'url'
+        direct_url(arg)
+      when 'man'
+        man_link(arg)
       when 'rfc', 'RFC'
         rfc_link(arg)
       when 'ruby-list', 'ruby-dev', 'ruby-ext', 'ruby-talk', 'ruby-core'
@@ -462,7 +493,7 @@ module BitClust
     MAN_HEADER_URL = "#{opengroup_url}/basedefs/%s.html"
     MAN_LINUX_URL = "http://man7.org/linux/man-pages/man%1$s/%2$s.%1$s.html"
     MAN_FREEBSD_URL = "http://www.freebsd.org/cgi/man.cgi?query=%2$s&sektion=%1$s&manpath=FreeBSD+9.0-RELEASE"
-    
+
     def man_url(section, page)
       case section
       when "1"
@@ -475,17 +506,30 @@ module BitClust
         sprintf(MAN_LINUX_URL, $1, page)
       when /\A([1-9])freebsd\Z/
         sprintf(MAN_FREEBSD_URL, $1, page)
-      else 
+      else
         nil
       end
     end
-    
+
     def man_link(spec)
       m = /([\w\.\/]+)\((\w+)\)/.match(spec) or return escape_html(spec)
       url = man_url(m[2], escape_html(m[1])) or return escape_html(spec)
       %Q(<a class="external" href="#{escape_html(url)}">#{escape_html("#{m[1]}(#{m[2]})")}</a>)
     end
 
+    def rdoc_url(method_id, version)
+      cname, tmark, mname, libname = methodid2specparts(method_id)
+      tchar = typemark2char(tmark) == 'i' ? 'i' : 'c'
+      cname = cname.gsub('::', '/')
+      id = "method-#{tchar}-#{encodename_rdocurl(mname)}"
+
+      "http://docs.ruby-lang.org/en/#{version}/#{cname}.html##{id}"
+    end
+
+    def rdoc_link(method_id, version)
+      a_href(rdoc_url(method_id, version), "rdoc")
+    end
+
     def complete_spec(spec0)
       case spec0
       when /\A\$/