rdtool 0.6.23

data/lib/rd/block-element.rb

@@ -0,0 +1,114 @@
+require 'rd/element'
+require 'rd/labeled-element'
+
+module RD
+  # Block-level Element of document tree. abstruct class.
+  class BlockElement < Element
+  end
+
+  class Headline < BlockElement
+    include NonterminalElement
+    include LabeledElement
+
+    MARK2LEVEL = {
+      "=" => 1,
+      "==" => 2,
+      "===" => 3,
+      "====" => 4,
+      "+" => 5,
+      "++" => 6
+    }
+    
+    attr_accessor :level
+    attr_reader :title
+    
+    def initialize(level_num)
+      super()
+      @level = level_num
+      @title = []
+    end
+    
+    def accept(visitor)
+      visitor.visit_Headline(self)
+    end
+
+    def calculate_label
+      ret = ""
+      @title.each do |i|
+	ret << i.to_label
+      end
+      ret
+    end
+    private :calculate_label
+    
+    def Headline.mark_to_level(mark_str)
+      MARK2LEVEL[mark_str] or
+	raise ArgumentError, "#{mark_str} is irregular for Headline mark."
+    end
+
+    def children
+      @title
+    end
+  end
+  
+  class Include < BlockElement
+    include TerminalElement
+    
+    attr_accessor :filename
+    
+    def initialize(filename)
+      super()
+      @filename = filename
+    end
+    
+    def accept(visitor)
+      visitor.visit_Include(self)
+    end
+  end # Include
+  
+  class TextBlock < BlockElement
+    include NonterminalElement
+    
+    attr_accessor :content
+    
+    def initialize()
+      super()
+      @content = []
+    end
+    
+    def accept(visitor)
+      visitor.visit_TextBlock(self)
+    end
+    
+    def children
+      @content
+    end
+  end
+  
+  class Verbatim < BlockElement
+    include TerminalElement
+    
+    attr_reader :content
+    
+    def initialize(content_strings = [])
+      super()
+      @content = content_strings  # Array of String
+    end
+    
+    def accept(visitor)
+      visitor.visit_Verbatim(self)
+    end
+    
+    def each_line
+      if @content.respond_to?(:each_line)
+        @content.each_line {|i|
+	  yield i
+	}
+      else
+        @content.each {|i|
+	  yield i
+	}
+      end
+    end
+  end
+end

data/lib/rd/complex-list-item.rb

@@ -0,0 +1,65 @@
+
+
+module RD
+  # abstruct class for ListItem which have term part additionaly. 
+  # (i.e. DescListItem and MethodListItem)
+  module ComplexListItem
+    def set_term(term)
+      set_term_under_document_struct(term, tree.document_struct)
+    end
+    alias term= set_term
+
+    def set_term_under_document_struct(term, document_struct)
+      raise ArgumentError unless document_struct.is_valid?(self, term)
+      assign_term(term)
+    end
+
+    def set_term_without_document_struct(term)
+      assign_term(term)
+    end
+
+    def assign_term(term)
+      @term = term
+      term.parent = self
+    end
+    
+    def make_term(*args_of_new, &block)
+      child = self.class::Term.new(*args_of_new)
+      set_term(child)
+      child.build(&block) if block_given?
+      child
+    end
+
+    def each_element(&block)
+      yield(self)
+      @term.each_element(&block)
+      @description.each do |i|
+	i.each_element(&block)
+      end
+    end
+    alias each each_element
+    
+    def each_block_in_description
+      @description.each do |i|
+	yield(i)
+      end
+    end
+    alias each_block each_block_in_description
+
+    def children
+      @description
+    end
+
+    def to_label
+      @term.to_label
+    end
+    alias label to_label
+
+    def inspect
+      t = indent2(term.inspect) if term
+      c  = children.collect{|i| indent2(i.inspect)}.join("\n")
+      "<#{self.class.name}>" + (term ? "\n" : "") + t.to_s +
+	(c.empty? ? "" : "\n") + c
+    end
+  end # ComplexListItem
+end # RD

data/lib/rd/desclist.rb

@@ -0,0 +1,55 @@
+require 'rd/element'
+require 'rd/list'
+require 'rd/complex-list-item'
+require 'rd/labeled-element'
+
+module RD
+  class DescList < List
+    def accept(visitor)
+      visitor.visit_DescList(self)
+    end
+  end
+  
+  class DescListItem < ListItem
+    include ComplexListItem
+    
+    attr_reader :term
+    attr_reader :description
+    
+    def initialize
+      @term = nil
+      @description = []
+      @label = nil
+    end
+
+    def accept(visitor)
+      visitor.visit_DescListItem(self)
+    end
+
+    class Term < Element
+      include NonterminalElement
+      include LabeledElement
+      
+      def initialize
+	@content = []
+      end
+
+      def calculate_label
+	ret = ""
+	children.each do |i|
+	  ret.concat(i.to_label)
+	end
+	ret
+      end
+      private :calculate_label
+
+      def accept(visitor)
+	visitor.visit_DescListItemTerm(self)
+      end
+      
+      def children
+	@content
+      end
+    end
+  end # DescListItem
+end # RD

data/lib/rd/document-struct.rb

