rdoc 2.5.11 → 3.0

data/test/test_rdoc_parser_c.rb

@@ -5,6 +5,46 @@ require 'minitest/autorun'
 require 'rdoc/options'
 require 'rdoc/parser/c'
 
+=begin
+  TODO: test call-seq parsing
+
+/*
+ *  call-seq:
+ *     ARGF.readlines(sep=$/)     -> array
+ *     ARGF.readlines(limit)      -> array
+ *     ARGF.readlines(sep, limit) -> array
+ *
+ *     ARGF.to_a(sep=$/)     -> array
+ *     ARGF.to_a(limit)      -> array
+ *     ARGF.to_a(sep, limit) -> array
+ *
+ *  Reads +ARGF+'s current file in its entirety, returning an +Array+ of its
+ *  lines, one line per element. Lines are assumed to be separated by _sep_.
+ *
+ *     lines = ARGF.readlines
+ *     lines[0]                #=> "This is line one\n"
+ */
+
+assert call-seq did not stop at first empty line
+
+/*
+ * call-seq:
+ *
+ *  flt ** other  ->  float
+ *
+ * Raises <code>float</code> the <code>other</code> power.
+ *
+ *    2.0**3      #=> 8.0
+ */
+
+assert call-seq correct (bug: was empty)
+
+/* call-seq: flt ** other  ->  float */
+
+assert call-seq correct
+
+=end
+
 class RDoc::Parser::C
   attr_accessor :classes, :singleton_classes
 
@@ -30,6 +70,72 @@ class TestRDocParserC < MiniTest::Unit::TestCase
     @tempfile.close
   end
 
+  def test_do_attr_rb_attr
+    content = <<-EOF
+void Init_Blah(void) {
+  cBlah = rb_define_class("Blah", rb_cObject);
+
+  /*
+   * This is an accessor
+   */
+  rb_attr(cBlah, rb_intern("accessor"), 1, 1, Qfalse);
+
+  /*
+   * This is a reader
+   */
+  rb_attr(cBlah, rb_intern("reader"), 1, 0, Qfalse);
+
+  /*
+   * This is a writer
+   */
+  rb_attr(cBlah, rb_intern("writer"), 0, 1, Qfalse);
+}
+    EOF
+
+    klass = util_get_class content, 'cBlah'
+
+    attrs = klass.attributes
+    assert_equal 3, attrs.length, attrs.inspect
+
+    accessor = attrs.shift
+    assert_equal 'accessor',            accessor.name
+    assert_equal 'RW',                  accessor.rw
+    assert_equal 'This is an accessor', accessor.comment
+
+    reader = attrs.shift
+    assert_equal 'reader',           reader.name
+    assert_equal 'R',                reader.rw
+    assert_equal 'This is a reader', reader.comment
+
+    writer = attrs.shift
+    assert_equal 'writer',           writer.name
+    assert_equal 'W',                writer.rw
+    assert_equal 'This is a writer', writer.comment
+  end
+
+  def test_do_attr_rb_define_attr
+    content = <<-EOF
+void Init_Blah(void) {
+  cBlah = rb_define_class("Blah", rb_cObject);
+
+  /*
+   * This is an accessor
+   */
+  rb_define_attr(cBlah, "accessor", 1, 1);
+}
+    EOF
+
+    klass = util_get_class content, 'cBlah'
+
+    attrs = klass.attributes
+    assert_equal 1, attrs.length, attrs.inspect
+
+    accessor = attrs.shift
+    assert_equal 'accessor',            accessor.name
+    assert_equal 'RW',                  accessor.rw
+    assert_equal 'This is an accessor', accessor.comment
+  end
+
   def test_do_aliases
     content = <<-EOF
 /*
@@ -269,6 +375,26 @@ Multiline comment goes here because this comment spans multiple lines.
     assert constants.empty?, constants.inspect
   end
 
+  def test_find_alias_comment
+    parser = util_parser ''
+
+    comment = parser.find_alias_comment 'C', '[]', 'index'
+
+    assert_equal '', comment
+
+    parser = util_parser <<-C
+/*
+ * comment
+ */
+
+rb_define_alias(C, "[]", "index");
+    C
+
+    comment = parser.find_alias_comment 'C', '[]', 'index'
+
+    assert_equal "/*\n * comment\n */\n\n", comment
+  end
+
   def test_find_class_comment_include
     @options.rdoc_include << File.dirname(__FILE__)
 
