rdoc 3.12.2 → 4.0.0.preview2

data/test/test_rdoc_parser_markdown.rb

@@ -0,0 +1,55 @@
+require 'rdoc/test_case'
+
+class TestRDocParserMarkdown < RDoc::TestCase
+
+  def setup
+    super
+
+    @RP = RDoc::Parser
+
+    @tempfile = Tempfile.new self.class.name
+    filename = @tempfile.path
+
+    @top_level = @store.add_file filename
+    @fn = filename
+    @options = RDoc::Options.new
+    @stats = RDoc::Stats.new @store, 0
+  end
+
+  def teardown
+    super
+
+    @tempfile.close
+  end
+
+  def test_file
+    assert_kind_of RDoc::Parser::Text, util_parser('')
+  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')
+  end
+
+  def test_scan
+    parser = util_parser 'it *really* works'
+
+    expected =
+      @RM::Document.new(
+        @RM::Paragraph.new('it _really_ works'))
+    expected.file = @top_level
+
+    parser.scan
+
+    assert_equal expected, @top_level.comment.parse
+  end
+
+  def util_parser content
+    RDoc::Parser::Markdown.new @top_level, @fn, content, @options, @stats
+  end
+
+end
+

data/test/test_rdoc_parser_rd.rb

@@ -10,10 +10,10 @@ class TestRDocParserRd < RDoc::TestCase
     @tempfile = Tempfile.new self.class.name
     filename = @tempfile.path
 
-    @top_level = RDoc::TopLevel.new filename
+    @top_level = @store.add_file filename
     @fn = filename
     @options = RDoc::Options.new
-    @stats = RDoc::Stats.new 0
+    @stats = RDoc::Stats.new @store, 0
   end
 
   def teardown

data/test/test_rdoc_parser_ruby.rb

@@ -14,14 +14,16 @@ class TestRDocParserRuby < RDoc::TestCase
     @tempfile2 = Tempfile.new self.class.name
     @filename2 = @tempfile2.path
 
-    util_top_level
+    @top_level = @store.add_file @filename
+    @top_level2 = @store.add_file @filename2
+
     @options = RDoc::Options.new
     @options.quiet = true
     @options.option_parser = OptionParser.new
 
     @comment = RDoc::Comment.new '', @top_level
 
-    @stats = RDoc::Stats.new 0
+    @stats = RDoc::Stats.new @store, 0
   end
 
   def teardown
@@ -68,6 +70,45 @@ class C; end
     assert_equal Encoding::CP852, comment.text.encoding
   end
 
+  def test_get_class_or_module
+    ctxt = RDoc::Context.new
+    ctxt.store = @store
+
+    cont, name_t, given_name = util_parser('A')    .get_class_or_module ctxt
+
+    assert_equal ctxt, cont
+    assert_equal 'A', name_t.text
+    assert_equal 'A', given_name
+
+    cont, name_t, given_name = util_parser('A::B') .get_class_or_module ctxt
+
+    assert_equal @store.find_module_named('A'), cont
+    assert_equal 'B', name_t.text
+    assert_equal 'A::B', given_name
+
+    cont, name_t, given_name = util_parser('A:: B').get_class_or_module ctxt
+
+    assert_equal @store.find_module_named('A'), cont
+    assert_equal 'B', name_t.text
+    assert_equal 'A::B', given_name
+
+    assert_raises NoMethodError do
+      util_parser("A::\nB").get_class_or_module ctxt
+    end
+  end
+
+  def test_get_class_specification
+    assert_equal 'A',    util_parser('A')   .get_class_specification
+    assert_equal 'A::B', util_parser('A::B').get_class_specification
+    assert_equal '::A',  util_parser('::A').get_class_specification
+
+    assert_equal 'self', util_parser('self').get_class_specification
+
+    assert_equal '',     util_parser('').get_class_specification
+
+    assert_equal '',     util_parser('$g').get_class_specification
+  end
+
   def test_get_symbol_or_name
     util_parser "* & | + 5 / 4"
 
@@ -160,7 +201,7 @@ class C; end
 
     section = @top_level.current_section
     assert_equal 'new section', section.title
