bitclust-core 0.5.0

data/lib/bitclust/libraryentry.rb

@@ -0,0 +1,211 @@
+#
+# bitclust/libraryentry.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 LibraryEntry < Entry
+
+    include Enumerable
+
+    def LibraryEntry.type_id
+      :library
+    end
+
+    def initialize(db, id)
+      super db
+      @id = id
+      if saved?
+        @classmap = nil
+        @methodmap = nil
+        @link_checked = true
+      else
+        @classmap = {}
+        @methodmap = {}
+        @link_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.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 :requires, '[LibraryEntry]'
+      property :classes,  '[ClassEntry]'   # :defined classes
+      property :methods,  '[MethodEntry]'  # :added/:redefined entries
+      property :source,   'String'
+      property :sublibraries, '[LibraryEntry]'
+      property :is_sublibrary,   'bool'
+    }
+
+    def inspect
+      "#<library #{@id}>"
+    end
+
+    def check_link(path = [])
+      return if @link_checked
+      if path.include?(name())
+        raise InvalidLink, "looped require: #{path_string(path)}"
+      end
+      path.push name()
+      requires().each do |lib|
+        lib.check_link path
+      end
+      path.pop
+      @link_checked = true
+    end
+
+    def all_requires(libs = {})
+      requires.each{|l|
+        next if libs[l.name]
+        libs[l.name] = l
+        l.all_requires(libs)
+      }
+      libs.values
+    end
+
+    def all_classes
+      return @all_classes if @all_classes
+      required_classes = (sublibraries & requires).map{|l| l.classes }.flatten
+      @all_classes = (classes() + required_classes).uniq.sort
+    end
+
+    def error_classes
+      @error_classes ||= classes.select{|c| c.ancestors.any?{|k| k.name == 'Exception' }}
+    end
+
+    def all_error_classes
+      @all_error_classes ||= all_classes.select{|c| c.ancestors.any?{|k| k.name == 'Exception' }}
+    end
+
+    def require(lib)
+      requires().push lib
+    end
+
+    def sublibrary(lib)
+      unless sublibraries().include?(lib)
+        sublibraries().push lib
+        lib.is_sublibrary = true
+      end
+    end
+
+    def fetch_class(name)
+      get_class(name) or
+          raise ClassNotFound, "no such class in the library #{name()}: #{name}"
+    end
+
+    def get_class(name)
+      classes().detect {|c| c.name == name }
+    end
+
+    def classnames
+      classes().map {|c| c.name }
+    end
+
+    def each_class(&block)
+      classes().each(&block)
+    end
+
+    def classmap
+      @classmap ||=
+          begin
+            h = {}
+            classes().each do |c|
+              h[c.name] = c
+            end
+            h
+          end
+    end
+    private :classmap
+
+    def fetch_methods(spec)
+      ms = if c = get_class(spec.klass)
+           then c.fetch_methods(spec)
+           else []
+           end +
+           methods().select {|m| spec.match?(m) }
+      if ms.empty?
+        raise MethodNotFound, "no such method in the library #{name()}: #{name}"
+      end
+      ms
+    end
+
+    def fetch_method(spec)
+      classes().each do |c|
+        m = c.get_method(spec)
+        return m if m
+      end
+      methods().detect {|m| spec.match?(m) } or
+        raise MethodNotFound, "no such method in the library #{name()}: #{name}"
+    end
+
+    def each_method(&block)
+      methods().each(&block)
+    end
+
+    def methodmap
+      @methodmap ||=
+          begin
+            h = {}
+            methods().each do |m|
+              h[m] = m
+            end
+            h
+          end
+    end
+    private :methodmap
+
+    def add_class(c)
+      unless classmap()[c.name]
+        classes().push c
+        classmap()[c.name] = c
+        @db.dirty_library self
+      end
+    end
+
+    def add_method(m)
+      unless methodmap()[m]
+        methods().push m
+        methodmap()[m] = m
+        @db.dirty_library self
+      end
+    end
+
+  end
+
+end

data/lib/bitclust/lineinput.rb

