rdoc 2.5.11 → 3.0

data/test/test_rdoc_markup_to_html.rb

@@ -31,49 +31,73 @@ class TestRDocMarkupToHtml < RDoc::Markup::FormatterTestCase
   end
 
   def accept_heading
-    assert_equal "<h5>Hello</h5>\n", @to.res.join
+    assert_equal "\n<h5>Hello</h5>\n", @to.res.join
+  end
+
+  def accept_heading_1
+    assert_equal "\n<h1>Hello</h1>\n", @to.res.join
+  end
+
+  def accept_heading_2
+    assert_equal "\n<h2>Hello</h2>\n", @to.res.join
+  end
+
+  def accept_heading_3
+    assert_equal "\n<h3>Hello</h3>\n", @to.res.join
+  end
+
+  def accept_heading_4
+    assert_equal "\n<h4>Hello</h4>\n", @to.res.join
+  end
+
+  def accept_heading_b
+    assert_equal "\n<h1><b>Hello</b></h1>\n", @to.res.join
+  end
+
+  def accept_heading_suppressed_crossref
+    assert_equal "\n<h1>Hello</h1>\n", @to.res.join
   end
 
   def accept_list_end_bullet
     assert_equal [], @to.list
     assert_equal [], @to.in_list_entry
 
-    assert_equal "<ul>\n</ul>\n", @to.res.join
+    assert_equal "<ul></ul>\n", @to.res.join
   end
 
   def accept_list_end_label
     assert_equal [], @to.list
     assert_equal [], @to.in_list_entry
 
-    assert_equal "<dl>\n</dl>\n", @to.res.join
+    assert_equal "<dl></dl>\n", @to.res.join
   end
 
   def accept_list_end_lalpha
     assert_equal [], @to.list
     assert_equal [], @to.in_list_entry
 
-    assert_equal "<ol style=\"display: lower-alpha\">\n</ol>\n", @to.res.join
+    assert_equal "<ol style=\"display: lower-alpha\"></ol>\n", @to.res.join
   end
 
   def accept_list_end_number
     assert_equal [], @to.list
     assert_equal [], @to.in_list_entry
 
-    assert_equal "<ol>\n</ol>\n", @to.res.join
+    assert_equal "<ol></ol>\n", @to.res.join
   end
 
   def accept_list_end_note
     assert_equal [], @to.list
     assert_equal [], @to.in_list_entry
 
-    assert_equal "<table>\n</table>\n", @to.res.join
+    assert_equal "<table class=\"rdoc-list\"></table>\n", @to.res.join
   end
 
   def accept_list_end_ualpha
     assert_equal [], @to.list
     assert_equal [], @to.in_list_entry
 
-    assert_equal "<ol style=\"display: upper-alpha\">\n</ol>\n", @to.res.join
+    assert_equal "<ol style=\"display: upper-alpha\"></ol>\n", @to.res.join
   end
 
   def accept_list_item_end_bullet
@@ -101,73 +125,105 @@ class TestRDocMarkupToHtml < RDoc::Markup::FormatterTestCase
   end
 
   def accept_list_item_start_bullet
-    assert_equal "<ul>\n<li>", @to.res.join
+    assert_equal "<ul><li>", @to.res.join
   end
 
   def accept_list_item_start_label
-    assert_equal "<dl>\n<dt>cat</dt><dd>", @to.res.join
+    assert_equal "<dl><dt>cat</dt>\n<dd>", @to.res.join
   end
 
   def accept_list_item_start_lalpha
-    assert_equal "<ol style=\"display: lower-alpha\">\n<li>", @to.res.join
+    assert_equal "<ol style=\"display: lower-alpha\"><li>", @to.res.join
   end
 
   def accept_list_item_start_note