-    assert_equal "# woo stuff\n", section.comment.text
+    assert_equal [comment("# woo stuff\n", @top_level)], section.comments
 
     assert_empty comment
   end
@@ -564,6 +605,19 @@ end
     assert_equal 1, foo.line
   end
 
+  def test_parse_class_single_root
+    comment = RDoc::Comment.new "##\n# my class\n", @top_level
+
+    util_parser "class << ::Foo\nend"
+
+    tk = @parser.get_tk
+
+    @parser.parse_class @top_level, RDoc::Parser::Ruby::NORMAL, tk, comment
+
+    foo = @store.all_modules.first
+    assert_equal 'Foo', foo.full_name
+  end
+
   def test_parse_class_stopdoc
     @top_level.stop_doc
 
@@ -630,7 +684,6 @@ end
   end
 
   def test_parse_class_nested_superclass
-    util_top_level
     foo = @top_level.add_module RDoc::NormalModule, 'Foo'
 
     util_parser "class Bar < Super\nend"
@@ -701,7 +754,22 @@ end
 
     @parser.parse_class @top_level, false, @parser.get_tk, @comment
 
-    assert_equal %w[A B],    RDoc::TopLevel.classes.map { |c| c.full_name }
+    assert_equal %w[A B], @store.all_classes.map { |c| c.full_name }.sort
+  end
+
+  def test_parse_class_colon3_self_reference
+    code = <<-CODE
+class A::B
+  class ::A
+  end
+end
+    CODE
+
+    util_parser code
+
+    @parser.parse_class @top_level, false, @parser.get_tk, @comment
+
+    assert_equal %w[A A::B], @store.all_classes.map { |c| c.full_name }.sort
   end
 
   def test_parse_class_single
@@ -720,21 +788,42 @@ end
 
     @parser.parse_class @top_level, false, @parser.get_tk, @comment
 
-    assert_equal %w[A],    RDoc::TopLevel.classes.map { |c| c.full_name }
-    assert_equal %w[A::B A::d], RDoc::TopLevel.modules.map { |c| c.full_name }
+    assert_equal %w[A], @store.all_classes.map { |c| c.full_name }
 
-    b = RDoc::TopLevel.modules.first
+    modules = @store.all_modules.sort_by { |c| c.full_name }
+    assert_equal %w[A::B A::d], modules.map { |c| c.full_name }
+
+    b = modules.first
     assert_equal 10, b.offset
     assert_equal 2,  b.line
 
     # make sure method/alias was not added to enclosing class/module
-    a = RDoc::TopLevel.all_classes_hash['A']
+    a = @store.classes_hash['A']
     assert_empty a.method_list
 
     # make sure non-constant-named module will be removed from documentation
-    d = RDoc::TopLevel.all_modules_hash['A::d']
+    d = @store.modules_hash['A::d']
     assert d.remove_from_documentation?
+  end
 
+  def test_parse_class_single_gvar
+    code = <<-CODE
+class << $g
+  def m
+  end
+end
+    CODE
+
+    util_parser code
+
+    @parser.parse_class @top_level, false, @parser.get_tk, ''
+
+    assert_empty @store.all_classes
+    mod = @store.all_modules.first
+
+    refute mod.document_self
+
+    assert_empty mod.method_list
   end
 
   # TODO this is really a Context#add_class test
@@ -754,11 +843,14 @@ end
 
     @parser.parse_module @top_level, false, @parser.get_tk, @comment
 
-    assert_equal %w[A],    RDoc::TopLevel.modules.map { |c| c.full_name }
-    assert_equal %w[A::B A::C A::Object], RDoc::TopLevel.classes.map { |c| c.full_name }.sort
-    assert_equal 'Object', RDoc::TopLevel.classes_hash['A::B'].superclass
-    assert_equal 'Object', RDoc::TopLevel.classes_hash['A::Object'].superclass
-    assert_equal 'A::Object', RDoc::TopLevel.classes_hash['A::C'].superclass.full_name
+    assert_equal %w[A],
+      @store.all_modules.map { |c| c.full_name }
+    assert_equal %w[A::B A::C A::Object],
+      @store.all_classes.map { |c| c.full_name }.sort
+
+    assert_equal 'Object',    @store.classes_hash['A::B'].superclass
+    assert_equal 'Object',    @store.classes_hash['A::Object'].superclass
+    assert_equal 'A::Object', @store.classes_hash['A::C'].superclass.full_name
   end
 
   def test_parse_class_mistaken_for_module
