rdoc 4.0.0.preview2.1 → 4.0.0.rc.2

data/test/test_rdoc_options.rb

@@ -549,6 +549,17 @@ rdoc_include:
     FileUtils.rm_rf tmpdir
   end
 
+  def test_parse_extension_alias
+    out, err = capture_io do
+      @options.parse %w[--extension foobar=rdoc]
+    end
+
+    assert_includes RDoc::Parser.parsers, [/\.foobar$/, RDoc::Parser::Simple]
+
+    assert_empty out
+    assert_empty err
+  end
+
   def test_setup_generator
     test_generator = Class.new do
       def self.setup_options op

data/test/test_rdoc_parser.rb

@@ -33,8 +33,18 @@ class TestRDocParser < RDoc::TestCase
   end
 
   def test_class_binary_large_japanese_rdoc
-    file_name = File.expand_path '../test.ja.large.rdoc', __FILE__
-    assert !@RP.binary?(file_name)
+    skip "Encoding not implemented" unless Object.const_defined? :Encoding
+
+    capture_io do
+      begin
+        extenc, Encoding.default_external =
+          Encoding.default_external, Encoding::US_ASCII
+        file_name = File.expand_path '../test.ja.largedoc', __FILE__
+        assert !@RP.binary?(file_name)
+      ensure
+        Encoding.default_external = extenc
+      end
+    end
   end
 
   def test_class_binary_japanese_rdoc
@@ -51,7 +61,7 @@ class TestRDocParser < RDoc::TestCase
 
     assert_equal @RP::Simple, @RP.can_parse(readme_file_name)
 
-    assert_nil @RP.can_parse(@binary_dat)
+    assert_equal @RP::Simple, @RP.can_parse(@binary_dat)
 
     jtest_file_name = File.expand_path '../test.ja.txt', __FILE__
     assert_equal @RP::Simple, @RP.can_parse(jtest_file_name)
@@ -61,16 +71,39 @@ class TestRDocParser < RDoc::TestCase
 
     readme_file_name = File.expand_path '../README', __FILE__
     assert_equal @RP::Simple, @RP.can_parse(readme_file_name)
+
+    jtest_largerdoc_file_name = File.expand_path '../test.ja.largedoc', __FILE__
+    assert_equal @RP::Simple, @RP.can_parse(jtest_largerdoc_file_name)
+
+    @RP.alias_extension 'rdoc', 'largedoc'
+    assert_equal @RP::Simple, @RP.can_parse(jtest_largerdoc_file_name)
+  end
+
+  def test_class_for_executable
+    temp_dir do
+      content = "#!/usr/bin/env ruby -w\n"
+      open 'app', 'w' do |io| io.write content end
+      app = @store.add_file 'app'
+
+      parser = @RP.for app, 'app', content, @options, :stats
+
+      assert_kind_of RDoc::Parser::Ruby, parser
+
+      assert_equal 'app', parser.file_name
+    end
   end
 
-  def test_class_can_parse_forbidden
+  def test_class_for_forbidden
     skip 'chmod not supported' if Gem.win_platform?
 
     Tempfile.open 'forbidden' do |io|
       begin
         File.chmod 0000, io.path
+        forbidden = @store.add_file io.path
+
+        parser = @RP.for forbidden, 'forbidden', '', @options, :stats
 
-        assert_nil @RP.can_parse io.path
+        assert_nil parser
       ensure
         File.chmod 0400, io.path
       end
@@ -113,6 +146,18 @@ class TestRDocParser < RDoc::TestCase
     File.unlink readme_ext
   end
 
+  def test_check_modeline_coding
+    readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
+
+    open readme_ext, 'w' do |io|
+      io.puts "# -*- coding: utf-8 -*-"
+    end
+
+    assert_nil @RP.check_modeline readme_ext
+  ensure
+    File.unlink readme_ext
+  end
+
   def test_check_modeline_with_other
     readme_ext = File.join Dir.tmpdir, "README.EXT.#{$$}"
 

data/test/test_rdoc_parser_c.rb

@@ -64,17 +64,40 @@ class TestRDocParserC < RDoc::TestCase
   def test_class_can_parse
     c_parser = RDoc::Parser::C
 