-    assert_equal "<table>\n<tr><td valign=\"top\">cat</td><td>", @to.res.join
+    assert_equal "<table class=\"rdoc-list\"><tr><td class=\"rdoc-term\"><p>cat</p></td>\n<td>",
+                 @to.res.join
+  end
+
+  def accept_list_item_start_note_2
+    expected = <<-EXPECTED
+<table class="rdoc-list"><tr><td class="rdoc-term"><p><tt>teletype</tt></p></td>
+<td>
+<p>teletype description</p>
+</td></tr></table>
+    EXPECTED
+
+    assert_equal expected, @to.res.join
   end
 
   def accept_list_item_start_number
-    assert_equal "<ol>\n<li>", @to.res.join
+    assert_equal "<ol><li>", @to.res.join
   end
 
   def accept_list_item_start_ualpha
-    assert_equal "<ol style=\"display: upper-alpha\">\n<li>", @to.res.join
+    assert_equal "<ol style=\"display: upper-alpha\"><li>", @to.res.join
   end
 
   def accept_list_start_bullet
     assert_equal [:BULLET], @to.list
     assert_equal [false], @to.in_list_entry
 
-    assert_equal "<ul>\n", @to.res.join
+    assert_equal "<ul>", @to.res.join
   end
 
   def accept_list_start_label
     assert_equal [:LABEL], @to.list
     assert_equal [false], @to.in_list_entry
 
-    assert_equal "<dl>\n", @to.res.join
+    assert_equal "<dl>", @to.res.join
   end
 
   def accept_list_start_lalpha
     assert_equal [:LALPHA], @to.list
     assert_equal [false], @to.in_list_entry
 
-    assert_equal "<ol style=\"display: lower-alpha\">\n", @to.res.join
+    assert_equal "<ol style=\"display: lower-alpha\">", @to.res.join
   end
 
   def accept_list_start_note
     assert_equal [:NOTE], @to.list
     assert_equal [false], @to.in_list_entry
 
-    assert_equal "<table>\n", @to.res.join
+    assert_equal "<table class=\"rdoc-list\">", @to.res.join
   end
 
   def accept_list_start_number
     assert_equal [:NUMBER], @to.list
     assert_equal [false], @to.in_list_entry
 
-    assert_equal "<ol>\n", @to.res.join
+    assert_equal "<ol>", @to.res.join
   end
 
   def accept_list_start_ualpha
     assert_equal [:UALPHA], @to.list
     assert_equal [false], @to.in_list_entry
 
-    assert_equal "<ol style=\"display: upper-alpha\">\n", @to.res.join
+    assert_equal "<ol style=\"display: upper-alpha\">", @to.res.join
   end
 
   def accept_paragraph
-    assert_equal "<p>\nhi\n</p>\n", @to.res.join
+    assert_equal "\n<p>hi</p>\n", @to.res.join
+  end
+
+  def accept_paragraph_b
+    assert_equal "\n<p>reg <b>bold words</b> reg</p>\n", @to.res.join
+  end
+
+  def accept_paragraph_i
+    assert_equal "\n<p>reg <em>italic words</em> reg</p>\n", @to.res.join
+  end
+
+  def accept_paragraph_plus
+    assert_equal "\n<p>reg <tt>teletype</tt> reg</p>\n", @to.res.join
+  end
+
+  def accept_paragraph_star
+    assert_equal "\n<p>reg <b>bold</b> reg</p>\n", @to.res.join
+  end
+
+  def accept_paragraph_underscore
+    assert_equal "\n<p>reg <em>italic</em> reg</p>\n", @to.res.join
   end
 
   def accept_raw
@@ -183,11 +239,11 @@ class TestRDocMarkupToHtml < RDoc::Markup::FormatterTestCase
   end
 
   def accept_rule
-    assert_equal '<hr style="height: 4px"></hr>', @to.res.join
+    assert_equal "<hr style=\"height: 4px\">\n", @to.res.join
   end
 
   def accept_verbatim
-    assert_equal "<pre>\n  hi\n  world\n</pre>\n", @to.res.join
+    assert_equal "\n<pre>hi\n  world</pre>\n", @to.res.join
   end
 
   def end_accepting