@@ -781,7 +873,7 @@ end
 
     @parser.scan
 
-    assert_equal %w[Foo::Baz], RDoc::TopLevel.modules_hash.keys
+    assert_equal %w[Foo::Baz], @store.modules_hash.keys
     assert_empty @top_level.modules
 
     foo = @top_level.classes.first
@@ -795,9 +887,9 @@ end
   end
 
   def test_parse_class_definition_encountered_after_class_reference
-    # The code below is not strictly legal Ruby (Foo must have been defined
-    # before Foo.bar is encountered), but RDoc might encounter Foo.bar before
-    # Foo if they live in different files.
+    # The code below is not legal Ruby (Foo must have been defined before
+    # Foo.bar is encountered), but RDoc might encounter Foo.bar before Foo if
+    # they live in different files.
 
     code = <<-EOF
 def Foo.bar
@@ -811,9 +903,8 @@ end
 
     @parser.scan
 
-    assert_empty RDoc::TopLevel.modules_hash
-    # HACK why does it fail?
-    #assert_empty @top_level.modules
+    assert_empty @store.modules_hash
+    assert_empty @store.all_modules
 
     foo = @top_level.classes.first
     assert_equal 'Foo', foo.full_name
@@ -934,9 +1025,10 @@ EOF
     assert_equal klass.current_section, foo.section
 
     stream = [
-      tk(:COMMENT, 1, 1, nil, "# File #{@top_level.absolute_name}, line 1"),
+      tk(:COMMENT, 0, 1, 1, nil,
+         "# File #{@top_level.relative_name}, line 1"),
       RDoc::Parser::Ruby::NEWLINE_TOKEN,
-      tk(:SPACE,   1, 1, nil, ''),
+      tk(:SPACE,   0, 1, 1, nil, ''),
     ]
 
     assert_equal stream, foo.token_stream
@@ -959,8 +1051,6 @@ EOF
   end
 
   def test_parse_constant
-    util_top_level
-
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
 
     util_parser "A = v"
@@ -978,8 +1068,6 @@ EOF
   end
 
   def test_parse_constant_attrasgn
-    util_top_level
-
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
 
     util_parser "A[k] = v"
@@ -992,9 +1080,8 @@ EOF
   end
 
   def test_parse_constant_alias
-    util_top_level
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
-    cB = klass.add_class RDoc::NormalClass, 'B'
+    klass.add_class RDoc::NormalClass, 'B'
 
     util_parser "A = B"
 
@@ -1002,15 +1089,15 @@ EOF
 
     @parser.parse_constant klass, tk, @comment
 
-    assert_equal cB, klass.find_module_named('A')
+    assert_equal 'Foo::A', klass.find_module_named('A').full_name
   end
 
   def test_parse_constant_alias_same_name
     foo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    top_bar = @top_level.add_class RDoc::NormalClass, 'Bar'
+    @top_level.add_class RDoc::NormalClass, 'Bar'
     bar = foo.add_class RDoc::NormalClass, 'Bar'
 
-    assert RDoc::TopLevel.find_class_or_module('::Bar')
+    assert @store.find_class_or_module('::Bar')
 
     util_parser "A = ::Bar"
 
@@ -1018,12 +1105,10 @@ EOF
 
     @parser.parse_constant foo, tk, @comment
 
-    assert_equal top_bar, bar.find_module_named('A')
+    assert_equal 'A', bar.find_module_named('A').full_name
   end
 
   def test_parse_constant_stopdoc
-    util_top_level
-
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
     klass.stop_doc
 
@@ -1056,6 +1141,26 @@ EOF
     assert_equal @top_level, incl.file
   end
 
