bitclust-core 0.5.0

data/lib/bitclust/crossrubyutils.rb

@@ -0,0 +1,91 @@
+#
+# bitclust/crossrubyutils.rb
+#
+# Copyright (c) 2006 Minero Aoki
+#
+
+module BitClust
+
+  module CrossRubyUtils
+
+    private
+
+    def print_crossruby_table(&block)
+      print_table(*build_crossruby_table(&block))
+    end
+
+    def print_table(vers, table)
+      thcols = ([20] + table.keys.map {|s| s.size }).max
+      versions = vers.map {|ver| version_id(ver) }
+      width_list = versions.map{|v| v.size + 1 }
+      print_record thcols, '', versions, width_list
+      crossrubyutils_sort_entries(table.keys).each do |c|
+        print_record thcols, c, vers.map {|ver| table[c][ver] ? 'o' : '-' }, width_list
+      end
+    end
+
+    def crossrubyutils_sort_entries(ents)
+      ents.sort
+    end
+
+    def print_record(thcols, th, tds, width_list = nil)
+      unless width_list
+        width_list = Array.new(tds.size){ 4 }
+      end
+      printf "%-#{thcols}s ", th
+      puts tds.zip(width_list).map {|td, width| "%#{width}s" % td }.join('')
+    end
+
+    def version_id(ver)
+      ver.split[1].tr('.', '')
+    end
+
+    def get_ruby(version)      
+      forall_ruby(ENV['PATH']) do |ruby, |
+        v = `#{ruby} -e 'print RUBY_VERSION'`
+        patch = `#{ruby} -e 'print RUBY_PATCHLEVEL if defined? RUBY_PATCHLEVEL'`
+        if version == v or ( version == v.succ and patch == '5000')
+          return ruby
+        end
+      end
+      return nil
+    end
+    
+    def build_crossruby_table
+      ENV.delete 'RUBYOPT'
+      ENV.delete 'RUBYLIB'
+      ENV.delete 'GEM_HOME'
+      vers = []
+      table = {}
+      forall_ruby(ENV['PATH']) do |ruby, ver|
+        puts "#{version_id(ver)}: #{ver}" if @verbose
+        vers.push ver
+        yield(ruby).each do |c|
+          (table[c] ||= {})[ver] = true
+        end
+      end
+      return vers, table
+    end
+
+    def forall_ruby(path, &block)
+      rubys(path)\
+          .map {|ruby| [ruby, `#{ruby} --version`] }\
+          .reject {|ruby, verstr| `which #{ruby}`.include?('@') }\
+          .sort_by {|ruby, verstr| verstr }\
+          .each(&block)
+    end
+
+    def rubys(path)
+      parse_PATH(path).map {|bindir|
+        Dir.glob("#{bindir}/ruby-[12t]*").map {|path| File.basename(path) }
+      }\
+      .flatten.uniq + ['ruby']
+    end
+
+    def parse_PATH(str)
+      str.split(':').map {|path| path.empty? ? '.' : path }
+    end
+
+  end
+
+end

data/lib/bitclust/database.rb

