rdtool 0.6.23

data/test/test-rdtree.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+
+require 'rd/rdfmt'
+require 'rd/element'
+
+include RD
+
+class TestRDTree < Test::Unit::TestCase
+  def test_s_new
+    tr = RDTree.new("=begin\nTEST\n=end\n")
+    assert_kind_of(DocumentElement, tr.root)
+
+    tr_not_parse = RDTree.new("=begin\nTEST\n=end\n", ["test/data"], false)
+    assert_nil(tr_not_parse.root)
+    assert_equal(["test/data"], tr_not_parse.include_paths)
+  end
+end

data/test/test-rdvisitor.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+
+require 'rd/rdvisitor'
+require 'rd/rd-struct'
+
+include RD
+class TestRDVisitor < Test::Unit::TestCase
+
+  def test_refer_external
+    tr_ext = Tree.new_with_document_struct(DocumentStructure::RD,
+                                            ["test/data"])
+    label_ext = Reference::RDLabel.new("label1", "label.rd")
+    tr_ext.root = DocumentElement.new
+    ref_ext = nil
+    tr_ext.root.build do
+      new TextBlock do
+        StringElement.new "label"
+        ref_ext = new Reference, label_ext
+      end
+    end
+    vis_ext = RDVisitor.new
+    vis_ext.prepare_labels(tr_ext)
+    label_not_exist = Reference::RDLabel.new("label3", "label.rd")
+
+    assert_equal("label:0", vis_ext.refer_external(ref_ext))
+    assert_equal( "label:0", vis_ext.refer_external(label_ext))
+    assert_equal(nil, vis_ext.refer_external(label_not_exist))
+  end
+end

data/test/test-reference-resolver.rb

