rdtool 0.6.23

data/test/test-element.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+
+require 'rd/tree'
+require 'rd/element'
+require 'rd/rd-struct'
+
+include RD
+
+class TestElement < Test::Unit::TestCase
+
+  def setup
+    @tree = Tree.new_with_document_struct(DocumentStructure::RD)
+    @de = DocumentElement.new
+    @tree.root = @de
+    @tb = TextBlock.new
+    @de.add_child(@tb)
+
+    @err = TextBlock.new
+  end
+
+  def test_tree
+    assert_equal(@tree, @de.tree)
+    assert_equal(@tree, @tb.tree)
+    assert_raises(RuntimeError) do
+      @err.tree
+    end
+  end
+
+  def test_inspect
+    assert_equal("<RD::TextBlock>", TextBlock.new.inspect)
+
+    t = TextBlock.new
+    s = StringElement.new ""
+    t.add_child_under_document_struct(s, DocumentStructure::RD)
+    assert_equal("<RD::TextBlock>\n  <RD::StringElement>", t.inspect)
+
+    t = TextBlock.new
+    e = Emphasis.new
+    s = StringElement.new ""
+    s2 = StringElement.new "a"
+    e.add_child_under_document_struct(s, DocumentStructure::RD)
+    t.add_children_under_document_struct([e, s2], DocumentStructure::RD)
+    exp = "<RD::TextBlock>\n  <RD::Emphasis>\n    <RD::StringElement>\n  <RD::StringElement>"
+    assert_equal(exp, t.inspect)
+  end
+end

data/test/test-headline.rb

@@ -0,0 +1,80 @@
+require 'test/unit'
+
+require 'rd/block-element'
+require 'rd/inline-element'
+require 'rd/rd-struct'
+require 'rd/document-struct'
+
+include RD
+
+class TestHeadline < Test::Unit::TestCase
+  
+  def test_s_new
+    a = Headline.new(1)
+    assert_equal(1, a.level)
+  end
+
+  def test_add_child_under_document_struct
+    check_add_child(StringElement.new(""))
+    check_add_child(Emphasis.new)
+    check_add_child(Code.new)
+    check_add_child(Var.new)
+    check_add_child(Keyboard.new)
+    check_add_child(Index.new)
+    check_add_child(Verb.new(""))
+    check_add_child_fail(TextBlock.new)
+    check_add_child_fail(Verbatim.new)
+    check_add_child_fail(ItemList.new)
+    check_add_child_fail(ItemListItem.new)
+    check_add_child_fail(Reference.new(Reference::RDLabel.new("")))
+    check_add_child_fail(Footnote.new)
+  end
+
+  def check_add_child(child)
+    parent = Headline.new(1)
+    parent.add_child_under_document_struct(child, DocumentStructure::RD)
+    assert_equal([child], parent.children)
+    assert_equal(parent, child.parent)
+  end
+
+  def check_add_child_fail(child)
+    parent = Headline.new(1)
+    assert_raises(ArgumentError) do
+      parent.add_child_under_document_struct(child, DocumentStructure::RD)
+    end
+  end
+
+  def test_to_label
+    a = Headline.new(1)
+    c1 = StringElement.new "label"
+    a.add_child_under_document_struct(c1, DocumentStructure::RD)
+    assert_equal("label", a.to_label)
+
+    b = Headline.new(1)
+    c2 = Emphasis.new
+    c21 = StringElement.new "LABEL"
+    c2.add_child_under_document_struct(c21, DocumentStructure::RD)
+    b.add_children_under_document_struct([c1, c2], DocumentStructure::RD)
+    assert_equal("labelLABEL", b.to_label)
+
+    b = Headline.new(1)
+    c2 = Code.new
+    c21 = StringElement.new " LABEL "
+    c2.add_child_under_document_struct(c21, DocumentStructure::RD)
+    b.add_children_under_document_struct([c1, c2], DocumentStructure::RD)
+    assert_equal("labelLABEL", b.to_label)
+  end
+
+  def test_s_mark_to_level
+    assert_equal(1, Headline.mark_to_level("="))
+    assert_equal(2, Headline.mark_to_level("=="))
+    assert_equal(3, Headline.mark_to_level("==="))
+    assert_equal(4, Headline.mark_to_level("===="))
+    assert_equal(5, Headline.mark_to_level("+"))
+    assert_equal(6, Headline.mark_to_level("++"))
+
+    assert_raises(ArgumentError) do
+      Headline.mark_to_level("=====")
+    end
+  end
+end