@@ -0,0 +1,181 @@
+#
+# bitclust/database.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'
+require 'bitclust/exception'
+
+module BitClust
+
+  class Database
+
+    include NameUtils
+
+    def Database.datadir?(dir)
+      File.file?("#{dir}/properties")
+    end
+
+    def Database.connect(uri)
+      case uri.scheme
+      when 'file'
+        new(uri.path)
+      when 'druby'
+        DRbObject.new_with_uri(uri.to_s)
+      else
+        raise InvalidScheme, "unknown database scheme: #{uri.scheme}"
+      end
+    end
+
+    def Database.dummy(params = {})
+      db = new(nil)
+      db.properties['version'] = params['version']
+      db
+    end
+
+    def initialize(prefix)
+      @prefix = prefix
+      @properties = nil
+      @in_transaction = false
+      @properties_dirty = false
+    end
+    
+    def dummy?
+      not @prefix
+    end
+
+    #
+    # Transaction
+    #
+
+    def transaction
+      @in_transaction = true
+      yield
+      return if dummy?
+      if @properties_dirty
+        save_properties 'properties', @properties
+        @properties_dirty = false
+      end
+      commit if dirty?
+    ensure
+      @in_transaction = false
+    end
+
+    # abstract dirty?
+    # abstract clear_dirty
+    # abstract commit
+
+    def check_transaction
+      return if dummy?
+      unless @in_transaction
+        raise NotInTransaction, "database changed without transaction"
+      end
+    end
+    private :check_transaction
+
+    #
+    # Properties
+    #
+
+    def properties
+      @properties ||=
+          begin
+            h = load_properties('properties')
+            h.delete 'source' if h['source'] and h['source'].strip.empty?
+            h
+          end
+    end
+
+    def propkeys
+      properties().keys
+    end
+
+    def propget(key)
+      properties()[key]
+    end
+
+    def propset(key, value)
+      check_transaction
+      properties()[key] = value
+      @properties_dirty = true
+    end
+
+    def encoding
+      propget('encoding')
+    end
+
+    #
+    # Direct File Access Layer: BitClust internal use only
+    #
+
+    def exist?(rel)
+      return false unless @prefix
+      File.exist?(realpath(rel))
+    end
+
+    def entries(rel)
+      Dir.entries(realpath(rel))\
+          .reject {|ent| /\A[\.=]/ =~ ent }\
+          .map {|ent| decodeid(ent) }
+    rescue Errno::ENOENT
+      return []
+    end
+
+    def makepath(rel)
+      FileUtils.mkdir_p realpath(rel)
+    end
+
+    def load_properties(rel)
+      h = {}
+      fopen(realpath(rel), 'r:UTF-8') {|f|
+        while line = f.gets
+          k, v = line.strip.split('=', 2)
+          break unless k
+          h[k] = v
+        end
+        h['source'] = f.read
+      }
+      h
+    rescue Errno::ENOENT
+      return {}
+    end
+
+    def save_properties(rel, h)
+      source = h.delete('source')
+      atomic_write_open(rel) {|f|
+        h.each do |key, val|
+          f.puts "#{key}=#{val}"
+        end
+        f.puts
+        f.puts source
+      }
+    end
+
+    def read(rel)
+      File.read(realpath(rel))
+    end
+
+    def foreach_line(rel, &block)
+      File.foreach(realpath(rel), &block)
+    end
+
+    def atomic_write_open(rel, &block)
+      tmppath = realpath(rel) + '.writing'
+      fopen(tmppath, 'wb', &block)
+      File.rename tmppath, realpath(rel)
+    ensure
+      File.unlink tmppath  rescue nil
+    end
+
+    def realpath(rel)
+      "#{@prefix}/#{encodeid(rel)}"
+    end
+    private :realpath
+
+  end
+
+end

data/lib/bitclust/docentry.rb

@@ -0,0 +1,83 @@
+#
+# bitclust/docentry.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 DocEntry < Entry
+
+    def self.type_id
+      :doc
+    end
+
+    def initialize(db, id)
+      super db
+      @id = id
+      init_properties
+    end
+
+    attr_reader :id
+
+    def ==(other)
+      @id == other.id
+    end
+
+    alias eql? ==
+
+    def hash
+      @id.hash
+    end
+
+    def <=>(other)
+      @id.casecmp(other.id)
+    end
+
+    def name
+      libid2name(@id)
+    end
+
+    alias label name
+
+    def labels
+      [label()]
+    end
+    
+    def name?(n)
+      name() == n
+    end
+
+    persistent_properties {
+      property :title,    'String'
+      property :source,   'String'
+    }
+
+    def inspect
+      "#<doc #{@id}>"
+    end
+
+    def classes
+      @db.classes
+    end
+
+    def error_classes
+      classes.select{|c| c.ancestors.any?{|k| k.name == 'Exception' }}
+    end
+    
+    def methods
+      @db.methods
+    end
+
+    def libraries
+      @db.libraries
+    end
+  end
+
+end

data/lib/bitclust/entry.rb