@@ -200,54 +256,70 @@ class TestRDocMarkupToHtml < RDoc::Markup::FormatterTestCase
     assert_equal [], @to.list
   end
 
-  def test_list_verbatim
-    str = "* one\n    verb1\n    verb2\n* two\n"
-
+  def list_nested
     expected = <<-EXPECTED
-<ul>
-<li><p>
-one
-</p>
-<pre>
-  verb1
-  verb2
-</pre>
-</li>
-<li><p>
-two
-</p>
-</li>
-</ul>
+<ul><li>
+<p>l1</p>
+<ul><li>
+<p>l1.1</p>
+</li></ul>
+</li><li>
+<p>l2</p>
+</li></ul>
     EXPECTED
 
-    assert_equal expected, @m.convert(str, @to)
+    assert_equal expected, @to.res.join
   end
 
-  def test_tt_formatting
-    assert_equal "<p>\n<tt>--</tt> &#8212; <tt>cats'</tt> cats&#8217;\n</p>\n",
-                 util_format("<tt>--</tt> -- <tt>cats'</tt> cats'")
+  def list_verbatim
+    expected = <<-EXPECTED
+<ul><li>
+<p>list stuff</p>
+
+<pre>* list
+  with
+
+  second
+
+  1. indented
+  2. numbered
 
-    assert_equal "<p>\n<b>&#8212;</b>\n</p>\n", util_format("<b>--</b>")
+  third
+
+* second</pre>
+</li></ul>
+    EXPECTED
+
+    assert_equal expected, @to.end_accepting
   end
 
-  def test_convert_string_fancy
-    #
-    # The HTML typesetting is broken in a number of ways, but I have fixed
-    # the most glaring issues for single and double quotes.  Note that
-    # "strange" symbols (periods or dashes) need to be at the end of the
-    # test case strings in order to suppress cross-references.
-    #
-    assert_equal "<p>\n&#8220;cats&#8221;.\n</p>\n", util_format("\"cats\".")
-    assert_equal "<p>\n&#8216;cats&#8217;.\n</p>\n", util_format("\'cats\'.")
-    assert_equal "<p>\ncat&#8217;s-\n</p>\n", util_format("cat\'s-")
+  def test_convert_string
+    assert_equal '&lt;&gt;', @to.convert_string('<>')
+  end
+
+  def test_list_verbatim_2
+    str = "* one\n    verb1\n    verb2\n* two\n"
+
+    expected = <<-EXPECTED
+<ul><li>
+<p>one</p>
+
+<pre>verb1
+verb2</pre>
+</li><li>
+<p>two</p>
+</li></ul>
+    EXPECTED
+
+    assert_equal expected, @m.convert(str, @to)
   end
 
-  def util_paragraph(text)
-    RDoc::Markup::Paragraph.new text
+  def test_to_html
+    assert_equal "\n<p><tt>--</tt></p>\n", util_format("<tt>--</tt>")
   end
 
-  def util_format(text)
-    paragraph = util_paragraph text
+  def util_format text
+    paragraph = RDoc::Markup::Paragraph.new text
 
     @to.start_accepting
     @to.accept_paragraph paragraph

data/test/test_rdoc_markup_to_html_crossref.rb

@@ -14,12 +14,11 @@ class TestRDocMarkupToHtmlCrossref < XrefTestCase
   end
 
   def assert_ref(path, ref)
-    assert_equal "<p>\n<a href=\"#{path}\">#{ref}</a>\n</p>\n",
-                 @xref.convert(ref)
+    assert_equal "\n<p><a href=\"#{path}\">#{ref}</a></p>\n", @xref.convert(ref)
   end
 
   def refute_ref(body, ref)
-    assert_equal "<p>\n#{body}\n</p>\n", @xref.convert(ref)
+    assert_equal "\n<p>#{body}</p>\n", @xref.convert(ref)
   end
 
   def test_handle_special_CROSSREF_C2