-    assert_equal c_parser, c_parser.can_parse('file.C')
-    assert_equal c_parser, c_parser.can_parse('file.CC')
-    assert_equal c_parser, c_parser.can_parse('file.H')
-    assert_equal c_parser, c_parser.can_parse('file.HH')
-    assert_equal c_parser, c_parser.can_parse('file.c')
-    assert_equal c_parser, c_parser.can_parse('file.cc')
-    assert_equal c_parser, c_parser.can_parse('file.cpp')
-    assert_equal c_parser, c_parser.can_parse('file.cxx')
-    assert_equal c_parser, c_parser.can_parse('file.h')
-    assert_equal c_parser, c_parser.can_parse('file.hh')
-    assert_equal c_parser, c_parser.can_parse('file.y')
+    temp_dir do
+      FileUtils.touch 'file.C'
+      assert_equal c_parser, c_parser.can_parse('file.C')
+
+      FileUtils.touch 'file.CC'
+      assert_equal c_parser, c_parser.can_parse('file.CC')
+
+      FileUtils.touch 'file.H'
+      assert_equal c_parser, c_parser.can_parse('file.H')
+
+      FileUtils.touch 'file.HH'
+      assert_equal c_parser, c_parser.can_parse('file.HH')
+
+      FileUtils.touch 'file.c'
+      assert_equal c_parser, c_parser.can_parse('file.c')
+
+      FileUtils.touch 'file.cc'
+      assert_equal c_parser, c_parser.can_parse('file.cc')
+
+      FileUtils.touch 'file.cpp'
+      assert_equal c_parser, c_parser.can_parse('file.cpp')
+
+      FileUtils.touch 'file.cxx'
+      assert_equal c_parser, c_parser.can_parse('file.cxx')
+
+      FileUtils.touch 'file.h'
+      assert_equal c_parser, c_parser.can_parse('file.h')
+
+      FileUtils.touch 'file.hh'
+      assert_equal c_parser, c_parser.can_parse('file.hh')
+
+      FileUtils.touch 'file.y'
+      assert_equal c_parser, c_parser.can_parse('file.y')
+    end
   end
 
   def test_initialize

data/test/test_rdoc_parser_changelog.rb

@@ -25,11 +25,15 @@ class TestRDocParserChangeLog < RDoc::TestCase
   def test_class_can_parse
     parser = RDoc::Parser::ChangeLog
 
-    assert_equal parser, parser.can_parse('ChangeLog')
+    temp_dir do
+      FileUtils.touch 'ChangeLog'
+      assert_equal parser, parser.can_parse('ChangeLog')
 
-    assert_equal parser, parser.can_parse(@tempfile.path)
+      assert_equal parser, parser.can_parse(@tempfile.path)
 
-    assert_equal RDoc::Parser::Ruby, parser.can_parse('ChangeLog.rb')
+      FileUtils.touch 'ChangeLog.rb'
+      assert_equal RDoc::Parser::Ruby, parser.can_parse('ChangeLog.rb')
+    end
   end
 
   def test_continue_entry_body
