rdoc 2.3.0 → 2.4.0

data/test/test_rdoc_include.rb

@@ -0,0 +1,17 @@
+require 'test/xref_test_case'
+
+class TestRDocInclude < XrefTestCase
+
+  def setup
+    super
+
+    @inc = RDoc::Include.new 'M1', 'comment'
+  end
+
+  def test_module
+    assert_equal @m1, @inc.module
+    assert_equal 'Unknown', RDoc::Include.new('Unknown', 'comment').module
+  end
+
+end
+

data/test/test_rdoc_markup.rb

@@ -18,12 +18,12 @@ class TestRDocMarkup < MiniTest::Unit::TestCase
 
     block = m.convert(str, mock)
 
-    if block != expected
+    unless block == expected then
       rows = (0...([expected.size, block.size].max)).collect{|i|
         [expected[i]||"nil", block[i]||"nil"]
       }
       printf "\n\n%35s %35s\n", "Expected", "Got"
-      rows.each {|e,g| printf "%35s %35s\n", e.dump, g.dump }
+      rows.each { |e,g| printf "%35s %35s\n", e.dump, g.dump }
     end
 
     assert_equal(expected, block)
@@ -385,6 +385,17 @@ class TestRDocMarkup < MiniTest::Unit::TestCase
 
   end
 
+  def test_list_verbatim
+    str = "* one\n    verb1\n    verb2\n* two\n"
+
+    line_groups(str,
+                [ "L1: ListStart\n",
+                  "L1: BULLET ListItem\none",
+                  "L1: Verbatim\n  verb1\n  verb2\n",
+                  "L1: BULLET ListItem\ntwo",
+                  "L1: ListEnd\n" ])
+  end
+
   def test_paragraph
     str = "paragraph\n\n*bold* paragraph\n"
 

data/test/test_rdoc_markup_to_html.rb

@@ -6,6 +6,7 @@ require 'rdoc/markup/to_html'
 class TestRDocMarkupToHtml < MiniTest::Unit::TestCase
 
   def setup
+    @m = RDoc::Markup.new
     @am = RDoc::Markup::AttributeManager.new
     @th = RDoc::Markup::ToHtml.new
   end
@@ -23,6 +24,27 @@ class TestRDocMarkupToHtml < MiniTest::Unit::TestCase
     assert_equal 'a/c.html',  gen('a.html',   'a/c.html')
   end
 
+  def test_list_verbatim
+    str = "* one\n    verb1\n    verb2\n* two\n"
+
+    expected = <<-EXPECTED
+<ul>
+<li>one
+
+<pre>
+  verb1
+  verb2
+</pre>
+</li>
+<li>two
+
+</li>
+</ul>
+    EXPECTED
+
+    assert_equal expected, @m.convert(str, @th)
+  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'")

data/test/test_rdoc_markup_to_html_crossref.rb

@@ -1,77 +1,16 @@
 require 'rubygems'
 require 'minitest/unit'
-require 'rdoc/generator'
-require 'rdoc/stats'
+require 'rdoc/rdoc'
 require 'rdoc/code_objects'
 require 'rdoc/markup/to_html_crossref'
-require 'rdoc/parser/ruby'
+require 'test/xref_test_case'
 
-require 'pathname'
-
-class TestRDocMarkupToHtmlCrossref < MiniTest::Unit::TestCase
-
-  XREF_DATA = <<-XREF_DATA
-class C1
-  def self.m
-  end
-
-  def m
-  end
-end
-
-class C2
-  class C3
-    def m
-    end
-
-    class H1
-      def m?
-      end
-    end
-  end
-end
-
-class C3
-  class H1
-  end
-
-  class H2
-  end
-end
-
-class C4
-  class C4
-  end
-end
-  XREF_DATA
+class TestRDocMarkupToHtmlCrossref < XrefTestCase
 
   def setup
-    RDoc::TopLevel.reset
-
-    RDoc::Generator::Method.reset
-    top_level = RDoc::TopLevel.new 'xref_data.rb'
-
-    options = RDoc::Options.new
-    options.quiet = true
-    options.inline_source = true # don't build HTML files
-
-    stats = RDoc::Stats.new 0
-
-    parser = RDoc::Parser::Ruby.new top_level, 'xref_data.rb', XREF_DATA,
-                                    options, stats
-    top_levels = []
-    top_levels.push parser.scan
+    super
 
-    files, classes = RDoc::Generator::Context.build_indices top_levels, options
-
-    @class_hash = {}
-
-    classes.each do |klass|
-      @class_hash[klass.name] = klass
-    end
-
-    @klass = @class_hash['C1']
-    @xref = RDoc::Markup::ToHtmlCrossref.new 'index.html', @klass, true
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'index.html', @c1, true
   end
 
   def assert_ref(path, ref)