@@ -108,16 +107,16 @@ class TestRDocMarkupToHtmlCrossref < XrefTestCase
     assert_ref 'C1.html#method-c-m', '::m'
 
     assert_ref 'C1.html#method-i-m', 'C1#m'
-    assert_ref 'C1.html#method-i-m', 'C1.m'
+    assert_ref 'C1.html#method-c-m', 'C1.m'
     assert_ref 'C1.html#method-c-m', 'C1::m'
 
     assert_ref 'C1.html#method-i-m', 'C1#m'
     assert_ref 'C1.html#method-i-m', 'C1#m()'
     assert_ref 'C1.html#method-i-m', 'C1#m(*)'
 
-    assert_ref 'C1.html#method-i-m', 'C1.m'
-    assert_ref 'C1.html#method-i-m', 'C1.m()'
-    assert_ref 'C1.html#method-i-m', 'C1.m(*)'
+    assert_ref 'C1.html#method-c-m', 'C1.m'
+    assert_ref 'C1.html#method-c-m', 'C1.m()'
+    assert_ref 'C1.html#method-c-m', 'C1.m(*)'
 
     assert_ref 'C1.html#method-c-m', 'C1::m'
     assert_ref 'C1.html#method-c-m', 'C1::m()'
@@ -127,7 +126,8 @@ class TestRDocMarkupToHtmlCrossref < XrefTestCase
 
     assert_ref 'C2/C3.html#method-i-m', 'C2::C3.m'
 
-    assert_ref 'C2/C3/H1.html#method-i-m%3F', 'C2::C3::H1#m?'
+    # TODO stop escaping - HTML5 allows anything but space
+    assert_ref 'C2/C3/H1.html#method-i-m-3F', 'C2::C3::H1#m?'
 
     assert_ref 'C2/C3.html#method-i-m', '::C2::C3#m'
     assert_ref 'C2/C3.html#method-i-m', '::C2::C3#m()'
@@ -156,12 +156,12 @@ class TestRDocMarkupToHtmlCrossref < XrefTestCase
   def test_handle_special_CROSSREF_show_hash_false
     @xref.show_hash = false
 
-    assert_equal "<p>\n<a href=\"C1.html#method-i-m\">m</a>\n</p>\n",
+    assert_equal "\n<p><a href=\"C1.html#method-i-m\">m</a></p>\n",
                  @xref.convert('#m')
   end
 
   def test_handle_special_CROSSREF_special
-    assert_equal "<p>\n<a href=\"C2/C3.html\">C2::C3</a>;method(*)\n</p>\n",
+    assert_equal "\n<p><a href=\"C2/C3.html\">C2::C3</a>;method(*)</p>\n",
                  @xref.convert('C2::C3;method(*)')
   end
 

data/test/test_rdoc_markup_to_rdoc.rb

@@ -1,11 +1,12 @@
 require 'rubygems'
-require 'rdoc/markup/formatter_test_case'
+require 'rdoc/markup/text_formatter_test_case'
 require 'rdoc/markup/to_rdoc'
 require 'minitest/autorun'
 
-class TestRDocMarkupToRdoc < RDoc::Markup::FormatterTestCase
+class TestRDocMarkupToRDoc < RDoc::Markup::TextFormatterTestCase
 
   add_visitor_tests
+  add_text_tests
 
   def setup
     super
@@ -191,8 +192,8 @@ class TestRDocMarkupToRdoc < RDoc::Markup::FormatterTestCase
     assert_equal "#{'-' * 78}\n", @to.res.join
   end
 
-  def accept_verbatim # FormatterTestCase doesn't set indent for ToAnsi
-    assert_equal "  hi\n  world\n\n", @to.res.join
+  def accept_verbatim
+    assert_equal "  hi\n    world\n\n", @to.res.join
   end
 
   def end_accepting
@@ -207,214 +208,102 @@ class TestRDocMarkupToRdoc < RDoc::Markup::FormatterTestCase
     assert_empty @to.list_width
   end
 
-  def test_accept_heading_1
-    @to.start_accepting
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
+  def accept_heading_1
     assert_equal "= Hello\n", @to.end_accepting
   end
 