@@ -178,7 +182,9 @@ class TestRDocParserChangeLog < RDoc::TestCase
       [ 'Tue Dec  4 08:32:10 2012  Eric Hodel  <drbrain@segment7.net>',
         %w[three four]],
       [ 'Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
-        %w[five six]]]
+        %w[five six]],
+      [ '2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>',
+        %w[seven eight]]]
 
     expected = {
       '2012-12-04' => [
@@ -189,6 +195,9 @@ class TestRDocParserChangeLog < RDoc::TestCase
       '2012-12-03' => [
         ['Mon Dec  3 20:28:02 2012  Koichi Sasada  <ko1@atdot.net>',
           %w[five six]]],
+      '2008-01-30' => [
+        ['2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>',
+          %w[seven eight]]],
     }
 
     assert_equal expected, parser.group_entries(entries)
@@ -222,6 +231,25 @@ Other note that will be ignored
     assert_equal expected, parser.parse_entries
   end
 
+  def test_parse_entries_bad_time
+    parser = util_parser <<-ChangeLog
+2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>
+
+        PR libffi/34612
+        * src/x86/sysv.S (ffi_closure_SYSV): Pop 4 byte from stack when
+        returning struct.
+
+    ChangeLog
+
+    expected = [
+      [ '2008-01-30  H.J. Lu  <hongjiu.lu@intel.com>',
+        [ 'src/x86/sysv.S (ffi_closure_SYSV): Pop 4 byte from stack when ' +
+          'returning struct.']]
+    ]
+
+    assert_equal expected, parser.parse_entries
+  end
+
   def test_parse_entries_gnu
     parser = util_parser <<-ChangeLog
 1998-08-17  Richard Stallman  <rms@gnu.org>

data/test/test_rdoc_parser_markdown.rb

@@ -27,11 +27,17 @@ class TestRDocParserMarkdown < RDoc::TestCase
   end
 
   def test_class_can_parse
-    assert_equal @RP::Markdown, @RP.can_parse('foo.md')
-    assert_equal @RP::Markdown, @RP.can_parse('foo.md.ja')
-
-    assert_equal @RP::Markdown, @RP.can_parse('foo.markdown')
-    assert_equal @RP::Markdown, @RP.can_parse('foo.markdown.ja')
+    temp_dir do
+      FileUtils.touch 'foo.md'
+      assert_equal @RP::Markdown, @RP.can_parse('foo.md')
+      FileUtils.touch 'foo.md.ja'
+      assert_equal @RP::Markdown, @RP.can_parse('foo.md.ja')
+
+      FileUtils.touch 'foo.markdown'
+      assert_equal @RP::Markdown, @RP.can_parse('foo.markdown')
+      FileUtils.touch 'foo.markdown.ja'
+      assert_equal @RP::Markdown, @RP.can_parse('foo.markdown.ja')
+    end
   end
 
   def test_scan

data/test/test_rdoc_parser_rd.rb

@@ -22,21 +22,31 @@ class TestRDocParserRd < RDoc::TestCase
     @tempfile.close
   end
 
+  def mu_pp obj
+    s = ''
+    s = PP.pp obj, s
+    s = s.force_encoding Encoding.default_external if defined? Encoding
+    s.chomp
+  end
+
   def test_file
     assert_kind_of RDoc::Parser::Text, util_parser('')
   end
 
   def test_class_can_parse
-    assert_equal @RP::RD, @RP.can_parse('foo.rd')
-    assert_equal @RP::RD, @RP.can_parse('foo.rd.ja')
+    temp_dir do
+      FileUtils.touch 'foo.rd'
+      assert_equal @RP::RD, @RP.can_parse('foo.rd')
+
+      FileUtils.touch 'foo.rd.ja'
+      assert_equal @RP::RD, @RP.can_parse('foo.rd.ja')
+    end
   end
 
   def test_scan
     parser = util_parser 'it ((*really*)) works'
 
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('it <em>really</em> works'))
+    expected = doc(para('it <em>really</em> works'))
     expected.file = @top_level
 
     parser.scan

data/test/test_rdoc_parser_ruby.rb

@@ -1525,6 +1525,21 @@ end
     assert            ampersand.singleton
   end
 
+  def test_parse_method_constant
+    c = RDoc::Constant.new 'CONST', nil, ''
+    m = @top_level.add_class RDoc::NormalModule, 'M'
+    m.add_constant c
+
+    util_parser "def CONST.m() end"
+
+    tk = @parser.get_tk
+
+    @parser.parse_method m, RDoc::Parser::Ruby::NORMAL, tk, @comment
+
+    assert_empty @store.modules_hash.keys
+    assert_equal %w[M], @store.classes_hash.keys
+  end
+
   def test_parse_method_false
     util_parser "def false.foo() :bar end"
 
@@ -1766,6 +1781,14 @@ end
     assert_equal "def \317\211", omega.text
   end
 
+  def test_parse_method_dummy
+    util_parser ".method() end"
+
+    @parser.parse_method_dummy @top_level
+
+    assert_nil @parser.get_tk
+  end
+
   def test_parse_method_or_yield_parameters_hash
     util_parser "({})\n"
 

data/test/test_rdoc_rd_block_parser.rb

@@ -15,6 +15,23 @@ class TestRDocRdBlockParser < RDoc::TestCase
     s.chomp
   end
 
+  def test_add_footnote
+    index = @block_parser.add_footnote 'context'
+
+    assert_equal 1, index
+
+    expected = [
+      para('{^1}[rdoc-label:footmark-1:foottext-1]', ' ', 'context'),
+      blank_line,
+    ]
+
+    assert_equal expected, @block_parser.footnotes
+
+    index = @block_parser.add_footnote 'other'
+
+    assert_equal 2, index
+  end
+
   def test_parse_desclist
     list = <<-LIST
 :one