@@ -0,0 +1,165 @@
+#
+# $Id: lineinput.rb 3723 2007-03-28 21:34:13Z aamine $
+#
+# Copyright (c) 2002-2007 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+#
+
+require 'stringio'
+
+class LineInput
+
+  def LineInput.for_string(s)
+    new(StringIO.new(s))
+  end
+
+  def initialize(f)
+    @input = f
+    @buf = []
+    @lineno = 0
+    @eof_p = false
+  end
+
+  def inspect
+    "\#<#{self.class} file=#{@input.inspect} line=#{lineno()}>"
+  end
+
+  def eof?
+    @eof_p
+  end
+
+  def path
+    @input.path
+  end
+
+  def lineno
+    @lineno
+  end
+
+  def gets
+    unless @buf.empty?
+      @lineno += 1
+      return @buf.pop
+    end
+    return nil if @eof_p   # to avoid ARGF blocking.
+    line = @input.gets
+    @eof_p = true unless line
+    @lineno += 1
+    line
+  end
+
+  def ungets(line)
+    return unless line
+    @lineno -= 1
+    @buf.push line
+    line
+  end
+
+  def peek
+    line = gets()
+    ungets line if line
+    line
+  end
+
+  def next?
+    peek() ? true : false
+  end
+
+  def skip_blank_lines
+    n = 0
+    while line = gets()
+      unless line.strip.empty?
+        ungets line
+        return n
+      end
+      n += 1
+    end
+    n
+  end
+
+  def gets_if(re)
+    line = gets()
+    if not line or not (re =~ line)
+      ungets line
+      return nil
+    end
+    line
+  end
+
+  def gets_unless(re)
+    line = gets()
+    if not line or re =~ line
+      ungets line
+      return nil
+    end
+    line
+  end
+
+  def each
+    while line = gets()
+      yield line
+    end
+  end
+
+  def while_match(re)
+    while line = gets()
+      unless re =~ line
+        ungets line
+        return
+      end
+      yield line
+    end
+    nil
+  end
+
+  def getlines_while(re)
+    buf = []
+    while_match(re) do |line|
+      buf.push line
+    end
+    buf
+  end
+
+  alias span getlines_while   # from Haskell
+
+  def until_match(re)
+    while line = gets()
+      if re =~ line
+        ungets line
+        return
+      end
+      yield line
+    end
+    nil
+  end
+
+  def getlines_until(re)
+    buf = []
+    until_match(re) do |line|
+      buf.push line
+    end
+    buf
+  end
+
+  alias break getlines_until   # from Haskell
+
+  def until_terminator(re)
+    while line = gets()
+      return if re =~ line   # discard terminal line
+      yield line
+    end
+    nil
+  end
+
+  def getblock(term_re)
+    buf = []
+    until_terminator(term_re) do |line|
+      buf.push line
+    end
+    buf
+  end
+
+end

data/lib/bitclust/messagecatalog.rb

@@ -0,0 +1,95 @@
+#
+# bitclust/messagecatalog.rb
+#
+# Copyright (c) 2006-2008 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the Ruby License.
+#
+
+module BitClust
+
+  module Translatable
+
+    private
+
+    def init_message_catalog(catalog)
+      @__message_catalog = catalog
+    end
+
+    def message_catalog
+      @__message_catalog
+    end
+
+    def _(key, *args)
+      @__message_catalog.translate(key, *args)
+    end
+
+  end
+
+  # FIXME: support automatic encoding-conversion
+  class MessageCatalog
+
+    ENCODING_MAP = {
+      'utf-8' => 'UTF-8',
+      'euc-jp' => 'EUC-JP',
+      'shift_jis' => 'Shift_JIS'
+    }
+
+    # FIXME: support non ja_JP locales
+    def MessageCatalog.encoding2locale(enc)
+      newenc = ENCODING_MAP[enc.downcase]
+      newenc ? "ja_JP.#{newenc}" : "C"
+    end
+
+    def MessageCatalog.load(prefix)
+      load_with_locales(prefix, env_locales())
+    end
+
+    def MessageCatalog.load_with_locales(prefix, locales)
+      path, loc = find_catalog(prefix, locales)
+      path ? load_file(path, loc) : new({}, 'C')
+    end
+
+    def MessageCatalog.env_locales
+      [ENV['LC_MESSAGES'], ENV['LC_ALL'], ENV['LANG'], 'C']\
+          .compact.uniq.reject {|loc| loc.empty? }
+    end
+    private_class_method :env_locales
+
+    def MessageCatalog.find_catalog(prefix, locales)
+      locales.each do |locale|
+        path = "#{prefix}/#{locale}"
+        return path, locale if File.file?(path)
+      end
+      nil
+    end
+    private_class_method :find_catalog
+
+    def MessageCatalog.load_file(path, locale)
+      h = {}
+      fopen(path, 'r:UTF-8') {|f|
+        f.each do |key|
+          h[key.chomp] = f.gets.chomp
+        end
+      }
+      new(h, locale)
+    end
+
+    def initialize(msgs, locale)
+      @msgs = msgs
+      @locale = locale
+    end
+
+    def inspect
+      "\#<#{self.class} #{@locale}>"
+    end
+
+    def translate(key, *args)
+      str = @msgs[key] || key
+      sprintf(str, *args)
+    end
+
+  end
+
+end