+  def test_parse_extend
+    klass = RDoc::NormalClass.new 'C'
+    klass.parent = @top_level
+
+    comment = RDoc::Comment.new "# my extend\n", @top_level
+
+    util_parser "extend I"
+
+    @parser.get_tk # extend
+
+    @parser.parse_extend klass, comment
+
+    assert_equal 1, klass.extends.length
+
+    ext = klass.extends.first
+    assert_equal 'I', ext.name
+    assert_equal 'my extend', ext.comment.text
+    assert_equal @top_level, ext.file
+  end
+
   def test_parse_meta_method
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
@@ -1093,16 +1198,17 @@ EOF
     assert_equal klass.current_section, foo.section
 
     stream = [
-      tk(:COMMENT,    1, 1,  nil, "# File #{@top_level.absolute_name}, line 1"),
+      tk(:COMMENT,     0, 1, 1,  nil,
+         "# File #{@top_level.relative_name}, line 1"),
       RDoc::Parser::Ruby::NEWLINE_TOKEN,
-      tk(:SPACE,      1, 1,  nil, ''),
-      tk(:IDENTIFIER, 1, 0,  'add_my_method', 'add_my_method'),
-      tk(:SPACE,      1, 13, nil, ' '),
-      tk(:SYMBOL,     1, 14, nil, ':foo'),
-      tk(:COMMA,      1, 18, nil, ','),
-      tk(:SPACE,      1, 19, nil, ' '),
-      tk(:SYMBOL,     1, 20, nil, ':bar'),
-      tk(:NL,         1, 24, nil, "\n"),
+      tk(:SPACE,       0, 1, 1,  nil, ''),
+      tk(:IDENTIFIER,  0, 1, 0,  'add_my_method', 'add_my_method'),
+      tk(:SPACE,       0, 1, 13, nil, ' '),
+      tk(:SYMBOL,      0, 1, 14, nil, ':foo'),
+      tk(:COMMA,       0, 1, 18, nil, ','),
+      tk(:SPACE,       0, 1, 19, nil, ' '),
+      tk(:SYMBOL,      0, 1, 20, nil, ':bar'),
+      tk(:NL,          0, 1, 24, nil, "\n"),
     ]
 
     assert_equal stream, foo.token_stream
@@ -1126,7 +1232,23 @@ end
 
     @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 
-    assert_nil @parser.get_tk
+    assert_equal tk(:NL, 0, 3, 3, 3, "\n"), @parser.get_tk
+  end
+
+  def test_parse_meta_method_define_method
+    klass = RDoc::NormalClass.new 'Foo'
+    comment = RDoc::Comment.new "##\n# my method\n", @top_level
+
+    util_parser "define_method :foo do end"
+
+    tk = @parser.get_tk
+
+    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+
+    foo = klass.method_list.first
+    assert_equal 'foo', foo.name
+    assert_equal 'my method', foo.comment.text
+    assert_equal @top_level,  foo.file
   end
 
   def test_parse_meta_method_name
@@ -1274,19 +1396,20 @@ end
     assert_equal klass.current_section, foo.section
 
     stream = [
-      tk(:COMMENT,    1, 1,  nil, "# File #{@top_level.absolute_name}, line 1"),
+      tk(:COMMENT,     0, 1, 1,  nil,
+         "# File #{@top_level.relative_name}, line 1"),
       RDoc::Parser::Ruby::NEWLINE_TOKEN,
-      tk(:SPACE,      1, 1,  nil,   ''),
-      tk(:DEF,        1, 0,  'def', 'def'),
-      tk(:SPACE,      1, 3,  nil,   ' '),
-      tk(:IDENTIFIER, 1, 4,  'foo', 'foo'),
-      tk(:LPAREN,     1, 7,  nil,   '('),
-      tk(:RPAREN,     1, 8,  nil,   ')'),
-      tk(:SPACE,      1, 9,  nil,   ' '),
-      tk(:COLON,      1, 10, nil,   ':'),
-      tk(:IDENTIFIER, 1, 11, 'bar', 'bar'),
-      tk(:SPACE,      1, 14, nil,   ' '),
-      tk(:END,        1, 15, 'end', 'end'),
+      tk(:SPACE,       0, 1, 1,  nil,   ''),
+      tk(:DEF,         0, 1, 0,  'def', 'def'),
+      tk(:SPACE,       3, 1, 3,  nil,   ' '),
+      tk(:IDENTIFIER,  4, 1, 4,  'foo', 'foo'),
+      tk(:LPAREN,      7, 1, 7,  nil,   '('),
+      tk(:RPAREN,      8, 1, 8,  nil,   ')'),
+      tk(:SPACE,       9, 1, 9,  nil,   ' '),
+      tk(:COLON,      10, 1, 10, nil,   ':'),
+      tk(:IDENTIFIER, 11, 1, 11, 'bar', 'bar'),
+      tk(:SPACE,      14, 1, 14, nil,   ' '),
+      tk(:END,        15, 1, 15, 'end', 'end'),
     ]
 
     assert_equal stream, foo.token_stream