@@ -84,15 +23,14 @@ end
   end
 
   def test_handle_special_CROSSREF_C2
-    @klass = @class_hash['C2']
-    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C2.html', @klass, true
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C2.html', @c2, true
 
     refute_ref '#m', '#m'
 
-    assert_ref 'C2/C3.html', 'C2::C3'
-    assert_ref 'C2/C3.html#M000003', 'C2::C3#m'
-    assert_ref 'C2/C3/H1.html', 'C3::H1'
-    assert_ref 'C4.html', 'C4'
+    assert_ref '../C2/C3.html', 'C2::C3'
+    assert_ref '../C2/C3.html#M000002', 'C2::C3#m'
+    assert_ref '../C2/C3/H1.html', 'C3::H1'
+    assert_ref '../C4.html', 'C4'
 
     # TODO there is a C3::H2 in the top-level namespace and RDoc should follow
     # constant scoping rules
@@ -101,100 +39,96 @@ end
   end
 
   def test_handle_special_CROSSREF_C2_C3
-    @klass = @class_hash['C2::C3']
-    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C2/C3.html', @klass, true
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C2/C3.html', @c2_c3, true
 
-    assert_ref 'C3.html#M000003', '#m'
+    assert_ref '../../C2/C3.html#M000002', '#m'
 
-    assert_ref 'C3.html', 'C3'
-    assert_ref 'C3.html#M000003', 'C3#m'
+    assert_ref '../../C2/C3.html', 'C3'
+    assert_ref '../../C2/C3.html#M000002', 'C3#m'
 
-    assert_ref 'C3/H1.html', 'H1'
-    assert_ref 'C3/H1.html', 'C3::H1'
+    assert_ref '../../C2/C3/H1.html', 'H1'
+    assert_ref '../../C2/C3/H1.html', 'C3::H1'
 
-    assert_ref '../C4.html', 'C4'
+    assert_ref '../../C4.html', 'C4'
 
     refute_ref 'C3::H2', 'C3::H2'
   end
 
   def test_handle_special_CROSSREF_C3
-    @klass = @class_hash['C3']
-    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C3.html', @klass, true
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C3.html', @c3, true
 
-    assert_ref 'C3.html', 'C3'
+    assert_ref '../C3.html', 'C3'
 
     refute_ref '#m',   '#m'
     refute_ref 'C3#m', 'C3#m'
 
-    assert_ref 'C3/H1.html', 'H1'
+    assert_ref '../C3/H1.html', 'H1'
 
-    assert_ref 'C3/H1.html', 'C3::H1'
-    assert_ref 'C3/H2.html', 'C3::H2'
+    assert_ref '../C3/H1.html', 'C3::H1'
+    assert_ref '../C3/H2.html', 'C3::H2'
 
-    assert_ref 'C4.html', 'C4'
+    assert_ref '../C4.html', 'C4'
   end
 
   def test_handle_special_CROSSREF_C4
-    @klass = @class_hash['C4']
-    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C4.html', @klass, true
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C4.html', @c4, true
 
     # C4 ref inside a C4 containing a C4 should resolve to the contained class
-    assert_ref 'C4/C4.html', 'C4'
+    assert_ref '../C4/C4.html', 'C4'
   end
 
   def test_handle_special_CROSSREF_C4_C4
-    @klass = @class_hash['C4::C4']
-    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C4/C4.html', @klass, true
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C4/C4.html', @c4_c4, true
 
     # A C4 reference inside a C4 class contained within a C4 class should
     # resolve to the inner C4 class.
-    assert_ref 'C4.html', 'C4'
+    assert_ref '../../C4/C4.html', 'C4'
   end
 
   def test_handle_special_CROSSREF_class
-    assert_ref 'classes/C1.html', 'C1'
+    assert_ref 'C1.html', 'C1'
     refute_ref 'H1', 'H1'
 
-    assert_ref 'classes/C2.html',       'C2'
-    assert_ref 'classes/C2/C3.html',    'C2::C3'
-    assert_ref 'classes/C2/C3/H1.html', 'C2::C3::H1'
+    assert_ref 'C2.html',       'C2'
+    assert_ref 'C2/C3.html',    'C2::C3'
+    assert_ref 'C2/C3/H1.html', 'C2::C3::H1'
 
-    assert_ref 'classes/C3.html',    '::C3'
-    assert_ref 'classes/C3/H1.html', '::C3::H1'
+    assert_ref 'C3.html',    '::C3'
+    assert_ref 'C3/H1.html', '::C3::H1'
 
-    assert_ref 'classes/C4/C4.html', 'C4::C4'
+    assert_ref 'C4/C4.html', 'C4::C4'
   end
 
   def test_handle_special_CROSSREF_file
-    assert_ref 'files/xref_data_rb.html', 'xref_data.rb'
+    assert_ref 'xref_data_rb.html', 'xref_data.rb'
   end
 
   def test_handle_special_CROSSREF_method
     refute_ref 'm', 'm'
