tdiary 3.2.2.20130518 → 3.2.2.20130527

data/vendor/rdtool-0.6.38/lib/rd/block-element.rb

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

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

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

@@ -1,46 +0,0 @@
-
-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/vendor/rdtool-0.6.38/lib/rd/dot.rd2rc

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

@@ -1,160 +0,0 @@
-
-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