@@ -25,9 +42,9 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NOTE,
-          @RM::ListItem.new("one", @RM::Paragraph.new("desc one")),
-          @RM::ListItem.new("two", @RM::Paragraph.new("desc two"))))
+        list(:NOTE,
+          item("one", para("desc one")),
+          item("two", para("desc two"))))
 
     assert_equal expected, parse(list)
   end
@@ -40,9 +57,9 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil, @RM::Paragraph.new("one")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("two"))))
+        list(:NUMBER,
+          item(nil, para("one")),
+          item(nil, para("two"))))
 
     assert_equal expected, parse(list)
   end
@@ -56,10 +73,10 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("one"),
-            @RM::Paragraph.new("two"))))
+        list(:NUMBER,
+          item(nil,
+            para("one"),
+            para("two"))))
 
     assert_equal expected, parse(list)
   end
@@ -74,8 +91,8 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil, @RM::Paragraph.new(*contents))))
+        list(:NUMBER,
+          item(nil, para(*contents))))
 
     assert_equal expected, parse(list)
   end
@@ -88,10 +105,10 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("item"),
-            @RM::Verbatim.new("verbatim\n"))))
+        list(:NUMBER,
+          item(nil,
+            para("item"),
+            verb("verbatim\n"))))
 
     assert_equal expected, parse(list)
   end
@@ -105,11 +122,11 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("one"),
-            @RM::Verbatim.new("verbatim\n"),
-            @RM::Paragraph.new("two"))))
+        list(:NUMBER,
+          item(nil,
+            para("one"),
+            verb("verbatim\n"),
+            para("two"))))
 
     assert_equal expected, parse(list)
   end
@@ -117,9 +134,10 @@ class TestRDocRdBlockParser < RDoc::TestCase
   def test_parse_footnote
     expected =
       doc(
-        @RM::Paragraph.new("{*1}[rdoc-label:foottext-1:footmark-1]"),
-        @RM::Rule.new(1),
-        @RM::Paragraph.new("{^1}[rdoc-label:footmark-1:foottext-1]", "text"))
+        para("{*1}[rdoc-label:foottext-1:footmark-1]"),
+        rule(1),
+        para("{^1}[rdoc-label:footmark-1:foottext-1]", " ", "text"),
+        blank_line)
 
     assert_equal expected, parse("((-text-))")
   end
@@ -137,10 +155,10 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::BlankLine.new,
-        @RM::Paragraph.new("include <em>worked</em>"),
-        @RM::BlankLine.new,
-        @RM::BlankLine.new)
+        blank_line,
+        para("include <em>worked</em>"),
+        blank_line,
+        blank_line)
 
     Tempfile.open %w[parse_include .rd] do |io|
       io.puts "=begin\ninclude ((*worked*))\n=end"
@@ -155,12 +173,12 @@ class TestRDocRdBlockParser < RDoc::TestCase
   end
 
   def test_parse_heading
-    assert_equal doc(@RM::Heading.new(1, "H")), parse("= H")
-    assert_equal doc(@RM::Heading.new(2, "H")), parse("== H")
-    assert_equal doc(@RM::Heading.new(3, "H")), parse("=== H")
-    assert_equal doc(@RM::Heading.new(4, "H")), parse("==== H")
-    assert_equal doc(@RM::Heading.new(5, "H")), parse("+ H")
-    assert_equal doc(@RM::Heading.new(6, "H")), parse("++ H")
+    assert_equal doc(head(1, "H")), parse("= H")
+    assert_equal doc(head(2, "H")), parse("== H")
+    assert_equal doc(head(3, "H")), parse("=== H")
+    assert_equal doc(head(4, "H")), parse("==== H")
+    assert_equal doc(head(5, "H")), parse("+ H")
+    assert_equal doc(head(6, "H")), parse("++ H")
   end
 
   def test_parse_itemlist
@@ -171,9 +189,9 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:BULLET,
-          @RM::ListItem.new(nil, @RM::Paragraph.new("one")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("two"))))
+        list(:BULLET,
+          item(nil, para("one")),
+          item(nil, para("two"))))
 
     assert_equal expected, parse(list)
   end