@@ -1305,6 +1428,21 @@ end
     assert klass.aliases.empty?
   end
 
+  def test_parse_method_ampersand
+    klass = RDoc::NormalClass.new 'Foo'
+    klass.parent = @top_level
+
+    util_parser "def self.&\nend"
+
+    tk = @parser.get_tk
+
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
+
+    ampersand = klass.method_list.first
+    assert_equal '&', ampersand.name
+    assert            ampersand.singleton
+  end
+
   def test_parse_method_false
     util_parser "def false.foo() :bar end"
 
@@ -1312,7 +1450,7 @@ end
 
     @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
 
-    klass = RDoc::TopLevel.find_class_named 'FalseClass'
+    klass = @store.find_class_named 'FalseClass'
 
     foo = klass.method_list.first
     assert_equal 'foo', foo.name
@@ -1328,7 +1466,7 @@ end
 
     @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
 
-    assert klass.method_list.empty?
+    assert_empty klass.method_list
   end
 
   def test_parse_method_gvar
@@ -1341,6 +1479,22 @@ end
     assert @top_level.method_list.empty?
   end
 
+  def test_parse_method_gvar_insane
+    util_parser "def $stdout.foo() class << $other; end; end"
+
+    tk = @parser.get_tk
+
+    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
+
+    assert @top_level.method_list.empty?
+
+    assert_empty @store.all_classes
+
+    assert_equal 1, @store.all_modules.length
+
+    refute @store.all_modules.first.document_self
+  end
+
   def test_parse_method_internal_gvar
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
@@ -1387,7 +1541,7 @@ end
 
     @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
 
-    klass = RDoc::TopLevel.find_class_named 'NilClass'
+    klass = @store.find_class_named 'NilClass'
 
     foo = klass.method_list.first
     assert_equal 'foo', foo.name
@@ -1436,6 +1590,21 @@ end
     assert_equal '(arg1, arg2, arg3)', foo.params
   end
 
+  def test_parse_method_star
+    klass = RDoc::NormalClass.new 'Foo'
+    klass.parent = @top_level
+
+    util_parser "def self.*\nend"
+
+    tk = @parser.get_tk
+
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
+
+    ampersand = klass.method_list.first
+    assert_equal '*', ampersand.name
+    assert            ampersand.singleton
+  end
+
   def test_parse_method_stopdoc
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
@@ -1461,7 +1630,7 @@ end
 
     @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
 
-    object = RDoc::TopLevel.find_class_named 'Object'
+    object = @store.find_class_named 'Object'
 
     foo = object.method_list.first
     assert_equal 'Object#foo', foo.full_name
@@ -1477,7 +1646,7 @@ end
 
     @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, @comment
 
-    object = RDoc::TopLevel.find_class_named 'Object'
+    object = @store.find_class_named 'Object'
 
     foo = object.method_list.first
     assert_equal 'Object::foo', foo.full_name
@@ -1490,7 +1659,7 @@ end
 
     @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, @comment
 
-    klass = RDoc::TopLevel.find_class_named 'TrueClass'
+    klass = @store.find_class_named 'TrueClass'
 
     foo = klass.method_list.first
     assert_equal 'foo', foo.name
@@ -1515,6 +1684,16 @@ end
     assert_equal "def \317\211", omega.text
   end
 
+  def test_parse_method_or_yield_parameters_hash
+    util_parser "({})\n"
+
+    m = RDoc::AnyMethod.new nil, 'm'
+
+    result = @parser.parse_method_or_yield_parameters m
+
+    assert_equal '({})', result
+  end
+
   def test_parse_statements_class_if
     util_parser <<-CODE
 module Foo
