rdtool 0.6.23

data/lib/rd/rdvisitor.rb

@@ -0,0 +1,214 @@
+require 'rd/output-format-visitor'
+require 'rd/reference-resolver'
+require 'rd/rbl-file'
+require 'forwardable'
+
+module RD
+  # for Backward compatibility
+  class RDVisitor < OutputFormatVisitor
+    extend Forwardable
+
+    def apply_to_DescListItemTerm(element, contents)
+      contents
+    end
+
+    def apply_to_MethodListItemTerm(element)
+      apply_to_String(element.content)
+    end
+    
+    def_delegator(:@reference_resolver, :labels, :__labels__)
+    def_delegator(:@reference_resolver, :label_prefix, :__label_prefix__)
+    def_delegator(:@reference_resolver, :rbl_suite)
+
+    def prepare_labels(tree, prefix = "label:")
+      @reference_resolver = ReferenceResolver.new(tree, prefix)
+    end
+
+    def_delegator(:@reference_resolver, :refer)
+    def_delegator(:@reference_resolver, :get_anchor)
+    def_delegator(:@reference_resolver, :make_rbl_file)
+
+    def refer_external(label)
+      label = @reference_resolver.refer_external_file(label)
+      return nil unless label
+      label[1]
+    end
+  end
+
+  module AutoLabel
+    def parse_rmi(src)
+      labels = {}
+      $method_index = []
+      eval(src)
+      $method_index.each do |c, k, m, f, l|
+	labels[c + k + m] = l
+      end
+      labels
+    end
+    private :parse_rmi
+  end # AutoLabel
+
+=begin
+== module RD::MethodParse
+this module provide several functions for MehotList.
+=end
+  
+  module MethodParse
+
+    def analize_method(method)
+      klass = nil
+      args = nil
+      kind = nil
+      if /[^{(\s]+/ =~ method
+	method = $&
+	args = $'                   # '
+      end
+
+      if /^(.*)(#|::|\.)/ =~ method
+	klass = $1
+	kind = str2kind($2)
+	method = $'                 # '
+      end
+      
+      if klass == "function" and kind == :instance_method
+	kind = :function
+      end
+      
+      [klass, kind, method, args]
+    end
+    module_function :analize_method
+
+    def str2kind(str)
+      case str
+      when '#'
+	:instance_method
+      when '.'
+	:class_method
+      when '::'
+	:constant
+      end
+    end
+    module_function :str2kind
+            
+    def kind2str(int)
+      case int
+      when :instance_method, :function
+	'#'
+      when :class_method
+	'.'
+      when :constant
+	'::'
+      end
+    end
+    module_function :kind2str
+
+    KIND2NUM = {:constant => 0, :class_method => 1, :instance_method => 2, :function => 2}
+    def kind2num(str)
+      KIND2NUM[str]
+    end
+    module_function :kind2num
+       
+    def make_mindex_label(element)
+      klass, kind, method = analize_method(element.label)
+      case kind
+      when :class_method
+	klass + "_S_" + tr_method(method)
+      when :instance_method
+	klass + "_" + tr_method(method)
+      when :constant
+	klass + "_" + method
+      when :function
+	"function_" + tr_method(method)
+      else
+	element.label
+      end
+    end
+    module_function :make_mindex_label
+
+    def tr_method(method)
+      case method
+      when "[]"
+	"ref_"
+      when "[]="
+	"set_"
+      when "+"
+	"plus_"
+      when "+@"
+	"uplus_"
+      when "-"
+	"minus_"
+      when "-@"
+	"uminus_"
+      when "*"
+	"mul_"
+      when "/"
+	"div_"
+      when "%"
+        "mod_"
+      when "**"
+	"power_"
+      when "~"
+	"inv_"
+      when "=="
+	"eq_"
+      when "==="
+	"eqq_"
+      when "=~"
+	"match_"
+      when "&"
+	"and_"
+      when "|"
+	"or_"
+      when "<<"
+	"lshift_"
+      when ">>"
+	"rshift_"
+      when "<=>"
+	"cmp_"
+      when "<"
+	"lt_"
+      when "<="
+	"le_"
+      when ">"
+	"gt_"
+      when ">="
+	"ge_"
+      when "^"
+	"xor_"
+      when "`"
+	"backquote_"
+      when /!$/
+	$` + "_bang"     # `
+      when /\?$/
+	$` + "_p"        # `
+      when /=$/
+	$` + "_eq"       # `
+      else
+	method
+      end
+    end
+    module_function :tr_method
+    
+    def make_method_index(tree)
+      indexes = []
+      tree.each do |i|
+	if i.is_a?(MethodListItem)
+	  klass, kind, method, args = analize_method(i.term.content)
+	  indexes.push([klass, kind2num(kind), method, kind]) if kind
+	end
+      end
+      indexes.uniq!
+      indexes.sort.each {|i| i[1] = i.pop}
+    end
+    module_function :make_method_index
+	  
+  end # MethodParse
+end # RD
+
+=begin
+== script info.
+ abstruct class for visitor of RDTree.
+ $Id: rdvisitor.rb,v 1.46 2003/02/18 16:20:25 tosh Exp $
+
+=end
+

data/lib/rd/reference-resolver.rb

@@ -0,0 +1,114 @@
+require 'rd/rbl-suite'
+require 'rd/labeled-element'
+
+require 'forwardable'
+
+module RD
+  class ReferenceResolver
+    extend Forwardable
+    include Enumerable
+    
+    attr_reader :labels
+    attr_reader :label_prefix
+    attr_reader :rbl_suite
+    
+    def initialize(tree, prefix = "label:")
+      init_labels(tree)
+      @label_prefix = prefix
+      @rbl_suite = RBLSuite.new(tree.include_path)
+    end
+
+    def init_labels(tree)
+      @labels = {}
+      ary = (tree.find_all do |i|
+	       i.is_a? LabeledElement
+	     end)
+      num = 0
+      ary.each do |i|
+	push_to_labels(i.to_label, [i, num])
+	num += 1
+      end
+    end
+    private :init_labels
+
+    def push_to_labels(key, value)
+      if labels[key]
+	labels[key].push(value)
+      else
+	labels[key] = [value]
+      end
+    end
+    private :push_to_labels
+
+    def each_label
+      tmp = []
+      labels.each_value do |i|
+	i.each do |j|
+	  tmp.push(j)
+	end
+      end
+      tmp.sort{|i,j| i[1] <=> j[1]}.each do |i|
+	yield(i[0])
+      end
+    end
+    alias each each_label
+
+    def referent_of_label(label)
+      label = label.label if label.is_a? Reference
+      if label.filename
+	refer_external_file(label)
+      else
+	anchor = refer(label)
+	return nil unless anchor
+	[nil, anchor]
+      end
+    end
+
+    def refer(label)
+      matched = labels[label2str(label)]
+      return nil unless matched
+      num2anchor(matched[0][1])
+    end
+
+    def refer_element(label)
+      labels.fetch(label2str(label), []).collect{|i| i[0] }
+    end
+
+    def refer_external_file(label)
+      label = label.label if label.is_a? Reference
+      rbl_suite.refer(label.element_label, label.filename)
+    end
+
+    def get_label_num(element)
+      entry = labels[element.to_label].find{|i| i[0] == element }
+      return nil unless entry
+      entry[1]
+    end
+
+    def get_anchor(element)
+      if num = get_label_num(element)
+	num2anchor(num)
+      end
+    end
+
+    def num2anchor(num)
+      label_prefix + num.to_s
+    end
+    private :num2anchor
+    
+    def label2str(label)
+      case label
+      when String
+	label
+      when Element, Reference::RDLabel
+	label.to_label
+      else
+	raise ArgumentError, "can't extract Label from #{label}."
+      end
+    end
+
+    def make_rbl_file(filename)
+      RBLFile.create_rbl_file(filename, self)
+    end
+  end
+end

data/lib/rd/search-file.rb

@@ -0,0 +1,14 @@
+
+module RD
+  module SearchFile
+    def search_file(base, include_path, suffixes)
+      include_path.each do |dir|
+	suffixes.each do |suffix|
+	  file = dir + "/" + base + "." + suffix
+	  return file if File.exist? file
+	end
+      end
+      nil
+    end
+  end
+end

data/lib/rd/tree.rb

@@ -0,0 +1,103 @@
+require "rd/rdblockparser.tab"
+require "rd/filter"
+require "rd/document-struct"
+require "rd/version"
+
+module RD
+
+  # document tree
+  class Tree
+    include Enumerable
+
+    SYSTEM_NAME = "RDtool Framework -- Document Tree"
+    SYSTEM_VERSION = "$Version: 0.6.23$" #"
+    VERSION = Version.new_from_version_string(SYSTEM_NAME, SYSTEM_VERSION)
+
+    def Tree.version
+      VERSION
+    end
+
+    TMP_DIR = "/tmp"
+
+    def Tree.tmp_dir
+      TMP_DIR
+    end
+
+    attr_reader :root
+    attr_reader :document_struct
+    attr_accessor :include_paths
+    alias include_path include_paths
+    alias include_path= include_paths=
+    attr_reader :filters
+    alias filter filters
+    attr_accessor :tmp_dir
+
+    def Tree.new_with_document_struct(document_struct, include_paths = [])
+      Tree.new(document_struct, nil, include_paths)
+    end
+
+    def initialize(document_struct, src_str = nil, include_paths = [])
+      @src = src_str
+      @document_struct = document_struct
+      @include_paths = include_paths
+      @filters = Hash.new()
+      @tmp_dir = TMP_DIR
+      @root = nil
+    end
+    
+    def parse
+      parser = RDParser.new
+      src = @src.respond_to?(:to_a) ? @src.to_a : @src.split(/^/)
+      set_root(parser.parse(src, self))
+    end
+
+    def set_root(element)
+      raise ArgumentError, "#{element.class} can't be root." unless
+	@document_struct.is_valid?(self, element)
+      @root = element
+      element.parent = self
+    end
+    alias root= set_root
+
+    def make_root(&block)
+      child = DocumentElement.new
+      set_root(child)
+      child.build(&block) if block_given?
+      child
+    end
+
+    def check_valid
+      each_element do |i|
+	raise RuntimeError,
+	  "mismatched document structure, #{i.parent} <-/- #{i}." unless
+	  @document_struct.is_valid?(i.parent, i)
+      end
+      true
+    end
+
+    def accept(visitor)
+      @root.accept(visitor)
+    end
+    
+    def each_element(&block)
+      return nil unless @root
+      @root.each(&block)
+    end
+    alias each each_element
+
+    def tree
+      self
+    end
+    
+    def Tree.new_from_rdo(*rdos) # rdos: IOs
+      tree = Tree.new("", [], nil)
+      tree_content = []
+      rdos.each do |i|
+	subtree = Marshal.load(i)
+	tree_content.concat(subtree.root.blocks)
+      end
+      tree.root = DocumentElement.new(tree_content)
+      tree
+    end
+  end
+end