@@ -0,0 +1,223 @@
+#
+# bitclust/entry.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/nameutils'
+require 'bitclust/exception'
+
+module BitClust
+
+  class Entry
+
+    include NameUtils
+
+    def self.persistent_properties
+      @slots = []
+      yield
+      sep = ";"
+      module_eval(src = <<-End, __FILE__, __LINE__ + 1)
+        def init_properties
+          if saved?
+            #{@slots.map {|s| "@#{s.name} = nil" }.join(sep)}
+            @loaded = false
+          else
+            clear
+          end
+        end
+
+        def clear
+          #{@slots.map {|s| "@#{s.name} = #{s.initial_value}" }.join(sep)}
+          @loaded = true
+        end
+
+        def _set_properties(h)
+          #{@slots.map {|s| "@#{s.name} = #{s.deserializer}" }.join(sep)}
+        end
+
+        def _get_properties
+          h = {}
+          #{@slots.map {|s| "h['#{s.name}'] = #{s.serializer}" }.join(sep)}
+          h
+        end
+
+        def unload
+          clear
+          @loaded = false
+        end
+      End
+      @slots.each do |slot|
+        module_eval(<<-End, __FILE__, __LINE__ + 1)
+          def #{slot.name}
+            load unless @loaded
+            @#{slot.name}
+          end
+
+          def #{slot.name}=(value)
+            load unless @loaded
+            @#{slot.name} = value
+          end
+        End
+      end
+    end
+
+    def self.property(name, type)
+      @slots.push Property.new(name, type)
+    end
+
+    class Property
+      def initialize(name, type)
+        @name = name
+        @type = type
+      end
+
+      attr_reader :name
+
+      def initial_value
+        case @type
+        when 'String'         then "'(uninitialized)'"
+        when 'Symbol'         then "nil"
+        when 'bool'           then "false"
+        when 'LibraryEntry'   then "nil"
+        when 'ClassEntry'     then "nil"
+        when 'MethodEntry'    then "nil"
+        when '[String]'       then "[]"
+        when '[LibraryEntry]' then "[]"
+        when '[ClassEntry]'   then "[]"
+        when '[MethodEntry]'  then "[]"
+        else
+          raise "must not happen: @type=#{@type.inspect}"
+        end
+      end
+
+      def deserializer
+        case @type
+        when 'String'         then "h['#{@name}']"
+        when 'Symbol'         then "h['#{@name}'].intern"
+        when 'bool'           then "h['#{@name}'] == 'true' ? true : false"
+        when 'LibraryEntry'   then "restore_library(h['#{@name}'])"
+        when 'ClassEntry'     then "restore_class(h['#{@name}'])"
+        when 'MethodEntry'    then "restore_method(h['#{@name}'])"
+        when '[String]'       then "h['#{@name}'].split(/,(?=.)/)"
+        when '[LibraryEntry]' then "restore_libraries(h['#{@name}'])"
+        when '[ClassEntry]'   then "restore_classes(h['#{@name}'])"
+        when '[MethodEntry]'  then "restore_methods(h['#{@name}'])"
+        else
+          raise "must not happen: @type=#{@type.inspect}"
+        end
+      end
+
+      def serializer
+        case @type
+        when 'String'         then "@#{@name}"
+        when 'Symbol'         then "@#{@name}.to_s"
+        when 'bool'           then "@#{@name}.to_s"
+        when 'LibraryEntry'   then "serialize_entry(@#{@name})"
+        when 'ClassEntry'     then "serialize_entry(@#{@name})"
+        when 'MethodEntry'    then "serialize_entry(@#{@name})"
+        when '[String]'       then "@#{@name}.join(',')"
+        when '[LibraryEntry]' then "serialize_entries(@#{@name})"
+        when '[ClassEntry]'   then "serialize_entries(@#{@name})"
+        when '[MethodEntry]'  then "serialize_entries(@#{@name})"
+        else
+          raise "must not happen: @type=#{@type.inspect}"
+        end
+      end
+    end
+
+    class << self
+      alias load new
+    end
+
+    def initialize(db)
+      @db = db
+    end
+
+    def type_id
+      self.class.type_id
+    end
+
+    def loaded?
+      @loaded
+    end
+
+    def encoding
+      @db.encoding
+    end
+
+    def synopsis_source
+      source().split(/\n\n/, 2).first || ''
+    end
+
+    def detail_source
+      source().split(/\n\n/, 2)[1] || ''
+    end
+
+    def save
+      @db.save_properties objpath(), _get_properties()
+    rescue Errno::ENOENT
+      @db.makepath File.dirname(objpath())
+      retry
+    end
+
+    private
+
+    def load
+      _set_properties @db.load_properties(objpath())
+      @loaded = true
+    end
+
+    def saved?
+      @db.exist?(objpath())
+    end
+
+    def restore_library(id)
+      LibraryEntry.load(@db, id)
+    end
+
+    def restore_class(id)
+      id.empty? ? nil : ClassEntry.load(@db, id)
+    end
+
+    def restore_libraries(str)
+      restore_entries(str, LibraryEntry)
+    end
+
+    def restore_classes(str)
+      restore_entries(str, ClassEntry)
+    end
+
+    def restore_methods(str)
+      restore_entries(str, MethodEntry)
+    end
+
+    def restore_entries(str, klass)
+      str.split(',').map {|id| klass.load(@db, id) }
+    end
+
+    def serialize_entry(x)
+      x ? x.id : ''
+    end
+
+    def serialize_entries(xs)
+      xs.map {|x| x.id }.join(',')
+    end
+
+    def objpath
+      "#{type_id()}/#{id()}"
+    end
+
+    def path_string(path)
+      i = path.index(name())
+      (path[i..-1] + [name()]).join(' -> ')
+    end
+    private :path_string
+
+  end
+
+end