@@ -0,0 +1,202 @@
+require 'test/unit'
+
+require 'temp-dir'
+
+require 'rd/reference-resolver'
+require 'rd/tree'
+require 'rd/rd-struct'
+
+include RD
+
+class TestReferenceResolver < Test::Unit::TestCase
+  def setup
+    @tr_head1 = Tree.new_with_document_struct(DocumentStructure::RD)
+    @de_head1 = DocumentElement.new
+    @tr_head1.root = @de_head1
+
+    hl_head1 = nil
+    se_head1 = nil
+    @de_head1.build do
+      hl_head1 = new Headline, 1 do
+        se_head1 = new StringElement, "label"
+      end
+    end
+    @hl_head1 = hl_head1
+    @se_head1 = se_head1
+
+    @tr_head2 = Tree.new_with_document_struct(DocumentStructure::RD)
+    @de_head2 = DocumentElement.new
+    @tr_head2.root = @de_head2
+    hl1_head2, hl2_head2 = nil
+
+    @de_head2.build do
+      hl1_head2 = new Headline, 1 do
+        new StringElement, "label1"
+      end
+      new TextBlock
+      hl2_head2 = new Headline, 2 do
+        new StringElement, "label2"
+      end
+    end
+    @hl1_head2 = hl1_head2
+    @hl2_head2 = hl2_head2
+
+    @tr_desc = Tree.new_with_document_struct(DocumentStructure::RD)
+    @de_desc = DocumentElement.new
+    @tr_desc.root = @de_desc
+    hl1_desc, dt1_desc = nil
+    @de_desc.build do
+      hl1_desc = new(Headline, 1) do
+        new StringElement, "label1"
+      end
+      new DescList do
+        new DescListItem do
+          dt1_desc = make_term do
+            new StringElement, "label2"
+          end
+        end
+      end
+    end
+    @hl1_desc = hl1_desc
+    @dt1_desc = dt1_desc
+
+    @tr_conf = Tree.new_with_document_struct(DocumentStructure::RD)
+    @de_conf = DocumentElement.new
+    @tr_conf.root = @de_conf
+    hl1_conf, hl2_conf = nil
+    @de_conf.build do
+      hl1_conf = new Headline, 1 do
+        new StringElement, "label"
+      end
+      hl2_conf = new Headline, 2 do
+        new StringElement, "label"
+      end
+    end
+    @hl1_conf = hl1_conf
+    @hl2_conf = hl2_conf
+    
+    @tr_no = Tree.new_with_document_struct(DocumentStructure::RD)
+    @de_no = DocumentElement.new
+    @tr_no.root = @de_no
+
+    @resolver = ReferenceResolver.new(@tr_head2)
+  end
+
+  def test_referent_of_label
+    @tr_desc.include_path = ["test/data"]
+    resolv = ReferenceResolver.new(@tr_desc, "label:")
+    label1 = Reference::RDLabel.new("label1")
+    assert_equal([nil, "label:0"], resolv.referent_of_label(label1))
+    label2 = Reference::RDLabel.new("label2")    
+    assert_equal([nil, "label:1"], resolv.referent_of_label(label2))
+    label_ext = Reference::RDLabel.new("label1", "label.rd")
+    assert_equal(["label", "label:0"], resolv.referent_of_label(label_ext))
+
+    label3 = Reference::RDLabel.new("label3")
+    assert_equal(nil, resolv.referent_of_label(label3))
+    label_ext3 = Reference::RDLabel.new("label3", "label.rd")
+    assert_equal(["label", nil], resolv.referent_of_label(label_ext3))
+  end
+
+  def test_refer_element
+    resolv = ReferenceResolver.new(@tr_head1)
+    assert_equal([@hl_head1], resolv.refer_element("label"))
+    assert_equal([], resolv.refer_element("label not found"))
+    resolv = ReferenceResolver.new(@tr_head2)
+    assert_equal([@hl1_head2], resolv.refer_element("label1"))
+    assert_equal([@hl2_head2], resolv.refer_element("label2"))
+    resolv = ReferenceResolver.new(@tr_desc)
+    assert_equal([@hl1_desc], resolv.refer_element("label1"))
+    assert_equal([@dt1_desc], resolv.refer_element("label2"))
+    resolv = ReferenceResolver.new(@tr_conf)
+    assert_equal([@hl1_conf, @hl2_conf], resolv.refer_element("label"))
+    resolv = ReferenceResolver.new(@tr_no)
+    assert_equal([], resolv.refer_element("label"))
+  end
+
+  def test_refer
+    resolv = ReferenceResolver.new(@tr_head1, "label:")
+    assert_equal("label:0", resolv.refer("label"))
+    assert_equal(nil, resolv.refer("label not found"))
+    resolv = ReferenceResolver.new(@tr_head2, "label:")
+    assert_equal("label:0", resolv.refer("label1"))
+    assert_equal("label:1", resolv.refer("label2"))
+    resolv = ReferenceResolver.new(@tr_desc, "label:")
+    assert_equal("label:0", resolv.refer("label1"))
+    assert_equal("label:1", resolv.refer("label2"))
+    resolv = ReferenceResolver.new(@tr_conf, "label:")
+    assert_equal("label:0", resolv.refer("label"))
+    resolv = ReferenceResolver.new(@tr_no, "label:")
+    assert_equal(nil, resolv.refer("label"))
+
+    resolv = ReferenceResolver.new(@tr_head1, "label:")
+    label = Reference::RDLabel.new("label")
+    assert_equal("label:0", resolv.refer(label))
+    ref = Reference.new(label)
+    assert_equal("label:0", resolv.refer(ref))
+  end
+
+  def test_refer_external_file
+    tr_ext = Tree.new_with_document_struct(DocumentStructure::RD,
+                                            ["test/data"])
+    label_ext = Reference::RDLabel.new("label1", "label.rd")
+    de = DocumentElement.new
+    tr_ext.root = de
+    ref = nil
+    de.build do
+      new TextBlock do
+        se = StringElement.new "label"
+        ref = new Reference, label_ext
+      end
+    end
+    label_not_exist = Reference::RDLabel.new("label3", "label.rd")
+    resolv = ReferenceResolver.new(tr_ext)
+    
+    assert_equal(["label", "label:0"], resolv.refer_external_file(ref))
+    assert_equal(["label", "label:0"], resolv.refer_external_file(label_ext))
+    assert_equal(["label", nil], resolv.refer_external_file(label_not_exist))
+  end
+
+  def test_get_label_num
+    assert_equal(0, @resolver.get_label_num(@hl1_head2))
+    assert_equal(1, @resolver.get_label_num(@hl2_head2))
+    assert_equal(nil, @resolver.get_label_num(@dt1_desc))
+  end
+
+  def test_get_anchor
+    resolv = ReferenceResolver.new(@tr_head2, "Label-")
+    assert_equal("Label-0", resolv.get_anchor(@hl1_head2))
+    assert_equal("Label-1", resolv.get_anchor(@hl2_head2))
+    assert_equal(nil, resolv.get_anchor(@dt1_desc))
+  end
+
+  def test_label2str
+    assert_equal("string", @resolver.label2str("string"))
+    assert_equal("label", @resolver.label2str(@hl_head1))
+    assert_equal("label2", @resolver.label2str(@dt1_desc))
+    label = Reference::RDLabel.new("label1")
+    assert_equal("label1", @resolver.label2str(label))
+    ref = Reference.new(label)
+    assert_equal("label1", @resolver.label2str(ref))    
+    assert_raises(ArgumentError) do
+      @resolver.label2str([])
+    end
+  end
+
+  def test_make_rbl_file
+    in_temp_dir do
+      begin
+        @resolver.make_rbl_file("label-head")
+        assert(File.exist?("label-head.rbl"))
+      ensure
+        remove_file("label-head.rbl")
+      end
+      begin
+        @resolver.make_rbl_file("label-head2.rd")
+        assert(File.exist?("label-head2.rbl"))
+      ensure
+        remove_file("label-head2.rbl")
+      end
+    end
+  end
+end