@@ -1562,19 +1741,17 @@ end
     assert_equal 2, x.method_list.length
     a = x.method_list.first
 
-    rt = RDoc::RubyToken
-
     expected = [
-      rt::TkCOMMENT   .new( 0, 2, 1, "# File #{@filename}, line 2"),
-      rt::TkNL        .new( 0, 0, 0, "\n"),
-      rt::TkSPACE     .new( 0, 1, 1, ""),
-      rt::TkDEF       .new( 8, 2, 0, "def"),
-      rt::TkSPACE     .new(11, 2, 3, " "),
-      rt::TkIDENTIFIER.new(12, 2, 4, "a"),
-      rt::TkNL        .new(13, 2, 5, "\n"),
-      rt::TkDREGEXP   .new(14, 3, 0, "%r{#}"),
-      rt::TkNL        .new(19, 3, 5, "\n"),
-      rt::TkEND       .new(20, 4, 0, "end"),
+      tk(:COMMENT,     0, 2, 1, nil,   "# File #{@filename}, line 2"),
+      tk(:NL,          0, 0, 0, nil,   "\n"),
+      tk(:SPACE,       0, 1, 1, nil,   ''),
+      tk(:DEF,         8, 2, 0, 'def', 'def'),
+      tk(:SPACE,      11, 2, 3, nil,   ' '),
+      tk(:IDENTIFIER, 12, 2, 4, 'a',   'a'),
+      tk(:NL,         13, 2, 5, nil,   "\n"),
+      tk(:DREGEXP,    14, 3, 0, nil,   '%r{#}'),
+      tk(:NL,         19, 3, 5, nil,   "\n"),
+      tk(:END,        20, 4, 0, 'end', 'end'),
     ]
 
     assert_equal expected, a.token_stream
@@ -1682,8 +1859,25 @@ EOF
     assert_equal 'unknown', @top_level.classes.first.external_aliases[0].old_name
   end
 
-  def test_parse_statements_identifier_constant
+  def test_parse_statements_identifier_args
+    comment = "##\n# :args: x\n# :method: b\n# my method\n"
+
+    util_parser "module M\n#{comment}def_delegator :a, :b, :b\nend"
+
+    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
+
+    m = @top_level.modules.first
+    assert_equal 'M', m.full_name
+
+    b = m.method_list.first
+    assert_equal 'M#b', b.full_name
+    assert_equal 'x', b.params
+    assert_equal 'my method', b.comment.text
 
+    assert_nil m.params, 'Module parameter not removed'
+  end
+
+  def test_parse_statements_identifier_constant
     sixth_constant = <<-EOF
 Class.new do
   rule :file do
@@ -1794,6 +1988,24 @@ EOF
     assert_equal 'RW', foo.rw
   end
 
+  def test_parse_statements_identifier_define_method
+    util_parser <<-RUBY
+class C
+  ##
+  # :method: a
+  define_method :a do end
+  ##
+  # :method: b
+  define_method :b do end
+end
+    RUBY
+
+    @parser.parse_statements @top_level
+    c = @top_level.classes.first
+
+    assert_equal %w[a b], c.method_list.map { |m| m.name }
+  end
+
   def test_parse_statements_identifier_include
     content = "class Foo\ninclude Bar\nend"
 
@@ -1851,10 +2063,10 @@ end
 
     @parser.parse_statements @top_level
 
-    date, date_time = @top_level.classes
+    date, date_time = @top_level.classes.sort_by { |c| c.full_name }
 
     date_now      = date.method_list.first
-    date_time_now = date_time.method_list.first
+    date_time_now = date_time.method_list.sort_by { |m| m.full_name }.first
 
     assert_equal :private, date_now.visibility
     assert_equal :public,  date_time_now.visibility
@@ -1876,10 +2088,11 @@ end
 
     @parser.parse_statements @top_level
 
-    date, date_time = @top_level.classes
+    # TODO sort classes by default
+    date, date_time = @top_level.classes.sort_by { |c| c.full_name }
 
     date_now      = date.method_list.first