data/test/test-inline-parser.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+
+require 'rd/rdinlineparser.tab'
+require 'rd/rd-struct'
+
+include RD
+
+class TestInlineParser < Test::Unit::TestCase
+  def setup
+    @block_parser = RDParser.new
+    @tree = tree = Tree.new_with_document_struct(DocumentStructure::RD)
+    @block_parser.instance_eval do
+      @tree = tree
+    end
+
+    @inline_parser = RDInlineParser.new(@block_parser)
+  end
+
+  def test_tree
+    assert_equal(@tree, @inline_parser.tree)
+  end
+
+  def test_make_reference_from_label
+    label = Reference::TemporaryLabel.new([StringElement.new("label")])
+    expect = Reference.new_from_label_under_document_struct(label,
+                        DocumentStructure::RD)
+    ref = @inline_parser.make_reference_from_label(label)
+    assert_equal(expect.label.element_label, ref.label.element_label)
+    assert_equal(expect.label.filename, ref.label.filename)
+  end
+
+  def test_prev_words_on_error
+    @inline_parser.instance_eval{@pre="foo bar baz"}
+    assert_equal("foo bar baz", @inline_parser.prev_words_on_error("foo"))
+    assert_equal("foo bar ", @inline_parser.prev_words_on_error("baz"))
+    assert_equal("foo bar baz", @inline_parser.prev_words_on_error(false))
+    assert_equal("foo bar baz", @inline_parser.prev_words_on_error("not exist"))
+    @inline_parser.instance_eval{@pre="foo bar\nfoo2 bar2"}
+    assert_equal("foo2 bar2", @inline_parser.prev_words_on_error("foo2"))
+    assert_equal("foo2 ", @inline_parser.prev_words_on_error("bar2"))
+
+    @inline_parser.instance_eval{@pre="foo?"}
+    assert_equal("foo", @inline_parser.prev_words_on_error("?"))
+  end
+end
+

data/test/test-list-item.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+
+require 'rd/list.rb'
+require 'rd/rd-struct'
+
+include RD
+
+class TestListItem < Test::Unit::TestCase
+  def setup
+    @a = ItemListItem.new
+    @c1 = TextBlock.new
+    @c2 = TextBlock.new
+    @a.add_children_under_document_struct([@c1, @c2], DocumentStructure::RD)
+
+    @b = ItemListItem.new
+    @d1 = TextBlock.new
+    @d11 = Emphasis.new
+    @d1.add_child_under_document_struct(@d11, DocumentStructure::RD)
+    @b.add_children_under_document_struct([@d1], DocumentStructure::RD)
+  end
+  
+  def test_each_block
+    exp = [@c1, @c2]
+    i = 0
+    @a.each_block do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+
+    exp = [@d1]
+    i = 0
+    @b.each_block do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+  end
+
+  def test_each_element
+    exp = [@a, @c1, @c2]
+    i = 0
+    @a.each_element do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+
+    exp = [@b, @d1, @d11]
+    i = 0
+    @b.each_element do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+  end
+
+end

data/test/test-list.rb

@@ -0,0 +1,53 @@
+require 'test/unit'
+
+require 'rd/list.rb'
+require 'rd/rd-struct'
+
+include RD
+
+class TestList < Test::Unit::TestCase
+  def setup
+    @a = ItemList.new
+    @c1 = ItemListItem.new
+    @c2 = ItemListItem.new
+    @a.add_children_under_document_struct([@c1, @c2], DocumentStructure::RD)
+
+    @b = ItemList.new
+    @d1 = ItemListItem.new
+    @d11 = TextBlock.new
+    @d1.add_child_under_document_struct(@d11, DocumentStructure::RD)
+    @b.add_children_under_document_struct([@d1], DocumentStructure::RD)
+  end
+  
+  def test_each_item
+    exp = [@c1, @c2]
+    i = 0
+    @a.each_item do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+
+    exp = [@d1]
+    i = 0
+    @b.each_item do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+  end
+
+  def test_each_element
+    exp = [@a, @c1, @c2]
+    i = 0
+    @a.each_element do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+
+    exp = [@b, @d1, @d11]
+    i = 0
+    @b.each_element do |b|
+      assert_equal(exp[i], b)
+      i += 1
+    end
+  end
+end