@@ -474,7 +600,7 @@ Init_Foo(void) {
     assert_equal "a comment for bar", bar.comment
   end
 
-  def test_find_modifiers
+  def test_find_modifiers_call_seq
     comment = <<-COMMENT
 /* call-seq:
  *   commercial() -> Date <br />
@@ -497,15 +623,90 @@ Init_Foo(void) {
 
     parser.find_modifiers comment, method_obj
 
-    expected = <<-CALL_SEQ
+    expected = <<-CALL_SEQ.chomp
 commercial() -> Date <br />
 commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
 commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
+ 
     CALL_SEQ
 
     assert_equal expected, method_obj.call_seq
   end
 
+  def test_find_modifiers_nodoc
+    comment = <<-COMMENT
+/* :nodoc:
+ *
+ * Blah
+ */
+
+    COMMENT
+
+    parser = util_parser ''
+    method_obj = RDoc::AnyMethod.new nil, 'blah'
+
+    parser.find_modifiers comment, method_obj
+
+    assert_equal nil, method_obj.document_self
+  end
+
+  def test_find_modifiers_yields
+    comment = <<-COMMENT
+/* :yields: a, b
+ *
+ * Blah
+ */
+
+    COMMENT
+
+    parser = util_parser ''
+    method_obj = RDoc::AnyMethod.new nil, 'blah'
+
+    parser.find_modifiers comment, method_obj
+
+    assert_equal 'a, b', method_obj.block_params
+
+    expected = <<-EXPECTED
+/*
+ *
+ * Blah
+ */
+
+    EXPECTED
+
+    assert_equal expected, comment
+  end
+
+  def test_handle_method
+    parser = util_parser "Document-method: BasicObject#==\n blah */"
+
+    parser.handle_method 'method', 'rb_cBasicObject', '==', 'rb_obj_equal', 1
+
+    bo = @top_level.find_module_named 'BasicObject'
+
+    assert_equal 1, bo.method_list.length
+
+    equals2 = bo.method_list.first
+
+    assert_equal '==', equals2.name
+  end
+
+  def test_handle_method_initialize
+    parser = util_parser "Document-method: BasicObject::new\n blah */"
+
+    parser.handle_method('private_method', 'rb_cBasicObject',
+                         'initialize', 'rb_obj_dummy', -1)
+
+    bo = @top_level.find_module_named 'BasicObject'
+
+    assert_equal 1, bo.method_list.length
+
+    new = bo.method_list.first
+
+    assert_equal 'new',   new.name
+    assert_equal :public, new.visibility
+  end
+
   def test_look_for_directives_in
     parser = util_parser ''
 

data/test/test_rdoc_parser_ruby.rb

@@ -22,6 +22,8 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     util_top_level
     @options = RDoc::Options.new
     @options.quiet = true
+    @options.option_parser = OptionParser.new
+
     @stats = RDoc::Stats.new 0
   end
 
@@ -30,6 +32,30 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     @tempfile2.close
   end
 
+  def test_get_symbol_or_name
+    util_parser "* & | + 5 / 4"
+
+    assert_equal '*', @parser.get_symbol_or_name
+
+    @parser.skip_tkspace
+
+    assert_equal '&', @parser.get_symbol_or_name
+
+    @parser.skip_tkspace
+
+    assert_equal '|', @parser.get_symbol_or_name
+
+    @parser.skip_tkspace
+
+    assert_equal '+', @parser.get_symbol_or_name
+
+    @parser.skip_tkspace
+    @parser.get_tk
+    @parser.skip_tkspace
+
+    assert_equal '/', @parser.get_symbol_or_name
+  end
+
   def test_look_for_directives_in_attr
     util_parser ""
 
@@ -52,6 +78,61 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal "# :attr_writer: my_method\n", comment
   end
 
+  def test_remove_private_comments
+    util_parser ''
+
+    comment = <<-EOS
+# This is text
+#--
+# this is private
+    EOS
+
+    expected = <<-EOS
+# This is text
+    EOS
+
+    @parser.remove_private_comments(comment)
+
+    assert_equal expected, comment
+  end
+
+  def test_remove_private_comments_rule
+    util_parser ''
+
+    comment = <<-EOS
+# This is text with a rule:
+# ---
+# this is also text
+    EOS
+
+    expected = comment.dup
+
+    @parser.remove_private_comments(comment)
+
+    assert_equal expected, comment
+  end
+
+  def test_remove_private_comments_toggle
+    util_parser ''
+
+    comment = <<-EOS
+# This is text
+#--
+# this is private
+#++
+# This is text again.
+    EOS
+
+    expected = <<-EOS
+# This is text
+# This is text again.
+    EOS
+
+    @parser.remove_private_comments(comment)
+
+    assert_equal expected, comment
+  end
+
   def test_look_for_directives_in_commented
     util_parser ""
 
@@ -70,9 +151,9 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
   def test_look_for_directives_in_enddoc
     util_parser ""
 
-    assert_throws :enddoc do
-      @parser.look_for_directives_in @top_level, "# :enddoc:\n"
-    end
+    @parser.look_for_directives_in @top_level, "# :enddoc:\n"
+
+    assert @top_level.done_documenting
   end
 
   def test_look_for_directives_in_main
@@ -105,13 +186,11 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     @top_level.stop_doc
     assert !@top_level.document_self
     assert !@top_level.document_children
-    assert !@top_level.force_documentation
 
     @parser.look_for_directives_in @top_level, "# :startdoc:\n"
 
     assert @top_level.document_self
     assert @top_level.document_children
-    assert @top_level.force_documentation
   end
 
   def test_look_for_directives_in_stopdoc
@@ -166,10 +245,11 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
 
     alas = @parser.parse_alias klass, RDoc::Parser::Ruby::NORMAL, tk, 'comment'
 
-    assert_equal 'bar',     alas.old_name
-    assert_equal 'next=',   alas.new_name
-    assert_equal klass,     alas.parent
-    assert_equal 'comment', alas.comment
+    assert_equal 'bar',      alas.old_name
+    assert_equal 'next=',    alas.new_name
+    assert_equal klass,      alas.parent
+    assert_equal 'comment',  alas.comment
+    assert_equal @top_level, alas.file
   end
 
   def test_parse_alias_singleton
@@ -182,11 +262,12 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
 
     alas = @parser.parse_alias klass, RDoc::Parser::Ruby::SINGLE, tk, 'comment'
 
-    assert_equal 'bar',     alas.old_name
-    assert_equal 'next=',   alas.new_name
-    assert_equal klass,     alas.parent
-    assert_equal 'comment', alas.comment
-    assert                  alas.singleton
+    assert_equal 'bar',      alas.old_name
+    assert_equal 'next=',    alas.new_name
+    assert_equal klass,      alas.parent
+    assert_equal 'comment',  alas.comment
+    assert_equal @top_level, alas.file
+    assert                   alas.singleton
   end
 
   def test_parse_alias_meta
@@ -219,6 +300,7 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     foo = klass.attributes.first
     assert_equal 'foo', foo.name
     assert_equal 'my attr', foo.comment
+    assert_equal @top_level, foo.file
   end
 
   def test_parse_attr_accessor
@@ -239,6 +321,7 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'foo', foo.name
     assert_equal 'RW', foo.rw
     assert_equal 'my attr', foo.comment
+    assert_equal @top_level, foo.file
 
     bar = klass.attributes.last
     assert_equal 'bar', bar.name
@@ -246,6 +329,21 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'my attr', bar.comment
   end
 
+  def test_parse_attr_accessor_nodoc
+    klass = RDoc::NormalClass.new 'Foo'
+    klass.parent = @top_level
+
+    comment = "##\n# my attr\n"
+
+    util_parser "attr_accessor :foo, :bar # :nodoc:"
+
+    tk = @parser.get_tk
+
+    @parser.parse_attr_accessor klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+
+    assert_equal 0, klass.attributes.length
+  end
+
   def test_parse_attr_accessor_writer
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
@@ -264,6 +362,7 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'foo', foo.name
     assert_equal 'W', foo.rw
     assert_equal "my attr", foo.comment
+    assert_equal @top_level, foo.file
 
     bar = klass.attributes.last
     assert_equal 'bar', bar.name
@@ -288,6 +387,7 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'foo', foo.name
     assert_equal 'RW', foo.rw
     assert_equal "my method", foo.comment
+    assert_equal @top_level, foo.file
   end
 
   def test_parse_meta_attr_accessor
@@ -307,6 +407,7 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'foo', foo.name
     assert_equal 'RW', foo.rw
     assert_equal 'my method', foo.comment
+    assert_equal @top_level, foo.file
   end
 
   def test_parse_meta_attr_named
@@ -326,6 +427,7 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'foo', foo.name
     assert_equal 'RW', foo.rw
     assert_equal 'my method', foo.comment
+    assert_equal @top_level, foo.file
   end
 
   def test_parse_meta_attr_reader
@@ -344,6 +446,7 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'foo', foo.name
     assert_equal 'R', foo.rw
     assert_equal 'my method', foo.comment
+    assert_equal @top_level, foo.file
   end
 
   def test_parse_meta_attr_writer
@@ -362,12 +465,13 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'foo', foo.name
     assert_equal 'W', foo.rw
     assert_equal "my method", foo.comment
+    assert_equal @top_level, foo.file
   end
 
   def test_parse_class
     comment = "##\n# my method\n"
 
-    util_parser 'class Foo; end'
+    util_parser "class Foo\nend"
 
     tk = @parser.get_tk
 
@@ -396,11 +500,12 @@ end
 
     blah = foo.method_list.first
     assert_equal 'Foo#blah', blah.full_name
+    assert_equal @top_level, blah.file
   end
 
   def test_parse_class_nested_superclass
-    foo = RDoc::NormalModule.new 'Foo'
-    foo.parent = @top_level
+    util_top_level
+    foo = @top_level.add_module RDoc::NormalModule, 'Foo'
 
     util_parser "class Bar < Super\nend"
 
@@ -415,7 +520,7 @@ end
   def test_parse_module
     comment = "##\n# my module\n"
 
-    util_parser 'module Foo; end'
+    util_parser "module Foo\nend"
 
     tk = @parser.get_tk
 
@@ -446,6 +551,10 @@ end
 class A
   class << B
   end
+  class << d = Object.new
+    def foo; end
+    alias bar foo
+  end
 end
     CODE
 
@@ -454,7 +563,40 @@ end
     @parser.parse_class @top_level, false, @parser.get_tk, ''
 
     assert_equal %w[A],    RDoc::TopLevel.classes.map { |c| c.full_name }
-    assert_equal %w[A::B], RDoc::TopLevel.modules.map { |c| c.full_name }
+    assert_equal %w[A::B A::d], RDoc::TopLevel.modules.map { |c| c.full_name }
+
+    # make sure method/alias was not added to enclosing class/module
+    a = RDoc::TopLevel.all_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']
+    assert d.remove_from_documentation?
+
+  end
+
+  # TODO this is really a Context#add_class test
+  def test_parse_class_object
+    code = <<-CODE
+module A
+  class B
+  end
+  class Object
+  end
+  class C < Object
+  end
+end
+    CODE
+
+    util_parser code
+
+    @parser.parse_module @top_level, false, @parser.get_tk, ''
+
+    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
   end
 
   def test_parse_class_mistaken_for_module
@@ -462,7 +604,7 @@ end
     # before Foo::Bar is encountered), but RDoc might encounter Foo::Bar
     # before Foo if they live in different files.
 
-    code = <<-EOF
+    code = <<-RUBY
 class Foo::Bar
 end
 
@@ -471,7 +613,7 @@ end
 
 class Foo
 end
-    EOF
+    RUBY
 
     util_parser code
 
@@ -557,18 +699,20 @@ EOF
     @parser.parse_comment klass, tk, comment
 
     foo = klass.attributes.first
-    assert_equal 'foo',     foo.name
-    assert_equal 'RW',      foo.rw
-    assert_equal 'my attr',   foo.comment
+    assert_equal 'foo',      foo.name
+    assert_equal 'RW',       foo.rw
+    assert_equal 'my attr',  foo.comment
+    assert_equal @top_level, foo.file
+
+    assert_equal nil,        foo.viewer
+    assert_equal true,       foo.document_children
+    assert_equal true,       foo.document_self
+    assert_equal false,      foo.done_documenting
+    assert_equal false,      foo.force_documentation
+    assert_equal klass,      foo.parent
+    assert_equal :public,    foo.visibility
+    assert_equal "\n",       foo.text
 
-    assert_equal nil,       foo.viewer
-    assert_equal true,      foo.document_children
-    assert_equal true,      foo.document_self
-    assert_equal false,     foo.done_documenting
-    assert_equal false,     foo.force_documentation
-    assert_equal klass,     foo.parent
-    assert_equal :public,   foo.visibility
-    assert_equal "\n",      foo.text
     assert_equal klass.current_section, foo.section
   end
 
@@ -585,8 +729,9 @@ EOF
     @parser.parse_comment klass, tk, comment
 
     foo = klass.method_list.first
-    assert_equal 'foo',     foo.name
-    assert_equal 'my method',   foo.comment
+    assert_equal 'foo',       foo.name
+    assert_equal 'my method', foo.comment
+    assert_equal @top_level,  foo.file
 
     assert_equal [],        foo.aliases
     assert_equal nil,       foo.block_params
@@ -614,9 +759,23 @@ EOF
     assert_equal stream, foo.token_stream
   end
 
+  def test_parse_constant_attrasgn
+    util_top_level
+
+    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
+
+    util_parser "A[k] = v"
+
+    tk = @parser.get_tk
+
+    @parser.parse_constant klass, tk, ''
+
+    assert klass.constants.empty?
+  end
+
   def test_parse_constant_alias
-    klass = RDoc::NormalClass.new 'Foo'
-    klass.parent = @top_level
+    util_top_level
+    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
     cB = klass.add_class RDoc::NormalClass, 'B'
 
     util_parser "A = B"
@@ -657,8 +816,9 @@ EOF
     @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 
     foo = klass.method_list.first
-    assert_equal 'foo', foo.name
+    assert_equal 'foo',       foo.name
     assert_equal 'my method', foo.comment
+    assert_equal @top_level,  foo.file
 
     assert_equal [],      foo.aliases
     assert_equal nil,     foo.block_params
@@ -706,8 +866,9 @@ EOF
     @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 
     foo = klass.method_list.first
-    assert_equal 'woo_hoo!', foo.name
+    assert_equal 'woo_hoo!',  foo.name
     assert_equal 'my method', foo.comment
+    assert_equal @top_level,  foo.file
   end
 
   def test_parse_meta_method_singleton
@@ -726,6 +887,7 @@ EOF
     assert_equal 'foo', foo.name
     assert_equal true, foo.singleton, 'singleton method'
     assert_equal 'my method', foo.comment
+    assert_equal @top_level,  foo.file
   end
 
   def test_parse_meta_method_singleton_name
@@ -744,6 +906,7 @@ EOF
     assert_equal 'woo_hoo!', foo.name
     assert_equal true, foo.singleton, 'singleton method'
     assert_equal 'my method', foo.comment
+    assert_equal @top_level,  foo.file
   end
 
   def test_parse_meta_method_string_name
@@ -759,6 +922,7 @@ EOF
     foo = klass.method_list.first
     assert_equal 'foo', foo.name
     assert_equal 'my method', foo.comment
+    assert_equal @top_level,  foo.file
   end
 
   def test_parse_meta_method_unknown
@@ -774,6 +938,7 @@ EOF
     foo = klass.method_list.first
     assert_equal 'unknown', foo.name
     assert_equal 'my method', foo.comment
+    assert_equal @top_level,  foo.file
   end
 
   def test_parse_method
@@ -789,8 +954,9 @@ EOF
     @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
 
     foo = klass.method_list.first
-    assert_equal 'foo',     foo.name
-    assert_equal 'my method',   foo.comment
+    assert_equal 'foo',       foo.name
+    assert_equal 'my method', foo.comment
+    assert_equal @top_level,  foo.file
 
     assert_equal [],        foo.aliases
     assert_equal nil,       foo.block_params
@@ -841,39 +1007,53 @@ EOF
     assert klass.aliases.empty?
   end
 
-  def test_parse_method_utf8
+  def test_parse_method_false
+    util_parser "def false.foo() :bar end"
+
+    tk = @parser.get_tk
+
+    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, ''
+
+    klass = RDoc::TopLevel.find_class_named 'FalseClass'
+
+    foo = klass.method_list.first
+    assert_equal 'foo', foo.name
+  end
+
+  def test_parse_method_funky
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
 
-    comment = "##\n# my method\n"
+    util_parser "def (blah).foo() :bar end"
 
-    method = "def ω() end"
+    tk = @parser.get_tk
 
-    assert_equal Encoding::UTF_8, method.encoding if defined? ::Encoding
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, ''
 
-    util_parser method
+    assert klass.method_list.empty?
+  end
+
+  def test_parse_method_gvar
+    util_parser "def $stdout.foo() :bar end"
 
     tk = @parser.get_tk
 
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, ''
 
-    omega = klass.method_list.first
-    assert_equal "def \317\211", omega.text
+    assert @top_level.method_list.empty?
   end
 
-  def test_parse_method_funky
+  def test_parse_method_internal_gvar
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
 
-    comment = "##\n# my method\n"
-
-    util_parser "def (blah).foo() :bar end"
+    util_parser "def foo() def $blah.bar() end end"
 
     tk = @parser.get_tk
 
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, ''
 
-    assert klass.method_list.empty?
+    assert_equal 1, klass.method_list.length
   end
 
   def test_parse_method_internal_ivar
@@ -902,33 +1082,43 @@ EOF
     assert_equal 1, klass.method_list.length
   end
 
+  def test_parse_method_nil
+    util_parser "def nil.foo() :bar end"
+
+    tk = @parser.get_tk
+
+    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, ''
+
+    klass = RDoc::TopLevel.find_class_named 'NilClass'
+
+    foo = klass.method_list.first
+    assert_equal 'foo', foo.name
+  end
+
   def test_parse_method_no_parens
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
 
-    comment = "##\n# my method\n"
-
-    util_parser "def foo arg1, arg2\nend"
+    util_parser "def foo arg1, arg2 = {}\nend"
 
     tk = @parser.get_tk
 
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, ''
 
     foo = klass.method_list.first
-    assert_equal '(arg1, arg2)', foo.params
+    assert_equal '(arg1, arg2 = {})', foo.params
+    assert_equal @top_level, foo.file
   end
 
   def test_parse_method_parameters_comment
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
 
-    comment = "##\n# my method\n"
-
     util_parser "def foo arg1, arg2 # some useful comment\nend"
 
     tk = @parser.get_tk
 
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, ''
 
     foo = klass.method_list.first
     assert_equal '(arg1, arg2)', foo.params
@@ -938,13 +1128,11 @@ EOF
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
 
-    comment = "##\n# my method\n"
-
     util_parser "def foo arg1, arg2, # some useful comment\narg3\nend"
 
     tk = @parser.get_tk
 
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, ''
 
     foo = klass.method_list.first
     assert_equal '(arg1, arg2, arg3)', foo.params
@@ -953,18 +1141,17 @@ EOF
   def test_parse_method_toplevel
     klass = @top_level
 
-    comment = "##\n# my method\n"
-
     util_parser "def foo arg1, arg2\nend"
 
     tk = @parser.get_tk
 
-    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, ''
 
     object = RDoc::TopLevel.find_class_named 'Object'
 
     foo = object.method_list.first
     assert_equal 'Object#foo', foo.full_name
+    assert_equal @top_level, foo.file
   end
 
   def test_parse_method_toplevel_class
@@ -982,9 +1169,39 @@ EOF
     assert_equal 'Object::foo', foo.full_name
   end
 
-  def test_parse_statements_class_if
-    comment = "##\n# my method\n"
+  def test_parse_method_true
+    util_parser "def true.foo() :bar end"
+
+    tk = @parser.get_tk
+
+    @parser.parse_method @top_level, RDoc::Parser::Ruby::NORMAL, tk, ''
+
+    klass = RDoc::TopLevel.find_class_named 'TrueClass'
+
+    foo = klass.method_list.first
+    assert_equal 'foo', foo.name
+  end
+
+  def test_parse_method_utf8
+    klass = RDoc::NormalClass.new 'Foo'
+    klass.parent = @top_level
+
+    method = "def ω() end"
+
+    assert_equal Encoding::UTF_8, method.encoding if
+      Object.const_defined? :Encoding
+
+    util_parser method
+
+    tk = @parser.get_tk
+
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, ''
+
+    omega = klass.method_list.first
+    assert_equal "def \317\211", omega.text
+  end
 
+  def test_parse_statements_class_if
     util_parser <<-CODE
 module Foo
   X = if TRUE then
@@ -1039,7 +1256,12 @@ end
   end
 
   def test_parse_statements_identifier_alias_method
-    content = "class Foo def foo() end; alias_method :foo2, :foo end"
+    content = <<-RUBY
+class Foo
+  def foo() end
+  alias_method :foo2, :foo
+end
+    RUBY
 
     util_parser content
 
@@ -1093,10 +1315,25 @@ EOF
     assert_equal 'foo4', foo4.name
     assert_equal 'foo', foo4.is_alias_for.name
 
-    assert_equal 'unknown', @top_level.classes.first.aliases[0].old_name
+    assert_equal 'unknown', @top_level.classes.first.external_aliases[0].old_name
   end
 
   def test_parse_statements_identifier_constant
+
+    sixth_constant = <<-EOF
+Class.new do
+  rule :file do
+    all(x, y, z) {
+      def value
+        find(:require).each {|r| require r.value }
+        find(:grammar).map {|g| g.value }
+      end
+      def min; end
+    }
+  end
+end
+    EOF
+
     content = <<-EOF
 class Foo
   FIRST_CONSTANT = 5
@@ -1118,6 +1355,10 @@ class Foo
   end
 
   FIFTH_CONSTANT = SECOND_CONSTANT.map { |element| element + 1 }
+
+  SIXTH_CONSTANT = #{sixth_constant}
+
+  SEVENTH_CONSTANT = proc { |i| begin i end }
 end
 EOF
 
@@ -1130,26 +1371,43 @@ EOF
     constant = constants[0]
     assert_equal 'FIRST_CONSTANT', constant.name
     assert_equal '5', constant.value
+    assert_equal @top_level, constant.file
 
     constant = constants[1]
     assert_equal 'SECOND_CONSTANT', constant.name
-    assert_equal '[      1,      2,      3   ]', constant.value
+    assert_equal "[\n1,\n2,\n3\n]", constant.value
+    assert_equal @top_level, constant.file
 
     constant = constants[2]
     assert_equal 'THIRD_CONSTANT', constant.name
-    assert_equal "{      :foo => 'bar',      :x => 'y'   }", constant.value
+    assert_equal "{\n:foo => 'bar',\n:x => 'y'\n}", constant.value
+    assert_equal @top_level, constant.file
 
     constant = constants[3]
     assert_equal 'FOURTH_CONSTANT', constant.name
-    assert_equal 'SECOND_CONSTANT.map do |element|     element + 1     element + 2   end', constant.value
+    assert_equal "SECOND_CONSTANT.map do |element|\nelement + 1\nelement + 2\nend", constant.value
+    assert_equal @top_level, constant.file
 
-    constant = constants.last
+    constant = constants[4]
     assert_equal 'FIFTH_CONSTANT', constant.name
     assert_equal 'SECOND_CONSTANT.map { |element| element + 1 }', constant.value
+    assert_equal @top_level, constant.file
+
+    # TODO: parse as class
+    constant = constants[5]
+    assert_equal 'SIXTH_CONSTANT', constant.name
+    assert_equal sixth_constant.lines.map(&:strip).join("\n"), constant.value
+    assert_equal @top_level, constant.file
+
+    # TODO: parse as method
+    constant = constants[6]
+    assert_equal 'SEVENTH_CONSTANT', constant.name
+    assert_equal "proc { |i| begin i end }", constant.value
+    assert_equal @top_level, constant.file
   end
 
   def test_parse_statements_identifier_attr
-    content = "class Foo; attr :foo; end"
+    content = "class Foo\nattr :foo\nend"
 
     util_parser content
 
@@ -1161,7 +1419,7 @@ EOF
   end
 
   def test_parse_statements_identifier_attr_accessor
-    content = "class Foo; attr_accessor :foo; end"
+    content = "class Foo\nattr_accessor :foo\nend"
 
     util_parser content
 
@@ -1173,7 +1431,7 @@ EOF
   end
 
   def test_parse_statements_identifier_include
-    content = "class Foo; include Bar; end"
+    content = "class Foo\ninclude Bar\nend"
 
     util_parser content
 
@@ -1185,24 +1443,24 @@ EOF
   end
 
   def test_parse_statements_identifier_module_function
-    content = "module Foo def foo() end; module_function :foo; end"
+    content = "module Foo\ndef foo() end\nmodule_function :foo\nend"
 
     util_parser content
 
     @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
 
     foo, s_foo = @top_level.modules.first.method_list
-    assert_equal 'foo', foo.name, 'instance method name'
+    assert_equal 'foo',    foo.name,       'instance method name'
     assert_equal :private, foo.visibility, 'instance method visibility'
-    assert_equal false, foo.singleton, 'instance method singleton'
+    assert_equal false,    foo.singleton,  'instance method singleton'
 
-    assert_equal 'foo', s_foo.name, 'module function name'
+    assert_equal 'foo',   s_foo.name,       'module function name'
     assert_equal :public, s_foo.visibility, 'module function visibility'
-    assert_equal true, s_foo.singleton, 'module function singleton'
+    assert_equal true,    s_foo.singleton,  'module function singleton'
   end
 
   def test_parse_statements_identifier_private
-    content = "class Foo private; def foo() end end"
+    content = "class Foo\nprivate\ndef foo() end\nend"
 
     util_parser content
 
@@ -1250,6 +1508,24 @@ end
     assert_equal 'A#b', m_b.full_name
   end
 
+  def test_parse_symbol_in_arg
+    util_parser ':blah "blah" "#{blah}" blah'
+
+    assert_equal 'blah', @parser.parse_symbol_in_arg
+
+    @parser.skip_tkspace
+
+    assert_equal 'blah', @parser.parse_symbol_in_arg
+
+    @parser.skip_tkspace
+
+    assert_equal nil, @parser.parse_symbol_in_arg
+
+    @parser.skip_tkspace
+
+    assert_equal nil, @parser.parse_symbol_in_arg
+  end
+
   def test_parse_top_level_statements_alias_method
     content = <<-CONTENT
 class A
@@ -1267,6 +1543,20 @@ end
     @parser.parse_statements @top_level
   end
 
+  def test_parse_yield_in_braces_with_parens
+    klass = RDoc::NormalClass.new 'Foo'
+    klass.parent = @top_level
+
+    util_parser "def foo\nn.times { |i| yield nth(i) }\nend"
+
+    tk = @parser.get_tk
+
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, ''
+
+    foo = klass.method_list.first
+    assert_equal 'nth(i)', foo.block_params
+  end
+
   def test_sanity_integer
     util_parser '1'
     assert_equal '1', @parser.get_tk.text
@@ -1287,7 +1577,6 @@ end
   # If you're writing code like this you're doing it wrong
 
   def test_sanity_interpolation_crazy
-    last_tk = nil
     util_parser '"#{"#{"a")}" if b}"'
 
     assert_equal '"#{"#{"a")}" if b}"', @parser.get_tk.text
@@ -1295,7 +1584,6 @@ end
   end
 
   def test_sanity_interpolation_curly
-    last_tk = nil
     util_parser '%{ #{} }'
 
     assert_equal '%{ #{} }', @parser.get_tk.text
@@ -1305,13 +1593,39 @@ end
   def test_sanity_interpolation_format
     util_parser '"#{stftime("%m-%d")}"'
 
-    while tk = @parser.get_tk do end
+    while @parser.get_tk do end
   end
 
   def test_sanity_symbol_interpolation
     util_parser ':"#{bar}="'
 
-    while tk = @parser.get_tk do end
+    while @parser.get_tk do end
+  end
+
+  def test_stopdoc_after_comment
+
+    util_parser <<-EOS
+      module Bar
+        # hello
+        module Foo
+          # :stopdoc:
+        end
+        # there
+        class Baz
+          # :stopdoc:
+        end
+      end
+    EOS
+
+    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
+
+    foo = @top_level.modules.first.modules.first
+    assert_equal 'Foo', foo.name
+    assert_equal 'hello', foo.comment
+
+    baz = @top_level.modules.first.classes.first
+    assert_equal 'Baz', baz.name
+    assert_equal 'there', baz.comment
   end
 
   def tk(klass, line, char, name, text)