@@ -188,8 +206,8 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:BULLET,
-          @RM::ListItem.new(nil, @RM::Paragraph.new(*contents))))
+        list(:BULLET,
+          item(nil, para(*contents))))
 
     assert_equal expected, parse(list)
   end
@@ -203,13 +221,13 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:BULLET,
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("one"),
-            @RM::List.new(:BULLET,
-              @RM::ListItem.new(nil, @RM::Paragraph.new("inner")))),
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("two"))))
+        list(:BULLET,
+          item(nil,
+            para("one"),
+            list(:BULLET,
+              item(nil, para("inner")))),
+          item(nil,
+            para("two"))))
 
     assert_equal expected, parse(list)
   end
@@ -223,10 +241,10 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:BULLET,
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("one"),
-            @RM::Paragraph.new("two"))))
+        list(:BULLET,
+          item(nil,
+            para("one"),
+            para("two"))))
 
     assert_equal expected, parse(list)
   end
@@ -239,10 +257,10 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:BULLET,
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("item"),
-            @RM::Verbatim.new("verbatim\n"))))
+        list(:BULLET,
+          item(nil,
+            para("item"),
+            verb("verbatim\n"))))
 
     assert_equal expected, parse(list)
   end
@@ -256,11 +274,11 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:BULLET,
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("one"),
-            @RM::Verbatim.new("verbatim\n"),
-            @RM::Paragraph.new("two"))))
+        list(:BULLET,
+          item(nil,
+            para("one"),
+            verb("verbatim\n"),
+            para("two"))))
 
     assert_equal expected, parse(list)
   end
@@ -277,15 +295,15 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil, @RM::Paragraph.new("one")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("two"))),
-        @RM::List.new(:BULLET,
-          @RM::ListItem.new(nil, @RM::Paragraph.new("three")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("four"))),
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil, @RM::Paragraph.new("five")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("six"))))
+        list(:NUMBER,
+          item(nil, para("one")),
+          item(nil, para("two"))),
+        list(:BULLET,
+          item(nil, para("three")),
+          item(nil, para("four"))),
+        list(:NUMBER,
+          item(nil, para("five")),
+          item(nil, para("six"))))
 
     assert_equal expected, parse(list)
   end
@@ -302,15 +320,15 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil, @RM::Paragraph.new("one")),
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("two"),
-            @RM::List.new(:BULLET,
-              @RM::ListItem.new(nil, @RM::Paragraph.new("three")),
-              @RM::ListItem.new(nil, @RM::Paragraph.new("four")))),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("five")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("six"))))
+        list(:NUMBER,
+          item(nil, para("one")),
+          item(nil,
+            para("two"),
+            list(:BULLET,
+              item(nil, para("three")),
+              item(nil, para("four")))),
+          item(nil, para("five")),
+          item(nil, para("six"))))
 
     assert_equal expected, parse(list)
   end
@@ -328,16 +346,16 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil, @RM::Paragraph.new("one")),
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("two"),
-            @RM::List.new(:BULLET,
-              @RM::ListItem.new(nil, @RM::Paragraph.new("three")),
-              @RM::ListItem.new(nil, @RM::Paragraph.new("four"))),
-            @RM::Verbatim.new("verbatim\n")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("five")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("six"))))
+        list(:NUMBER,
+          item(nil, para("one")),
+          item(nil,
+            para("two"),
+            list(:BULLET,
+              item(nil, para("three")),
+              item(nil, para("four"))),
+            verb("verbatim\n")),
+          item(nil, para("five")),
+          item(nil, para("six"))))
 
     assert_equal expected, parse(list)
   end
@@ -355,16 +373,16 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:NUMBER,
-          @RM::ListItem.new(nil, @RM::Paragraph.new("one")),
-          @RM::ListItem.new(nil,
-            @RM::Paragraph.new("two"),
-            @RM::List.new(:BULLET,
-              @RM::ListItem.new(nil, @RM::Paragraph.new("three")),
-              @RM::ListItem.new(nil, @RM::Paragraph.new("four"))),
-            @RM::Verbatim.new("verbatim\n")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("five")),
-          @RM::ListItem.new(nil, @RM::Paragraph.new("six"))))
+        list(:NUMBER,
+          item(nil, para("one")),
+          item(nil,
+            para("two"),
+            list(:BULLET,
+              item(nil, para("three")),
+              item(nil, para("four"))),
+            verb("verbatim\n")),
+          item(nil, para("five")),
+          item(nil, para("six"))))
 
     assert_equal expected, parse(list)
   end
