tdiary 3.2.2.20130518 → 3.2.2.20130527

data/vendor/rdtool-0.6.38/lib/rd/rdvisitor.rb

@@ -1,214 +0,0 @@
-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/vendor/rdtool-0.6.38/lib/rd/reference-resolver.rb

@@ -1,114 +0,0 @@
-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/vendor/rdtool-0.6.38/lib/rd/search-file.rb

@@ -1,14 +0,0 @@
-
-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/vendor/rdtool-0.6.38/lib/rd/tree.rb

@@ -1,103 +0,0 @@
-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: "+RD::VERSION+"$"
-    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