-  def test_accept_heading_2
-    @to.start_accepting
-    @to.accept_heading @RM::Heading.new(2, 'Hello')
-
+  def accept_heading_2
     assert_equal "== Hello\n", @to.end_accepting
   end
 
-  def test_accept_heading_3
-    @to.start_accepting
-    @to.accept_heading @RM::Heading.new(3, 'Hello')
-
+  def accept_heading_3
     assert_equal "=== Hello\n", @to.end_accepting
   end
 
-  def test_accept_heading_4
-    @to.start_accepting
-    @to.accept_heading @RM::Heading.new(4, 'Hello')
-
+  def accept_heading_4
     assert_equal "==== Hello\n", @to.end_accepting
   end
 
-  def test_accept_heading_indent
-    @to.start_accepting
-    @to.indent = 3
-    @to.accept_heading @RM::Heading.new(1, 'Hello')
-
+  def accept_heading_indent
     assert_equal "   = Hello\n", @to.end_accepting
   end
 
-  def test_accept_heading_b
-    @to.start_accepting
-    @to.indent = 3
-    @to.accept_heading @RM::Heading.new(1, '*Hello*')
-
-    assert_equal "   = <b>Hello</b>\n", @to.end_accepting
+  def accept_heading_b
+    assert_equal "= <b>Hello</b>\n", @to.end_accepting
   end
 
-  def test_accept_list_item_start_note_2
-    list = @RM::List.new(:NOTE,
-             @RM::ListItem.new('<tt>teletype</tt>',
-                               @RM::Paragraph.new('teletype description')))
-
-    @to.start_accepting
-
-    list.accept @to
-
-    expected = "<tt>teletype</tt>:\n  teletype description\n\n"
-
-    assert_equal expected, @to.end_accepting
+  def accept_heading_suppressed_crossref
+    assert_equal "= Hello\n", @to.end_accepting
   end
 
-  def test_accept_paragraph_b
-    @to.start_accepting
-    @to.accept_paragraph @RM::Paragraph.new('reg <b>bold words</b> reg')
-
-    expected = "reg <b>bold words</b> reg\n"
-
-    assert_equal expected, @to.end_accepting
+  def accept_list_item_start_note_2
+    assert_equal "<tt>teletype</tt>:\n  teletype description\n\n", @to.res.join
   end
 
-  def test_accept_paragraph_i
-    @to.start_accepting
-    @to.accept_paragraph @RM::Paragraph.new('reg <em>italic words</em> reg')
-
-    expected = "reg <em>italic words</em> reg\n"
-
-    assert_equal expected, @to.end_accepting
+  def accept_paragraph_b
+    assert_equal "reg <b>bold words</b> reg\n", @to.end_accepting
   end
 
-  def test_accept_paragraph_indent
-    @to.start_accepting
-    @to.indent = 3
-    @to.accept_paragraph @RM::Paragraph.new('words ' * 30)
+  def accept_paragraph_i
+    assert_equal "reg <em>italic words</em> reg\n", @to.end_accepting
+  end
 
+  def accept_paragraph_indent
     expected = <<-EXPECTED
    words words words words words words words words words words words words
    words words words words words words words words words words words words
-   words words words words words words 
+   words words words words words words
     EXPECTED
 
     assert_equal expected, @to.end_accepting
   end
 
-  def test_accept_paragraph_plus
-    @to.start_accepting
-    @to.accept_paragraph @RM::Paragraph.new('regular +teletype+ regular')
-
-    expected = "regular <tt>teletype</tt> regular\n"
-
-    assert_equal expected, @to.end_accepting
+  def accept_paragraph_plus
+    assert_equal "reg <tt>teletype</tt> reg\n", @to.end_accepting
   end
 
-  def test_accept_paragraph_star
-    @to.start_accepting
-    @to.accept_paragraph @RM::Paragraph.new('regular *bold* regular')
-
-    expected = "regular <b>bold</b> regular\n"
-
-    assert_equal expected, @to.end_accepting
+  def accept_paragraph_star
+    assert_equal "reg <b>bold</b> reg\n", @to.end_accepting
   end
 