@@ -380,13 +398,13 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:LABEL,
-          @RM::ListItem.new(
+        list(:LABEL,
+          item(
             "<tt>Array#each {|i| ... }</tt>",
-            @RM::Paragraph.new("yield block for each item.")),
-          @RM::ListItem.new(
+            para("yield block for each item.")),
+          item(
             "<tt>Array#index(val)</tt>",
-            @RM::Paragraph.new("return index of first item which equals with val. if it hasn't same item, return nil."))))
+            para("return index of first item which equals with val. if it hasn't same item, return nil."))))
 
     assert_equal expected, parse(list)
   end
@@ -399,8 +417,8 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:LABEL,
-          @RM::ListItem.new("<tt>A#b</tt>")))
+        list(:LABEL,
+          item("<tt>A#b</tt>")))
 
     assert_equal expected, parse(list)
   end
@@ -414,10 +432,10 @@ class TestRDocRdBlockParser < RDoc::TestCase
 
     expected =
       doc(
-        @RM::List.new(:LABEL,
-          @RM::ListItem.new(
+        list(:LABEL,
+          item(
             "<tt>A#b</tt>",
-            @RM::Paragraph.new("one"))))
+            para("one"))))
 
     assert_equal expected, parse(list)
   end
@@ -432,11 +450,11 @@ two
 
     expected =
       doc(
-        @RM::List.new(:LABEL,
-          @RM::ListItem.new(
+        list(:LABEL,
+          item(
             "<tt>A#b</tt>",
-            @RM::Paragraph.new("one"))),
-        @RM::Paragraph.new("two"))
+            para("one"))),
+        para("two"))
 
     assert_equal expected, parse(list)
   end
@@ -451,21 +469,21 @@ two
 
     expected =
       doc(
-        @RM::List.new(:LABEL,
-          @RM::ListItem.new(
+        list(:LABEL,
+          item(
             "<tt>A#b</tt>",
-            @RM::Paragraph.new("text"),
-            @RM::Verbatim.new("verbatim\n"))))
+            para("text"),
+            verb("verbatim\n"))))
 
     assert_equal expected, parse(list)
   end
 
   def test_parse_verbatim
-    assert_equal doc(@RM::Verbatim.new("verbatim\n")), parse("  verbatim")
+    assert_equal doc(verb("verbatim\n")), parse("  verbatim")
   end
 
   def test_parse_verbatim_blankline
-    expected = doc(@RM::Verbatim.new("one\n", "\n", "two\n"))
+    expected = doc(verb("one\n", "\n", "two\n"))
 
     verbatim = <<-VERBATIM
   one
@@ -477,7 +495,7 @@ two
   end
 
   def test_parse_verbatim_indent
-    expected = doc(@RM::Verbatim.new("one\n", " two\n"))
+    expected = doc(verb("one\n", " two\n"))
 
     verbatim = <<-VERBATIM
   one
@@ -488,7 +506,7 @@ two
   end
 
   def test_parse_verbatim_multi
-    expected = doc(@RM::Verbatim.new("one\n", "two\n"))
+    expected = doc(verb("one\n", "two\n"))
 
     verbatim = <<-VERBATIM
   one
@@ -499,11 +517,11 @@ two
   end
 
   def test_parse_textblock
-    assert_equal doc(@RM::Paragraph.new("text")), parse("text")
+    assert_equal doc(para("text")), parse("text")
   end
 
   def test_parse_textblock_multi
-    expected = doc(@RM::Paragraph.new("one two"))
+    expected = doc(para("one two"))
 
     assert_equal expected, parse("one\ntwo")
   end
@@ -513,8 +531,8 @@ two
 
     doc = @block_parser.parse text.lines.to_a
 
-    assert_equal @RM::BlankLine.new, doc.parts.shift, "=begin blankline"
-    assert_equal @RM::BlankLine.new, doc.parts.pop, "=end blankline"
+    assert_equal blank_line, doc.parts.shift, "=begin blankline"
+    assert_equal blank_line, doc.parts.pop, "=end blankline"
 
     doc
   end