data/test/test-reference.rb

@@ -0,0 +1,132 @@
+require 'test/unit'
+
+require 'rd/inline-element'
+require 'rd/document-struct'
+require 'rd/rd-struct'
+require 'rd/loose-struct'
+require 'dummy'
+
+include RD
+
+DummyStruct.define_relationship(Reference, DummyElement)
+
+class TestReference < Test::Unit::TestCase
+  def test_initialize
+    d1 = DummyElement.new
+    l = Reference::TemporaryLabel.new([d1])
+    ref = Reference.new_from_label_under_document_struct(l, DummyStruct)
+    assert_kind_of(Reference::RDLabel, ref.label)
+    assert_equal([d1], ref.instance_eval("children"))
+
+    l2 = Reference::TemporaryLabel.new([d1], "filename")
+    ref = Reference.new_from_label_under_document_struct(l2, DummyStruct)
+    assert_kind_of(Reference::RDLabel, ref.label)
+    assert_equal([d1], ref.instance_eval("children"))
+    assert_equal("filename", ref.label.filename)
+
+    l = Reference::RDLabel.new("label")
+    ref = Reference.new(l)
+    assert_kind_of(Reference::RDLabel, ref.label)
+    assert_equal([], ref.instance_eval("children"))
+
+    url = Reference::URL.new("label")
+    ref2 = Reference.new_from_label_under_document_struct(url,
+                                                          DocumentStructure::RD)
+    assert_kind_of(Reference::URL, ref2.label)
+    assert_kind_of(StringElement, ref2.instance_eval("children")[0])
+    assert_equal("<URL:label>", ref2.instance_eval("children")[0].content)
+  end
+
+  def test_s_new_from_label_without_document_struct
+    se = StringElement.new "string"
+    label = Reference::TemporaryLabel.new([se])
+    ref = Reference.new_from_label_without_document_struct(label)
+    assert_kind_of(Reference::RDLabel, ref.label)
+    assert_equal([se], ref.instance_eval("children"))
+  end
+  
+  def test_to_label_RDLabel
+    l = Reference::TemporaryLabel.new([DummyElement.new])
+    ref = Reference.new(l)
+    assert_equal("label", ref.to_label)
+  end
+
+  def test_to_label_URL
+    l = Reference::URL.new "http://www.ruby-lang.org/"
+    ref = Reference.new l
+    assert_equal("", ref.to_label)
+  end
+
+  def test_result_of_apply_method_of
+    visitor = DummyVisitor.new
+    label = Reference::RDLabel.new("label")
+    reference = Reference.new(label)
+    result = ["apply_to_Reference_with_RDLabel",
+      [reference, []]]
+    assert_equal(result, reference.result_of_apply_method_of(visitor, []))
+
+    url = Reference::URL.new("url")
+    reference = Reference.new(url)
+    result = ["apply_to_Reference_with_URL",
+      [reference, []]]
+    assert_equal(result, reference.result_of_apply_method_of(visitor, []))
+  end
+
+  def test_add_child
+    d1 = DummyElement.new
+    d2 = DummyElement.new
+    l = Reference::TemporaryLabel.new([d1])
+    ref = Reference.new_from_label_under_document_struct(l, DummyStruct)
+    ref.add_child_under_document_struct(d2, DummyStruct)
+    assert_equal(3, ref.to_a.size)
+    assert_equal("label", ref.label.element_label)
+  end
+
+  def test_build
+    lb = Reference::RDLabel.new("label")
+    ref = Reference.new(lb).build(DocumentStructure::LOOSE) do
+      set_label(Reference::RDLabel.new("LABEL"))
+    end
+    assert_equal("LABEL", ref.to_label)
+  end
+end
+
+class TestRDLabel < Test::Unit::TestCase
+  def test_to_label
+    one = Reference::RDLabel.new("label")
+    assert_equal("label", one.to_label)
+    zero = Reference::RDLabel.new("")
+    assert_equal("", zero.to_label)
+    file = Reference::RDLabel.new("label", "filename")
+    assert_equal("label", file.to_label)
+  end
+
+  def test_result_of_apply_method_of
+    visitor = DummyVisitor.new
+    label = Reference::RDLabel.new("label")
+    reference = Reference.new(label)
+    result = ["apply_to_Reference_with_RDLabel",
+      [reference, []]]
+    assert_equal(result, label.result_of_apply_method_of(visitor, reference,
+                                                         []))
+  end
+end
+
+class TestURL < Test::Unit::TestCase
+  def test_to_label
+    nor = Reference::URL.new "http://www.ruby-lang.org/"
+    assert_equal("", nor.to_label)
+    empty = Reference::URL.new ""
+    assert_equal("", empty.to_label)
+  end
+
+  def test_result_of_apply_method_of
+    visitor = DummyVisitor.new
+    label = Reference::URL.new("label")
+    reference = Reference.new(label)
+    result = ["apply_to_Reference_with_URL",
+      [reference, []]]
+    assert_equal(result, label.result_of_apply_method_of(visitor, reference,
+                                                         []))
+  end
+end