-    assert_ref 'classes/C1.html#M000001', '#m'
+    assert_ref 'C1.html#M000000', '#m'
 
-    assert_ref 'classes/C1.html#M000001', 'C1#m'
-    assert_ref 'classes/C1.html#M000001', 'C1#m()'
-    assert_ref 'classes/C1.html#M000001', 'C1#m(*)'
+    assert_ref 'C1.html#M000000', 'C1#m'
+    assert_ref 'C1.html#M000000', 'C1#m()'
+    assert_ref 'C1.html#M000000', 'C1#m(*)'
 
-    assert_ref 'classes/C1.html#M000001', 'C1.m'
-    assert_ref 'classes/C1.html#M000001', 'C1.m()'
-    assert_ref 'classes/C1.html#M000001', 'C1.m(*)'
+    assert_ref 'C1.html#M000000', 'C1.m'
+    assert_ref 'C1.html#M000000', 'C1.m()'
+    assert_ref 'C1.html#M000000', 'C1.m(*)'
 
     # HACK should this work
     #assert_ref 'classes/C1.html#M000001', 'C1::m'
     #assert_ref 'classes/C1.html#M000001', 'C1::m()'
     #assert_ref 'classes/C1.html#M000001', 'C1::m(*)'
 
-    assert_ref 'classes/C2/C3.html#M000003', 'C2::C3#m'
+    assert_ref 'C2/C3.html#M000002', 'C2::C3#m'
 
-    assert_ref 'classes/C2/C3.html#M000003', 'C2::C3.m'
+    assert_ref 'C2/C3.html#M000002', 'C2::C3.m'
 
-    assert_ref 'classes/C2/C3/H1.html#M000004', 'C2::C3::H1#m?'
+    assert_ref 'C2/C3/H1.html#M000003', 'C2::C3::H1#m?'
 
-    assert_ref 'classes/C2/C3.html#M000003', '::C2::C3#m'
-    assert_ref 'classes/C2/C3.html#M000003', '::C2::C3#m()'
-    assert_ref 'classes/C2/C3.html#M000003', '::C2::C3#m(*)'
+    assert_ref 'C2/C3.html#M000002', '::C2::C3#m'
+    assert_ref 'C2/C3.html#M000002', '::C2::C3#m()'
+    assert_ref 'C2/C3.html#M000002', '::C2::C3#m(*)'
   end
 
   def test_handle_special_CROSSREF_no_ref
@@ -216,10 +150,11 @@ end
   end
 
   def test_handle_special_CROSSREF_special
-    assert_equal "<p>\n<a href=\"classes/C2/C3.html\">C2::C3</a>;method(*)\n</p>\n",
+    assert_equal "<p>\n<a href=\"C2/C3.html\">C2::C3</a>;method(*)\n</p>\n",
                  @xref.convert('C2::C3;method(*)')
   end
 
 end
 
 MiniTest::Unit.autorun
+

data/test/test_rdoc_normal_module.rb

@@ -0,0 +1,26 @@
+require 'test/xref_test_case'
+
+class TestRDocNormalModule < XrefTestCase
+
+  def setup
+    super
+
+    @mod = RDoc::NormalModule.new 'Mod'
+  end
+
+  def test_comment_equals
+    @mod.comment = '# comment 1'
+
+    assert_equal '# comment 1', @mod.comment
+
+    @mod.comment = '# comment 2'
+
+    assert_equal "# comment 1\n# ---\n# comment 2", @mod.comment
+  end
+
+  def test_module_eh
+    assert @mod.module?
+  end
+
+end
+

data/test/test_rdoc_parser_c.rb