@@ -0,0 +1,46 @@
+
+module RD
+  # DocumentStructure defines and restricts structure of document tree.
+  # it consists of ElementRelationship
+  class DocumentStructure
+    def initialize
+      @relationships = []
+    end
+    
+    def add_relationships(*relations)
+      @relationships += relations
+    end
+
+    def define_relationship(parent, child)
+      add_relationships(ElementRelationship.new(parent, child))
+    end
+
+    def each_relationship
+      @relationships.each do |i|
+	yield(i)
+      end
+    end
+
+    def is_valid?(parent, child)
+      each_relationship do |i|
+	return true if i.match?(parent, child)
+      end
+      false
+    end
+  end
+
+  # ElementRelationship is knowledge about parent-children relationship
+  # between Elements.
+  class ElementRelationship
+    attr_reader(:parent, :child)
+
+    def initialize(parent, child)
+      @parent = parent
+      @child = child
+    end
+
+    def match?(parent, child)
+      parent.is_a? @parent and child.is_a? @child
+    end
+  end
+end

data/lib/rd/dot.rd2rc

@@ -0,0 +1,18 @@
+=begin
+= dot.rd2rc
+default dot file for "rd2".
+=end
+
+# define relation between types of part and Filter to set $RD["filter"]
+# RD::INCLUDE_FILTER is used if type doesn't set.
+#   $RC["filter"]["((|type|))"] = ((|Filter|))
+
+$RC["filter"]["include"] = RD::INCLUDE_FILTER
+$RC["filter"]["rd"] = RD::RD_FILTER
+$RC["filter"]["eval"] = RD::EVAL_FILTER
+
+=begin
+== script info.
+ default dot file for "rd2".
+ $Id: dot.rd2rc,v 1.2 2000/06/09 15:48:42 toshirok Exp $
+=end

data/lib/rd/element.rb

@@ -0,0 +1,160 @@
+
+module RD
+
+  # abstruct class of node of document tree
+  class Element
+    include Enumerable
+    
+    attr_accessor :parent
+
+    def initialize
+      @parent = nil
+    end
+    
+    def tree
+      raise RuntimeError, "#{self} doesn't have a parent." unless @parent
+      @parent.tree
+    end
+
+    def inspect
+      c  = children.collect{|i| indent2(i.inspect)}.join("\n")
+      "<#{self.class.name}>" + (c.empty? ? "" : "\n") + c
+    end
+  end # Element
+
+  # element which don't have children.
+  module TerminalElement
+    def children
+      []
+    end
+
+    def each_element
+      yield(self)
+    end
+    alias each each_element
+  end
+
+  # element which have children.
+  module NonterminalElement
+    def initialize(*arg)
+      @temporary_document_structure = nil
+      super
+    end
+
+    def children
+      raise NotImplimentedError, "need #{self}#children."
+    end
+
+    def each_child
+      children.each do |i|
+	yield(i)
+      end
+    end
+
+    def each_element(&block)
+      yield(self)
+      children.each do |i|
+	i.each_element(&block)
+      end
+    end
+    alias each each_element
+    
+    def add_child(child)
+      add_child_under_document_struct(child, tree.document_struct)
+    end
+
+    def add_child_under_document_struct(child, document_struct)
+      if document_struct.is_valid?(self, child)
+	push_to_children(child)
+      else
+	raise ArgumentError,
+	  "mismatched document structure, #{self} <-/- #{child}."
+      end
+      return self
+    end
+
+    def add_children(children)
+      add_children_under_document_struct(children, tree.document_struct)
+    end
+
+    def add_children_under_document_struct(children, document_struct)
+      children.each do |i|
+	add_child_under_document_struct(i, document_struct)
+      end
+      return self
+    end
+
+    def add_children_without_document_struct(new_children)
+      new_children.each do |i|
+	push_to_children(i)
+      end
+      return self
+    end
+
+    def push_to_children(child)
+      children.push(child)
+      child.parent = self
+    end
+
+    attr_accessor :temporary_document_structure
+
+    def build(document_struct = tree.document_struct, &block)
+      under_temporary_document_structure(document_struct) do
+	self.instance_eval(&block)
+      end
+      self
+    end
+
+    def make_child(child_class, *args_of_new, &block)
+      child = child_class.new(*args_of_new)
+      if self.temporary_document_structure
+	self.add_child_under_document_struct(child,
+					     self.temporary_document_structure)
+	child.build(self.temporary_document_structure, &block) if block_given?
+      else
+	self.add_child(child)
+	child.build(&block) if block_given?
+      end
+      child
+    end
+    alias new make_child
+    private :new
+    # NonterminalElement#new, not NonterminalElement.new
+
+    def under_temporary_document_structure(document_struct)
+      begin
+	self.temporary_document_structure = document_struct
+	yield
+      ensure
+	self.temporary_document_structure = nil
+      end
+    end
+
+    def indent2(str)
+      buf = ''
+      str.each_line{|i| buf << "  " << i }
+      buf
+    end
+    private :indent2
+  end
+
+  # root node of document tree
+  class DocumentElement < Element
+    include NonterminalElement
+    attr_reader :blocks
+    
+    def initialize()
+      @blocks = []
+    end
+
+    def accept(visitor)
+      visitor.visit_DocumentElement(self)
+    end
+
+    alias each_block each_child
+    
+    def children
+      @blocks
+    end
+  end
+end