-    date_time_now = date_time.method_list.first
+    date_time_now = date_time.method_list.sort_by { |m| m.full_name }.first
 
     assert_equal :public,  date_now.visibility,      date_now.full_name
     assert_equal :private, date_time_now.visibility, date_time_now.full_name
@@ -1895,9 +2108,25 @@ end
     assert_equal 1, @top_level.requires.length
   end
 
-  def test_parse_statements_stopdoc_TkALIAS
-    util_top_level
+  def test_parse_statements_identifier_yields
+    comment = "##\n# :yields: x\n# :method: b\n# my method\n"
+
+    util_parser "module M\n#{comment}def_delegator :a, :b, :b\nend"
+
+    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL
+
+    m = @top_level.modules.first
+    assert_equal 'M', m.full_name
+
+    b = m.method_list.first
+    assert_equal 'M#b', b.full_name
+    assert_equal 'x', b.block_params
+    assert_equal 'my method', b.comment.text
 
+    assert_nil m.params, 'Module parameter not removed'
+  end
+
+  def test_parse_statements_stopdoc_TkALIAS
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
 
     util_parser "\n# :stopdoc:\nalias old new"
@@ -1909,8 +2138,6 @@ end
   end
 
   def test_parse_statements_stopdoc_TkIDENTIFIER_alias_method
-    util_top_level
-
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
 
     util_parser "\n# :stopdoc:\nalias_method :old :new"
@@ -1922,8 +2149,6 @@ end
   end
 
   def test_parse_statements_stopdoc_TkIDENTIFIER_metaprogrammed
-    util_top_level
-
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
 
     util_parser "\n# :stopdoc:\n# attr :meta"
@@ -1935,8 +2160,6 @@ end
   end
 
   def test_parse_statements_stopdoc_TkCONSTANT
-    util_top_level
-
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
 
     util_parser "\n# :stopdoc:\nA = v"
@@ -1947,8 +2170,6 @@ end
   end
 
   def test_parse_statements_stopdoc_TkDEF
-    util_top_level
-
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
 
     util_parser "\n# :stopdoc:\ndef m\n end"
@@ -1958,6 +2179,25 @@ end
     assert_empty klass.method_list
   end
 
+  def test_parse_statements_super
+    m = RDoc::AnyMethod.new '', 'm'
+    util_parser 'super'
+
+    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, m
+
+    assert m.calls_super
+  end
+
+  def test_parse_statements_super_no_method
+    content = "super"
+
+    util_parser content
+
+    @parser.parse_statements @top_level
+
+    assert_nil @parser.get_tk
+  end
+
   def test_parse_statements_while_begin
     util_parser <<-RUBY
 class A
@@ -2086,6 +2326,98 @@ end
     assert_equal 'nth(i)', foo.block_params
   end
 
+  def test_read_directive
+    parser = util_parser '# :category: test'
+
+    directive, value = parser.read_directive %w[category]
+
+    assert_equal 'category', directive
+    assert_equal 'test', value
+
+    assert_kind_of RDoc::RubyToken::TkNL, parser.get_tk
+  end
+
+  def test_read_directive_allow
+    parser = util_parser '# :category: test'
+
+    directive = parser.read_directive []
+
+    assert_nil directive
+
+    assert_kind_of RDoc::RubyToken::TkNL, parser.get_tk
+  end
+
+  def test_read_directive_empty
+    parser = util_parser '# test'
+
+    directive = parser.read_directive %w[category]
+
+    assert_nil directive
+
+    assert_kind_of RDoc::RubyToken::TkNL, parser.get_tk
+  end
+
+  def test_read_directive_no_comment
+    parser = util_parser ''
+
+    directive = parser.read_directive %w[category]
+
+    assert_nil directive
+
+    assert_kind_of RDoc::RubyToken::TkNL, parser.get_tk
+  end
+
+  def test_read_directive_one_liner
+    parser = util_parser '; end # :category: test'
+
+    directive, value = parser.read_directive %w[category]
+
+    assert_equal 'category', directive
+    assert_equal 'test', value
+
+    assert_kind_of RDoc::RubyToken::TkSEMICOLON, parser.get_tk
+  end
+
+  def test_read_documentation_modifiers
+    c = RDoc::Context.new
+
+    parser = util_parser '# :category: test'
+
+    parser.read_documentation_modifiers c, %w[category]
+
+    assert_equal 'test', c.current_section.title
+  end
+
+  def test_read_documentation_modifiers_notnew
+    m = RDoc::AnyMethod.new nil, 'initialize'
+
+    parser = util_parser '# :notnew: test'
+
+    parser.read_documentation_modifiers m, %w[notnew]
+
+    assert m.dont_rename_initialize
+  end
+
+  def test_read_documentation_modifiers_not_dash_new
+    m = RDoc::AnyMethod.new nil, 'initialize'
+
+    parser = util_parser '# :not-new: test'
+
+    parser.read_documentation_modifiers m, %w[not-new]
+
+    assert m.dont_rename_initialize
+  end
+
+  def test_read_documentation_modifiers_not_new
+    m = RDoc::AnyMethod.new nil, 'initialize'
+
+    parser = util_parser '# :not_new: test'
+
+    parser.read_documentation_modifiers m, %w[not_new]
+
+    assert m.dont_rename_initialize
+  end
+
   def test_sanity_integer
     util_parser '1'
     assert_equal '1', @parser.get_tk.text