@@ -298,6 +298,39 @@ Init_Foo(void) {
     assert_equal "VALUE\nother_function() ", code
   end
 
+  def test_find_body_define
+    content = <<-EOF
+/*
+ * a comment for other_function
+ */
+#define other_function rb_other_function
+
+/* */
+VALUE
+rb_other_function() {
+}
+
+void
+Init_Foo(void) {
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+
+    rb_define_method(foo, "my_method", other_function, 0);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+    other_function = klass.method_list.first
+
+    assert_equal 'my_method', other_function.name
+    assert_equal "  \n   a comment for other_function\n   \n     \n",
+                 other_function.comment
+    assert_equal '()', other_function.params
+
+    code = other_function.token_stream.first.text
+
+    assert_equal "#define other_function rb_other_function", code
+  end
+
   def test_define_method
     content = <<-EOF
 /*Method Comment! */

data/test/test_rdoc_parser_ruby.rb

@@ -17,7 +17,7 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     @tempfile2 = Tempfile.new self.class.name
     @filename2 = @tempfile2.path
 
-    util_toplevel
+    util_top_level
     @options = RDoc::Options.new
     @options.quiet = true
     @stats = RDoc::Stats.new 0
@@ -177,13 +177,12 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'Foo', foo.full_name
     assert_equal comment, foo.comment
   end
-  
+
   def test_parse_class_mistaken_for_module
-#
-# 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 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.
+
     code = <<-EOF
 class Foo::Bar
 end
@@ -193,13 +192,15 @@ end
 
 class Foo
 end
-EOF
+    EOF
 
     util_parser code
 
-    @parser.scan()
+    @parser.scan
+
+    assert_equal %w[Foo::Baz], RDoc::TopLevel.modules_hash.keys
+    assert_empty @top_level.modules
 
-    assert(@top_level.modules.empty?)
     foo = @top_level.classes.first
     assert_equal 'Foo', foo.full_name
 
@@ -211,24 +212,25 @@ EOF
   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 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.
+
     code = <<-EOF
 def Foo.bar
 end
 
 class Foo < IO
 end
-EOF
+    EOF
 
     util_parser code
 
-    @parser.scan()
+    @parser.scan
 
-    assert(@top_level.modules.empty?)
+    assert_empty RDoc::TopLevel.modules_hash
+    # HACK why does it fail?
+    #assert_empty @top_level.modules
 
     foo = @top_level.classes.first
     assert_equal 'Foo', foo.full_name
@@ -305,7 +307,7 @@ end
     assert_equal klass.current_section, foo.section
 
     stream = [
-      tk(:COMMENT, 1, 1, nil, "# File #{@top_level.file_absolute_name}, line 1"),
+      tk(:COMMENT, 1, 1, nil, "# File #{@top_level.absolute_name}, line 1"),
       RDoc::Parser::Ruby::NEWLINE_TOKEN,
       tk(:SPACE,      1, 1,  nil,   ''),
     ]
@@ -347,7 +349,7 @@ end
     assert_equal klass.current_section, foo.section
 
     stream = [
-      tk(:COMMENT, 1, 1, nil, "# File #{@top_level.file_absolute_name}, line 1"),
+      tk(:COMMENT, 1, 1, nil, "# File #{@top_level.absolute_name}, line 1"),
       RDoc::Parser::Ruby::NEWLINE_TOKEN,
       tk(:SPACE,      1, 1,  nil, ''),
       tk(:IDENTIFIER, 1, 0,  'add_my_method', 'add_my_method'),
@@ -430,6 +432,21 @@ end
     assert_equal comment, foo.comment
   end
 
+  def test_parse_meta_method_unknown
+    klass = RDoc::NormalClass.new 'Foo'
+    comment = "##\n# my method\n"
+
+    util_parser "add_my_method ('foo')"
+
+    tk = @parser.get_tk
+
+    @parser.parse_meta_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+
+    foo = klass.method_list.first
+    assert_equal 'unknown', foo.name
+    assert_equal comment, foo.comment
+  end
+
   def test_parse_method
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level
@@ -464,7 +481,7 @@ end
     assert_equal klass.current_section, foo.section
 
     stream = [
-      tk(:COMMENT, 1, 1, nil, "# File #{@top_level.file_absolute_name}, line 1"),
+      tk(:COMMENT, 1, 1, nil, "# File #{@top_level.absolute_name}, line 1"),
       RDoc::Parser::Ruby::NEWLINE_TOKEN,
       tk(:SPACE,      1, 1,  nil,   ''),
       tk(:DEF,        1, 0,  'def', 'def'),
@@ -482,6 +499,21 @@ end
     assert_equal stream, foo.token_stream
   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"
+
+    tk = @parser.get_tk
+
+    @parser.parse_method klass, RDoc::Parser::Ruby::NORMAL, tk, comment
+
+    assert klass.method_list.empty?
+  end
+
   def test_parse_statements_class_nested
     comment = "##\n# my method\n"
 
@@ -648,20 +680,6 @@ EOF
     assert_equal 'RW', foo.rw
   end
 
-  def test_parse_statements_identifier_extra_accessors
-    @options.extra_accessors = /^my_accessor$/
-
-    content = "class Foo; my_accessor :foo; end"
-
-    util_parser content
-
-    @parser.parse_statements @top_level, RDoc::Parser::Ruby::NORMAL, nil, ''
-
-    foo = @top_level.classes.first.attributes.first
-    assert_equal 'foo', foo.name
-    assert_equal '?', foo.rw
-  end
-
   def test_parse_statements_identifier_include
     content = "class Foo; include Bar; end"
 
@@ -740,7 +758,7 @@ EOF
                                       second_file_content, @options, @stats
   end
 
-  def util_toplevel
+  def util_top_level
     RDoc::TopLevel.reset
     @top_level = RDoc::TopLevel.new @filename
     @top_level2 = RDoc::TopLevel.new @filename2