-  def test_accept_paragraph_underscore
-    @to.start_accepting
-    @to.accept_paragraph @RM::Paragraph.new('regular _italic_ regular')
-
-    expected = "regular <em>italic</em> regular\n"
-
-    assert_equal expected, @to.end_accepting
+  def accept_paragraph_underscore
+    assert_equal "reg <em>italic</em> reg\n", @to.end_accepting
   end
 
-  def test_accept_paragraph_wrap
-    @to.start_accepting
-    @to.accept_paragraph @RM::Paragraph.new('words ' * 30)
-
+  def accept_paragraph_wrap
     expected = <<-EXPECTED
 words words words words words words words words words words words words words
 words words words words words words words words words words words words words
-words words words words 
+words words words words
     EXPECTED
 
     assert_equal expected, @to.end_accepting
   end
 
-  def test_accept_rule_indent
-    @to.start_accepting
-    @to.indent = 3
-
-    @to.accept_rule @RM::Rule.new(1)
-
+  def accept_rule_indent
     assert_equal "   #{'-' * 75}\n", @to.end_accepting
   end
 
-  def test_accept_verbatim_indent
-    @to.start_accepting
-
-    @to.indent = 2
-
-    @to.accept_verbatim @RM::Verbatim.new('    ', 'hi', "\n",
-                                          '     ', 'world', "\n")
-
+  def accept_verbatim_indent
     assert_equal "    hi\n     world\n\n", @to.end_accepting
   end
 
-  def test_accept_verbatim_big_indent
-    @to.start_accepting
-
-    @to.indent = 2
-
-    @to.accept_verbatim @RM::Verbatim.new('    ', 'hi', "\n",
-                                          '    ', 'world', "\n")
-
+  def accept_verbatim_big_indent
     assert_equal "    hi\n    world\n\n", @to.end_accepting
   end
 
-  def test_attributes
-    assert_equal 'Dog', @to.attributes("\\Dog")
-  end
-
-  def test_list_nested
-    doc = @RM::Document.new(
-            @RM::List.new(:BULLET,
-              @RM::ListItem.new(nil,
-                @RM::Paragraph.new('l1'),
-                @RM::List.new(:BULLET,
-                  @RM::ListItem.new(nil,
-                    @RM::Paragraph.new('l1.1')))),
-              @RM::ListItem.new(nil,
-                @RM::Paragraph.new('l2'))))
-
-    output = doc.accept @to
-
+  def list_nested
     expected = <<-EXPECTED
 * l1
   * l1.1
 * l2
     EXPECTED
 
-    assert_equal expected, output
-  end
-
-  def test_list_verbatim # HACK overblown
-    doc = @RM::Document.new(
-            @RM::List.new(:BULLET,
-              @RM::ListItem.new(nil,
-                @RM::Paragraph.new('list', 'stuff'),
-                @RM::BlankLine.new(),
-                @RM::Verbatim.new('   ', '*', ' ', 'list', "\n",
-                                  '     ', 'with', "\n",
-                                  "\n",
-                                  '     ', 'second', "\n",
-                                  "\n",
-                                  '     ', '1.', ' ', 'indented', "\n",
-                                  '     ', '2.', ' ', 'numbered', "\n",
-                                  "\n",
-                                  '     ', 'third', "\n",
-                                  "\n",
-                                  '   ', '*', ' ', 'second', "\n"))))
-
-    output = doc.accept @to
+    assert_equal expected, @to.end_accepting
+  end
 
-    expected = <<-EXPECTED
+  def list_verbatim
+    expected = <<-EXPECTED # HACK overblown
 * list stuff
 
     * list
@@ -431,7 +320,7 @@ words words words words
 
     EXPECTED
 
-    assert_equal expected, output
+    assert_equal expected, @to.end_accepting
   end
 
 end