data/test/test-methodlist-item.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+
+require 'rd/methodlist'
+require 'rd/rd-struct'
+
+include RD
+
+class TestMethodListItem < Test::Unit::TestCase
+  def test_set_term
+    p = MethodListItem.new
+    c = MethodListItem::Term.new
+    p.set_term_under_document_struct(c, DocumentStructure::RD)
+    assert_equal(c, p.term)
+    assert_equal(p, c.parent)
+  end
+
+  def test_make_term
+    tr = Tree.new_with_document_struct(DocumentStructure::RD)
+    de = DocumentElement.new
+    tr.root = de
+    di, dt = nil
+    de.build do
+      new MethodList do
+        di = new MethodListItem do
+          dt = make_term
+        end
+      end
+    end
+    assert_equal("<RD::MethodListItem>\n  <RD::MethodListItem::Term>",
+                 di.inspect)
+    assert_equal(di.term, dt)
+  end
+
+  def test_inspect
+    mi = MethodListItem.new
+    mt = MethodListItem::Term.new
+    se = StringElement.new "string"
+    tb = TextBlock.new
+    mi.set_term_under_document_struct(mt, DocumentStructure::RD)
+    mi.add_child_under_document_struct(tb, DocumentStructure::RD)
+    assert_equal("<RD::MethodListItem>\n  <RD::MethodListItem::Term>\n" +
+                 "  <RD::TextBlock>", mi.inspect)
+    
+    mi_no_desc = MethodListItem.new
+    mt_no_desc = MethodListItem::Term.new
+    mi_no_desc.set_term_under_document_struct(mt_no_desc,
+                                              DocumentStructure::RD)
+    assert_equal("<RD::MethodListItem>\n  <RD::MethodListItem::Term>",
+                 mi_no_desc.inspect)
+
+    mi_no_term = MethodListItem.new
+    mi_no_term.add_child_under_document_struct(TextBlock.new,
+                                               DocumentStructure::RD)
+    assert_equal("<RD::MethodListItem>\n  <RD::TextBlock>",
+                 mi_no_term.inspect)
+    assert_equal("<RD::MethodListItem>", MethodListItem.new.inspect)
+  end
+
+end
+
+class TestMethodListItemTerm < Test::Unit::TestCase
+  def test_to_label
+    assert_equal("", MethodListItem::Term.new.to_label)
+    assert_equal("foo", MethodListItem::Term.new("foo").to_label)
+    assert_equal("foo", MethodListItem::Term.new("foo()").to_label)
+    assert_equal("foo", MethodListItem::Term.new("foo(arg)").to_label)
+    assert_equal("Foo#foo", MethodListItem::Term.new("Foo#foo(arg)").to_label)
+    assert_equal("Foo::foo", MethodListItem::Term.new("Foo::foo(arg)").to_label)    
+    assert_equal("foo", MethodListItem::Term.new("foo{|arg| ...}").to_label)
+    assert_equal("foo", MethodListItem::Term.new("foo(arg){|arg| ...}").to_label)
+    assert_equal("foo", MethodListItem::Term.new("foo  (arg)").to_label)
+  end
+end

data/test/test-nonterminal-element.rb