@@ -2381,11 +2713,11 @@ end
     assert_equal "find_by_<field>[_and_<field>...](args)\n", m.call_seq
 
     expected =
-      @RM::Document.new(
-        @RM::Heading.new(3, 'Signature'),
-        @RM::List.new(:NOTE,
-          @RM::ListItem.new('field',
-            @RM::Paragraph.new('A field name.'))))
+      doc(
+        head(3, 'Signature'),
+        list(:NOTE,
+          item(%w[field],
+            para('A field name.'))))
     expected.file = @top_level
 
     assert_equal expected, m.comment.parse
@@ -2420,14 +2752,47 @@ end
 
     @parser.scan
 
-    assert_empty RDoc::TopLevel.classes
+    assert_empty @store.all_classes
 
-    assert_equal 1, RDoc::TopLevel.modules.length
-    m = RDoc::TopLevel.modules.first
+    assert_equal 1, @store.all_modules.length
+    m = @store.all_modules.first
 
     assert m.ignored?
   end
 
+  def test_scan_stopdoc_nested
+    util_parser <<-RUBY
+# :stopdoc:
+class A::B
+end
+    RUBY
+
+    @parser.scan
+
+    a   = @store.modules_hash['A']
+    a_b = @store.classes_hash['A::B']
+
+    refute a.document_self, 'A is inside stopdoc'
+    assert a.ignored?,      'A is inside stopdoc'
+
+    refute a_b.document_self, 'A::B is inside stopdoc'
+    assert a_b.ignored?,      'A::B is inside stopdoc'
+  end
+
+  def test_scan_struct_self_brackets
+    util_parser <<-RUBY
+class C < M.m
+  def self.[]
+  end
+end
+    RUBY
+
+    @parser.scan
+
+    c = @store.find_class_named 'C'
+    assert_equal %w[C::[]], c.method_list.map { |m| m.full_name }
+  end
+
   def test_stopdoc_after_comment
     util_parser <<-EOS
       module Bar
@@ -2453,14 +2818,14 @@ end
     assert_equal 'there', baz.comment.text
   end
 
-  def tk(klass, line, char, name, text)
+  def tk klass, scan, line, char, name, text
     klass = RDoc::RubyToken.const_get "Tk#{klass.to_s.upcase}"
 
     token = if klass.instance_method(:initialize).arity == 3 then
-              raise ArgumentError, "name not used for #{klass}" unless name.nil?
-              klass.new 0, line, char
+              raise ArgumentError, "name not used for #{klass}" if name
+              klass.new scan, line, char
             else
-              klass.new 0, line, char, name
+              klass.new scan, line, char, name
             end
 
     token.set_text text
@@ -2480,11 +2845,5 @@ end
                                       second_file_content, @options, @stats
   end
 
-  def util_top_level
-    RDoc::TopLevel.reset
-    @top_level = RDoc::TopLevel.new @filename
-    @top_level2 = RDoc::TopLevel.new @filename2
-  end
-
 end