data/test/test-search-file.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+
+require 'rd/search-file'
+
+include RD
+class TestSearchFile < Test::Unit::TestCase
+  include SearchFile
+
+  def test_search_file
+    include_path = ["test/data/sub", "test/data"]
+    suffixes = ["xhtml", "html"]
+
+    assert_equal("test/data/includee1.html",
+                 search_file("includee1", include_path, suffixes))
+    assert_equal("test/data/sub/includee2.html",
+                 search_file("includee2", include_path, suffixes))
+    assert_equal(nil,
+                 search_file("includee3", include_path, suffixes))
+    assert_equal("test/data/sub/includee4.html",
+                 search_file("includee4", include_path, suffixes))
+  end
+end

data/test/test-terminal-inline.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+
+require 'rd/inline-element'
+
+include RD
+
+class TestStringElement < Test::Unit::TestCase
+  def test_to_label
+    el = StringElement.new "label"
+    assert_equal("label", el.to_label)
+    ws = StringElement.new " label "
+    assert_equal(" label ", ws.to_label)
+    empty = StringElement.new ""
+    assert_equal("", empty.to_label)    
+  end
+
+  def test_content
+    el = StringElement.new ""
+    assert_equal("", el.content)
+    el.content = "label"
+    assert_equal("label", el.content)
+  end
+end
+
+class TestVerb < Test::Unit::TestCase
+  def test_to_label
+    el = Verb.new "label"
+    assert_equal("label", el.to_label)
+    ws = Verb.new " label "
+    assert_equal("label", ws.to_label)
+    empty = Verb.new ""
+    assert_equal("", empty.to_label)    
+  end
+
+  def test_content
+    el = Verb.new ""
+    assert_equal("", el.content)
+    el.content = "label"
+    assert_equal("label", el.content)
+  end
+end