@@ -0,0 +1,170 @@
+require 'test/unit'
+
+require 'rd/tree'
+require 'rd/element'
+require 'rd/loose-struct'
+require 'rd/rd-struct'
+
+include RD
+
+class TestElement < Test::Unit::TestCase
+  
+  def test_add_child_under_document_struct
+    check_add_child(TextBlock.new, StringElement.new(""))
+    check_add_child(Headline.new(1), Emphasis.new)
+    check_add_child(ItemList.new, ItemListItem.new)
+    check_add_child(ItemListItem.new, TextBlock.new)
+    check_add_child(Emphasis.new, Code.new)
+
+    assert_raises(ArgumentError) do
+      Headline.new.add_child_under_document_struct(Reference.
+                                                 new(Reference::RDLabel.new),
+                                                 DocumentStructure::RD)
+      ItemListItem.new.add_child_under_document_struct(Headline.new,
+                                                 DocumentStructure::RD)
+    end
+  end
+
+  def check_add_child(p, c)
+    assert(p.add_child_under_document_struct(c, DocumentStructure::RD))
+  end
+
+  def test_add_children_under_document_struct
+    p = TextBlock.new
+    c1 = Code.new
+    c2 = Var.new
+    c3 = Reference.new(Reference::RDLabel.new(""))
+    p.add_children_under_document_struct([c1, c2, c3], DocumentStructure::RD)
+    assert_equal([c1, c2, c3], p.children)
+    [c1, c2, c3].each do |i|
+      assert_equal(p, i.parent)
+    end
+  end
+
+  def test_add_child_under_document_struct2
+    p = TextBlock.new
+    assert_equal([], p.children)
+
+    c1 = Emphasis.new
+    p.add_child_under_document_struct(c1, DocumentStructure::RD)
+    assert_equal([c1], p.children)
+    assert_equal(p, c1.parent)
+
+    c2 = StringElement.new("")
+    p.add_child_under_document_struct(c2, DocumentStructure::RD)
+    assert_equal([c1, c2], p.children)
+    assert_equal(p, c2.parent)
+
+    p = DocumentElement.new
+    c1 = Headline.new(1)
+    p.add_child_under_document_struct(c1, DocumentStructure::RD)
+    assert_equal([c1], p.children)
+    assert_equal(p, c1.parent)
+
+    c2 = ItemList.new
+    p.add_child_under_document_struct(c2, DocumentStructure::RD)
+    assert_equal([c1, c2], p.children)
+    assert_equal(p, c2.parent)
+  end
+
+  def test_add_children_without_document_struct
+    p = TextBlock.new
+    c1 = StringElement.new "string"
+    c2 = Emphasis.new
+    c3 = Headline.new(1)
+
+    assert_equal([], p.children)
+    p.add_children_without_document_struct([c1])
+    assert_equal([c1], p.children)
+    assert_equal(p, c1.parent)
+    p.add_children_without_document_struct([c1, c2])
+    assert_equal([c1, c1, c2], p.children)
+    assert_equal(p, c2.parent)
+    p.add_children_without_document_struct([c3])
+    assert_equal([c1, c1, c2, c3], p.children)
+    assert_equal(p, c2.parent)
+  end
+
+  def test_push_to_children
+    parent = TextBlock.new
+    child1 = StringElement.new "string"
+    parent.push_to_children(child1)
+    assert_equal([child1], parent.children)
+    assert_equal(parent, child1.parent)
+  end
+
+  def test_children
+    assert_equal([], DocumentElement.new.children)
+    assert_equal([], Headline.new(1).children)
+    assert_equal([], TextBlock.new.children)
+    assert_equal([], List.new.children)
+    assert_equal([], ListItem.new.children)
+    assert_equal([], DescListItem::Term.new.children)
+    assert_equal([], NonterminalInline.new.children)
+  end
+
+  def test_build
+    testcase = self
+    tr = Tree.new_with_document_struct(DocumentStructure::RD)
+    de = DocumentElement.new
+    tr.root = de
+    tb = TextBlock.new
+    de.add_child(tb)
+    res = tb.build do
+      testcase.assert_equal(tb, self)
+    end
+    assert_equal(tb, res)
+  end
+
+  def test_build_under_document_struct
+    testcase = self
+    tb = TextBlock.new
+    assert_nothing_raised do 
+      tb.build(DocumentStructure::LOOSE) do
+        testcase.assert_equal(DocumentStructure::LOOSE,
+                              tb.temporary_document_structure)
+        new Headline, 1
+      end
+    end
+    assert_equal(nil, tb.temporary_document_structure)
+
+    begin
+      tb.build(DocumentStructure::LOOSE) do
+        raise RuntimeError
+      end
+    rescue
+      assert_equal(nil, tb.temporary_document_structure)
+    end
+  end
+
+  def test_make_child
+    tr = Tree.new_with_document_struct(DocumentStructure::RD)
+    de = DocumentElement.new
+    tb = TextBlock.new
+    tr.root = de
+    de.add_child(tb)
+    
+    tb.make_child(StringElement, "string")
+    assert_equal("<RD::TextBlock>\n  <RD::StringElement>", tb.inspect)
+
+    assert_raises(ArgumentError) do
+      tb.make_child(TextBlock)
+    end
+
+    tr2 = Tree.new_with_document_struct(DocumentStructure::RD)
+    de2 = DocumentElement.new
+    tr2.root = de2
+
+    de2.build do
+      new TextBlock do
+        new StringElement, "string"
+        new Emphasis do
+          new StringElement, "emphais"
+        end
+      end
+    end
+    assert_equal("<RD::DocumentElement>\n  <RD::TextBlock>\n" +
+                 "    <RD::StringElement>\n    <RD::Emphasis>\n      " +
+                 "<RD::StringElement>", de2.inspect)
+  end
+end