rdoc 2.2.1 → 2.3.0

data/lib/rdoc/stats.rb

@@ -1,4 +1,5 @@
 require 'rdoc'
+require 'thread'
 
 ##
 # Simple stats collector
@@ -9,45 +10,69 @@ class RDoc::Stats
   attr_reader :num_files
   attr_reader :num_methods
   attr_reader :num_modules
+  attr_reader :total_files
 
-  def initialize(verbosity = 1)
+  def initialize(total_files, verbosity = 1)
+    @lock = Mutex.new
+    
     @num_classes = 0
     @num_files   = 0
     @num_methods = 0
     @num_modules = 0
+    @total_files = total_files
 
     @start = Time.now
 
     @display = case verbosity
                when 0 then Quiet.new
-               when 1 then Normal.new
+               when 1 then Normal.new(total_files)
                else        Verbose.new
                end
   end
+  
+  def begin_adding(number_of_workers)
+    @display.begin_adding(number_of_workers)
+  end
 
   def add_alias(as)
-    @display.print_alias as
-    @num_methods += 1
+    @lock.synchronize do
+      @display.print_alias as
+      @num_methods += 1
+    end
   end
 
   def add_class(klass)
-    @display.print_class klass
-    @num_classes += 1
+    @lock.synchronize do
+      @display.print_class klass
+      @num_classes += 1
+    end
   end
 
   def add_file(file)
-    @display.print_file file
-    @num_files += 1
+    @lock.synchronize do
+      @display.print_file @num_files, file
+      @num_files += 1
+    end
   end
 
   def add_method(method)
-    @display.print_method method
-    @num_methods += 1
+    @lock.synchronize do
+      @display.print_method method
+      @num_methods += 1
+    end
   end
 
   def add_module(mod)
-    @display.print_module mod
-    @num_modules += 1
+    @lock.synchronize do
+      @display.print_module mod
+      @num_modules += 1
+    end
+  end
+  
+  def done_adding
+    @lock.synchronize do
+      @display.done_adding
+    end
   end
 
   def print
@@ -59,36 +84,71 @@ class RDoc::Stats
   end
 
   class Quiet
+    def begin_adding(*) end
     def print_alias(*) end
     def print_class(*) end
     def print_file(*) end
     def print_method(*) end
     def print_module(*) end
+    def done_adding(*) end
   end
-
+  
   class Normal
-    def print_alias(as)
-      print 'a'
+    def initialize(total_files)
+      @total_files = total_files
     end
-
-    def print_class(klass)
-      print 'C'
+    
+    def begin_adding(number_of_workers)
+      puts "Parsing sources with #{number_of_workers} thread(s)..."
     end
-
-    def print_file(file)
-      print "\n#{file}: "
+    
+    def print_file(files_so_far, filename)
+      progress_bar = sprintf("%3d%% [%2d/%2d]  ",
+                             100 * (files_so_far + 1) / @total_files,
+                             files_so_far + 1,
+                             @total_files)
+      
+      if $stdout.tty?
+        # Print a progress bar, but make sure it fits on a single line. Filename
+        # will be truncated if necessary.
+        terminal_width = (ENV['COLUMNS'] || 80).to_i
+        max_filename_size = terminal_width - progress_bar.size
+        if filename.size > max_filename_size
+          # Turn "some_long_filename.rb" to "...ong_filename.rb"
+          filename = filename[(filename.size - max_filename_size) .. -1]
+          filename[0..2] = "..."
+        end
+        
+        # Pad the line with whitespaces so that leftover output from the
+        # previous line doesn't show up.
+        line = "#{progress_bar}#{filename}"
+        padding = terminal_width - line.size
+        if padding > 0
+          line << (" " * padding)
+        end
+        
+        $stdout.print("#{line}\r")
+        $stdout.flush
+      else
+        puts "#{progress_bar} #{filename}"
+      end
     end
-
-    def print_method(method)
-      print 'm'
+    
+    def done_adding
+      puts "\n"
     end
 
-    def print_module(mod)
-      print 'M'
-    end
+    def print_alias(*) end
+    def print_class(*) end
+    def print_method(*) end
+    def print_module(*) end
   end
 
   class Verbose
+    def begin_adding(number_of_workers)
+      puts "Parsing sources with #{number_of_workers} thread(s)..."
+    end
+    
     def print_alias(as)
       puts "\t\talias #{as.new_name} #{as.old_name}"
     end
@@ -97,7 +157,7 @@ class RDoc::Stats
       puts "\tclass #{klass.full_name}"
     end
 
-    def print_file(file)
+    def print_file(files_so_far, file)
       puts file
     end
 
@@ -108,6 +168,9 @@ class RDoc::Stats
     def print_module(mod)
       puts "\tmodule #{mod.full_name}"
     end
+    
+    def done_adding
+    end
   end
 
 end

data/lib/rdoc/template.rb

@@ -53,8 +53,12 @@ class RDoc::TemplatePage
     b = binding
     template_include = ""
 
-    @templates.reverse_each do |template|
-      template_include = ERB.new(template).result b
+    @compiled_templates ||= @templates.map do |template|
+      ERB.new(template)
+    end
+    
+    @compiled_templates.reverse_each do |template|
+      template_include = template.result(b)
     end
 
     io.write template_include

data/test/test.ja.rdoc

@@ -0,0 +1,8 @@
+こんにちは！
+
+初めまして。アーロンと申します。
+
+どんな食べ物が好きですか？私はフランスの料理が大好きです。
+日本の料理も大好きです。
+
+食べ物を食べるのが大好きだけど、お皿を洗うのが大嫌いです。

data/test/test.ja.txt

@@ -0,0 +1,8 @@
+こんにちは！
+
+初めまして。アーロンと申します。
+
+どんな食べ物が好きですか？私はフランスの料理が大好きです。
+日本の料理も大好きです。
+
+食べ物を食べるのが大好きだけど、お皿を洗うのが大嫌いです。

data/test/test_attribute_manager.rb

@@ -1,15 +1,16 @@
-require 'test/unit'
+require 'rubygems'
+require 'minitest/unit'
 require 'rdoc/markup/attribute_manager'
 
-class TestAttributeManager < Test::Unit::TestCase
+class TestAttributeManager < MiniTest::Unit::TestCase
 
   def setup
     @am = RDoc::Markup::AttributeManager.new
     @klass = RDoc::Markup::AttributeManager
   end
-  
+
   def teardown
-    silently do 
+    silently do
       @klass.const_set(:MATCHING_WORD_PAIRS, {})
       @klass.const_set(:WORD_PAIR_MAP, {})
       @klass.const_set(:HTML_TAGS, {})
@@ -34,9 +35,9 @@ class TestAttributeManager < Test::Unit::TestCase
     assert_equal(4,word_pairs.size)
     assert(word_pairs.has_key?("x"))
   end
-  
+
   def test_add_invalid_word_pair
-    assert_raise ArgumentError do
+    assert_raises ArgumentError do
       @am.add_word_pair("<", "<", :TEST)
     end
   end
@@ -71,3 +72,5 @@ class TestAttributeManager < Test::Unit::TestCase
   end
 
 end
+
+MiniTest::Unit.autorun

data/test/test_rdoc_markup.rb

@@ -1,8 +1,9 @@
-require 'test/unit'
+require 'rubygems'
+require 'minitest/unit'
 require 'rdoc/markup'
 require 'rdoc/markup/to_test'
 
-class TestRDocMarkup < Test::Unit::TestCase
+class TestRDocMarkup < MiniTest::Unit::TestCase
 
   def basic_conv(str)
     sm = RDoc::Markup.new
@@ -611,3 +612,4 @@ class TestRDocMarkup < Test::Unit::TestCase
 
 end
 
+MiniTest::Unit.autorun

data/test/test_rdoc_markup_attribute_manager.rb

@@ -1,10 +1,14 @@
-require "test/unit"
+require "rubygems"
+require "minitest/unit"
 require "rdoc/markup/inline"
 require "rdoc/markup/to_html_crossref"
 
-class TestRDocMarkupAttributeManager < Test::Unit::TestCase
+class TestRDocMarkupAttributeManager < MiniTest::Unit::TestCase
 
   def setup
+    @orig_special = RDoc::Markup::AttributeManager::SPECIAL
+    RDoc::Markup::AttributeManager::SPECIAL.replace Hash.new
+
     @am = RDoc::Markup::AttributeManager.new
 
     @bold_on  = @am.changed_attribute_by_name([], [:BOLD])
@@ -28,6 +32,10 @@ class TestRDocMarkupAttributeManager < Test::Unit::TestCase
     @wombat_off   = @am.changed_attribute_by_name([:WOMBAT], [])
   end
 
+  def teardown
+    RDoc::Markup::AttributeManager::SPECIAL.replace @orig_special
+  end
+
   def crossref(text)
     crossref_bitmap = RDoc::Markup::Attribute.bitmap_for(:_SPECIAL_) |
                       RDoc::Markup::Attribute.bitmap_for(:CROSSREF)
@@ -53,7 +61,7 @@ class TestRDocMarkupAttributeManager < Test::Unit::TestCase
   end
 
   def test_add_word_pair_angle
-    e = assert_raise ArgumentError do
+    e = assert_raises ArgumentError do
       @am.add_word_pair '<', '>', 'angles'
     end
 
@@ -222,3 +230,5 @@ class TestRDocMarkupAttributeManager < Test::Unit::TestCase
   end
 
 end
+
+MiniTest::Unit.autorun

data/test/test_rdoc_markup_to_html.rb

@@ -1,14 +1,28 @@
-require 'test/unit'
+require 'rubygems'
+require 'minitest/unit'
 require 'rdoc/markup'
 require 'rdoc/markup/to_html'
 
-class TestRDocMarkupToHtml < Test::Unit::TestCase
+class TestRDocMarkupToHtml < MiniTest::Unit::TestCase
 
   def setup
     @am = RDoc::Markup::AttributeManager.new
     @th = RDoc::Markup::ToHtml.new
   end
 
+  def test_class_gen_relative_url
+    def gen(from, to)
+      RDoc::Markup::ToHtml.gen_relative_url from, to
+    end
+
+    assert_equal 'a.html',    gen('a.html',   'a.html')
+    assert_equal 'b.html',    gen('a.html',   'b.html')
+
+    assert_equal 'd.html',    gen('a/c.html', 'a/d.html')
+    assert_equal '../a.html', gen('a/c.html', 'a.html')
+    assert_equal 'a/c.html',  gen('a.html',   'a/c.html')
+  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'")
@@ -40,3 +54,5 @@ class TestRDocMarkupToHtml < Test::Unit::TestCase
   end
 
 end
+
+MiniTest::Unit.autorun

data/test/test_rdoc_markup_to_html_crossref.rb

@@ -1,288 +1,225 @@
-require 'test/unit'
+require 'rubygems'
+require 'minitest/unit'
 require 'rdoc/generator'
+require 'rdoc/stats'
+require 'rdoc/code_objects'
 require 'rdoc/markup/to_html_crossref'
+require 'rdoc/parser/ruby'
 
 require 'pathname'
 
-class TestRDocMarkupToHtmlCrossref < Test::Unit::TestCase
-
-  #
-  # This method parses a source file and returns a Hash mapping
-  # class names (Strings) to RDoc::Generator::Class instances
-  # (classes), which can be used to create RDoc::Markup::ToHtmlCrossref
-  # instances.  The unit tests only test against classes starting with
-  # Ref_, so this method only includes such classes in the Hash.
-  #
-  def create_class_hash
-    # The relative gem would help here...
-    # @source_file_name must be cleaned because rdoc does not deal
-    # well with paths containing "." or "..".
-    curr_file = Pathname.new(__FILE__)
-    @source_file_name = curr_file.dirname + "rdoc_markup_to_html_crossref_reference.rb"
-    @source_file_name = @source_file_name.cleanpath.to_s
+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
+
+  def setup
     RDoc::TopLevel.reset
 
-    # Reset RDoc::Generator::Method so that the method sequence number starts
-    # at 1, making the method sequence numbers for the methods in the Ref_
-    # predicable.
     RDoc::Generator::Method.reset
-    top_level = RDoc::TopLevel.new @source_file_name
-    
+    top_level = RDoc::TopLevel.new 'xref_data.rb'
+
     options = RDoc::Options.new
     options.quiet = true
-
-    # If this is false, then RDoc::Generator::Method will attempt to create
-    # an HTML file containing the method source code when being instantiated,
-    # which does not work in the context of this unit test.
-    #
-    # RDoc::Generator::Method needs to be refactored so that this does *not*
-    # happen as part of instantiation.
-    options.inline_source = true
+    options.inline_source = true # don't build HTML files
 
     stats = RDoc::Stats.new 0
 
-    parser = RDoc::Parser::Ruby.new(top_level,
-                                    @source_file_name,
-                                    IO.read(@source_file_name),
-                                    options,
-                                    stats)
+    parser = RDoc::Parser::Ruby.new top_level, 'xref_data.rb', XREF_DATA,
+                                    options, stats
     top_levels = []
-    top_levels.push(parser.scan())
+    top_levels.push parser.scan
 
-    files, classes = RDoc::Generator::Context.build_indices(top_levels, options)
+    files, classes = RDoc::Generator::Context.build_indices top_levels, options
+
+    @class_hash = {}
 
-    class_hash = {}
     classes.each do |klass|
-      if(klass.name.include?("Ref_"))
-        class_hash[klass.name] = klass
-      end
+      @class_hash[klass.name] = klass
     end
 
-    return class_hash
+    @klass = @class_hash['C1']
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'index.html', @klass, true
   end
 
-  #
-  # This method uses xref to cross-reference String reference and
-  # asserts that xref.convert(reference) is equal
-  # to String expected_result.
-  #
-  def verify_convert(xref, reference, expected_result)
-    # Everything converted in the tests will be within paragraph markup, so
-    # add paragraph markup to the expected result.
-    actual_expected_result = "<p>\n#{expected_result}\n</p>\n"
-
-    result = xref.convert(reference)
-
-    # RDoc::Markup::ToHtml word-wraps lines.  It is tricky to predict where
-    # a line will be wrapped except that it will happen on a space, so replace
-    # all newlines with spaces in order to not have to worry about this.
-    actual_expected_result.gsub!(/\n/, " ")
-    result.gsub!(/\n/, " ")
-
-    assert_equal actual_expected_result, result
+  def assert_ref(path, ref)
+    assert_equal "<p>\n<a href=\"#{path}\">#{ref}</a>\n</p>\n",
+                 @xref.convert(ref)
   end
 
-  #
-  # This method verifies that xref generates no cross-reference link for
-  # String reference.
-  #
-  def verify_no_crossref(xref, reference)
-    if(reference[0, 1] == "\\") # Remove the markup suppression character
-      expected_result = reference[1, reference.length() - 1]
-    else
-      expected_result = reference
-    end
+  def refute_ref(body, ref)
+    assert_equal "<p>\n#{body}\n</p>\n", @xref.convert(ref)
+  end
+
+  def test_handle_special_CROSSREF_C2
+    @klass = @class_hash['C2']
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C2.html', @klass, true
+
+    refute_ref '#m', '#m'
 
-    verify_convert(xref, reference, expected_result)
+    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'
+
+    # TODO there is a C3::H2 in the top-level namespace and RDoc should follow
+    # constant scoping rules
+    refute_ref 'C3::H2', 'C3::H2'
+    refute_ref 'H1', 'H1'
   end
 
-  #
-  # This method verifies that xref generates a cross-reference link to
-  # class_name (String) for String reference.
-  #
-  def verify_class_crossref(xref, reference, class_name)
-    class_file_name = class_name.gsub(/::/, "/")
-    
-    result = "<a href=\"../classes/#{class_file_name}.html\">#{reference}</a>"
+  def test_handle_special_CROSSREF_C2_C3
+    @klass = @class_hash['C2::C3']
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C2/C3.html', @klass, true
+
+    assert_ref 'C3.html#M000003', '#m'
+
+    assert_ref 'C3.html', 'C3'
+    assert_ref 'C3.html#M000003', 'C3#m'
+
+    assert_ref 'C3/H1.html', 'H1'
+    assert_ref 'C3/H1.html', 'C3::H1'
 
-    verify_convert xref, reference, result
+    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
+
+    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', 'C3::H1'
+    assert_ref 'C3/H2.html', 'C3::H2'
+
+    assert_ref 'C4.html', 'C4'
   end
 
-  #
-  # This method verifies that xref generates a cross-reference link to method
-  # method_seq (String, e.g, "M000001") in class_name (String) for
-  # String reference.
-  #
-  def verify_method_crossref(xref, reference, class_name, method_seq)
-    class_file_name = class_name.gsub(/::/, "/")
-    
-    result = "<a href=\"../classes/#{class_file_name}.html##{method_seq}\">#{reference}</a>"
-
-    verify_convert xref, reference, result
+  def test_handle_special_CROSSREF_C4
+    @klass = @class_hash['C4']
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C4.html', @klass, true
+
+    # C4 ref inside a C4 containing a C4 should resolve to the contained class
+    assert_ref 'C4/C4.html', 'C4'
   end
 
-  #
-  # This method verifies that xref generates a cross-reference link to
-  # file_name (String) for String reference.
-  #
-  def verify_file_crossref(xref, reference, file_name)
-    generated_document_path = Pathname.new("../files/#{file_name.gsub(/\./, '_')}.html").cleanpath.to_s
-    result = "<a href=\"#{generated_document_path}\">#{reference}</a>"
+  def test_handle_special_CROSSREF_C4_C4
+    @klass = @class_hash['C4::C4']
+    @xref = RDoc::Markup::ToHtmlCrossref.new 'classes/C4/C4.html', @klass, true
 
-    verify_convert xref, reference, result
+    # A C4 reference inside a C4 class contained within a C4 class should
+    # resolve to the inner C4 class.
+    assert_ref 'C4.html', 'C4'
   end
 
-  #
-  # This method verifies that several invariant cross-references are
-  # (or are not) generated.
-  #
-  def verify_invariant_crossrefs(xref)
-    # bogus does not exist and so no cross-reference should be generated.
-    verify_no_crossref xref, "bogus"
-    verify_no_crossref xref, "\\bogus"
-    
-    # Ref_Class1 is in the top-level namespace, and so a cross-reference always
-    # should be generated, unless markup is suppressed.
-    verify_class_crossref xref, "Ref_Class1", "Ref_Class1"
-    verify_no_crossref xref, "\\Ref_Class1"
-
-    # Ref_Class2 is in the top-level namespace, and so a cross-reference always
-    # should be generated for it and for its nested classes.
-    verify_class_crossref xref, "Ref_Class2", "Ref_Class2"
-    verify_class_crossref xref, "Ref_Class2::Ref_Class3", "Ref_Class2::Ref_Class3"
-    verify_method_crossref xref, "Ref_Class2::Ref_Class3#method", "Ref_Class2::Ref_Class3", "M000001"
-    verify_method_crossref xref, "Ref_Class2::Ref_Class3#method()", "Ref_Class2::Ref_Class3", "M000001"
-    verify_method_crossref xref, "Ref_Class2::Ref_Class3.method()", "Ref_Class2::Ref_Class3", "M000001"
-    verify_method_crossref xref, "Ref_Class2::Ref_Class3.method(*)", "Ref_Class2::Ref_Class3", "M000001"
-    verify_class_crossref xref, "Ref_Class2::Ref_Class3::Helper1", "Ref_Class2::Ref_Class3::Helper1"
-    verify_method_crossref xref, "Ref_Class2::Ref_Class3::Helper1#method?", "Ref_Class2::Ref_Class3::Helper1", "M000002"
-
-    # The hyphen character is not a valid class/method separator character, so
-    # rdoc just generates a class cross-reference (perhaps it should not
-    # generate anything?).
-    result = "<a href=\"../classes/Ref_Class2/Ref_Class3.html\">Ref_Class2::Ref_Class3</a>;method(*)"
-    verify_convert xref, "Ref_Class2::Ref_Class3;method(*)", result
-
-    # There is one Ref_Class3 nested in Ref_Class2 and one defined in the
-    # top-level namespace; regardless, ::Ref_Class3 (Ref_Class3 relative
-    # to the top-level namespace) always should generate a link to the
-    # top-level Ref_Class3 (unless of course cross-references are suppressed).
-    verify_class_crossref xref, "::Ref_Class3", "Ref_Class3"
-    verify_no_crossref xref, "\\::Ref_Class3"
-    verify_class_crossref xref, "::Ref_Class3::Helper1", "Ref_Class3::Helper1"
-    verify_class_crossref xref, "::Ref_Class3::Helper2", "Ref_Class3::Helper2"
-
-    #
-    # Ref_Class3::Helper1 does not have method method.
-    #
-    verify_no_crossref xref, "::Ref_Class3::Helper1#method"
-    verify_no_crossref xref, "\\::Ref_Class3::Helper1#method"
-
-    # References to Ref_Class2 relative to the top-level namespace always should
-    # generate links to Ref_Class2.
-    verify_method_crossref xref, "::Ref_Class2::Ref_Class3#method", "Ref_Class2::Ref_Class3", "M000001"
-    verify_method_crossref xref, "::Ref_Class2::Ref_Class3#method()", "Ref_Class2::Ref_Class3", "M000001"
-    verify_method_crossref xref, "::Ref_Class2::Ref_Class3#method(*)", "Ref_Class2::Ref_Class3", "M000001"
-    verify_class_crossref xref, "::Ref_Class2::Ref_Class3::Helper1", "Ref_Class2::Ref_Class3::Helper1"
-    verify_no_crossref xref, "\\::Ref_Class2::Ref_Class3#method(*)"
-
-    # Suppressing cross-references always should suppress the generation of
-    # links.
-    verify_no_crossref xref, "\\#method"
-    verify_no_crossref xref, "\\#method()"
-    verify_no_crossref xref, "\\#method(*)"
-
-    # Links never should be generated for words solely consisting of lowercase
-    # letters, because too many links would get generated by mistake (i.e., the
-    # word "new" always would be a link).
-    verify_no_crossref xref, "method"
-
-    # A link always should be generated for a file name.
-    verify_file_crossref xref, @source_file_name, @source_file_name
-
-    # References should be generated correctly for a class scoped within
-    # a class of the same name.
-    verify_class_crossref xref, "Ref_Class4::Ref_Class4", "Ref_Class4::Ref_Class4"
+  def test_handle_special_CROSSREF_class
+    assert_ref 'classes/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 'classes/C3.html',    '::C3'
+    assert_ref 'classes/C3/H1.html', '::C3::H1'
+
+    assert_ref 'classes/C4/C4.html', 'C4::C4'
   end
 
-  def test_handle_special_CROSSREF_no_underscore
-    class_hash = create_class_hash
-
-    # Note that we instruct the ToHtmlCrossref instance to show hashes so that
-    # an exception won't have to be made for words starting with a '#'.
-    # I'm also not convinced that the current behavior of the rdoc code
-    # is correct since, without this, it strips the leading # from all
-    # words, whether or not they end up as cross-references.
-    #
-    # After the behavior has been sorted out, this can be changed.
-    #
-    # Create a variety of RDoc::Markup::ToHtmlCrossref instances, for
-    # different classes, and test the cross-references generated by
-    # each.
-    klass = class_hash["Ref_Class1"]
-    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
-    verify_invariant_crossrefs xref
-    verify_class_crossref xref, "Ref_Class3", "Ref_Class3"
-    verify_no_crossref xref, "Ref_Class3#method"
-    verify_no_crossref xref, "#method"
-    verify_class_crossref xref, "Ref_Class3::Helper1", "Ref_Class3::Helper1"
-    verify_class_crossref xref, "Ref_Class3::Helper2", "Ref_Class3::Helper2"
-    verify_no_crossref xref, "Helper1"
-    verify_class_crossref xref, "Ref_Class4", "Ref_Class4"
-
-    klass = class_hash["Ref_Class2"]
-    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
-    verify_invariant_crossrefs xref
-    verify_class_crossref xref, "Ref_Class3", "Ref_Class2::Ref_Class3"
-    verify_method_crossref xref, "Ref_Class3#method", "Ref_Class2::Ref_Class3", "M000001"
-    verify_no_crossref xref, "#method"
-    verify_class_crossref xref, "Ref_Class3::Helper1", "Ref_Class2::Ref_Class3::Helper1"
-    verify_class_crossref xref, "Ref_Class4", "Ref_Class4"
-
-    # This one possibly is an rdoc bug...
-    # Ref_Class2 has a nested Ref_Class3, but
-    # Ref_Class2::Ref_Class3::Helper2 does not exist.
-    # On the other hand, there is a Ref_Class3::Helper2
-    # in the top-level namespace...  Should rdoc stop
-    # looking if it finds one class match?
-    verify_no_crossref xref, "Ref_Class3::Helper2"
-    verify_no_crossref xref, "Helper1"
-
-    klass = class_hash["Ref_Class2::Ref_Class3"]
-    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
-    verify_invariant_crossrefs xref
-    verify_class_crossref xref, "Ref_Class3", "Ref_Class2::Ref_Class3"
-    verify_method_crossref xref, "Ref_Class3#method", "Ref_Class2::Ref_Class3", "M000001"
-    verify_method_crossref xref, "#method", "Ref_Class2::Ref_Class3", "M000001"
-    verify_class_crossref xref, "Ref_Class3::Helper1", "Ref_Class2::Ref_Class3::Helper1"
-    verify_no_crossref xref, "Ref_Class3::Helper2"
-    verify_class_crossref xref, "Helper1", "Ref_Class2::Ref_Class3::Helper1"
-    verify_class_crossref xref, "Ref_Class4", "Ref_Class4"
-
-    klass = class_hash["Ref_Class3"]
-    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
-    verify_invariant_crossrefs xref
-    verify_class_crossref xref, "Ref_Class3", "Ref_Class3"
-    verify_no_crossref xref, "Ref_Class3#method"
-    verify_no_crossref xref, "#method"
-    verify_class_crossref xref, "Ref_Class3::Helper1", "Ref_Class3::Helper1"
-    verify_class_crossref xref, "Ref_Class3::Helper2", "Ref_Class3::Helper2"
-    verify_class_crossref xref, "Helper1", "Ref_Class3::Helper1"
-    verify_class_crossref xref, "Ref_Class4", "Ref_Class4"
-
-    klass = class_hash["Ref_Class4"]
-    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
-    verify_invariant_crossrefs xref
-    # A Ref_Class4 reference inside a Ref_Class4 class containing a
-    # Ref_Class4 class should resolve to the contained class.
-    verify_class_crossref xref, "Ref_Class4", "Ref_Class4::Ref_Class4"
-
-    klass = class_hash["Ref_Class4::Ref_Class4"]
-    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
-    verify_invariant_crossrefs xref
-    # A Ref_Class4 reference inside a Ref_Class4 class contained within
-    # a Ref_Class4 class should resolve to the inner Ref_Class4 class.
-    verify_class_crossref xref, "Ref_Class4", "Ref_Class4::Ref_Class4"
+  def test_handle_special_CROSSREF_file
+    assert_ref 'files/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 '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/C1.html#M000001', 'C1.m'
+    assert_ref 'classes/C1.html#M000001', 'C1.m()'
+    assert_ref 'classes/C1.html#M000001', '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 'classes/C2/C3.html#M000003', 'C2::C3.m'
+
+    assert_ref 'classes/C2/C3/H1.html#M000004', '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(*)'
+  end
+
+  def test_handle_special_CROSSREF_no_ref
+    assert_equal '', @xref.convert('')
+
+    refute_ref 'bogus', 'bogus'
+    refute_ref 'bogus', '\bogus'
+
+    refute_ref '#n',    '\#n'
+    refute_ref '#n()',  '\#n()'
+    refute_ref '#n(*)', '\#n(*)'
+
+    refute_ref 'C1',   '\C1'
+    refute_ref '::C3', '\::C3'
+
+    refute_ref '::C3::H1#n',    '::C3::H1#n'
+    refute_ref '::C3::H1#n(*)', '::C3::H1#n(*)'
+    refute_ref '::C3::H1#n',    '\::C3::H1#n'
+  end
+
+  def test_handle_special_CROSSREF_special
+    assert_equal "<p>\n<a href=\"classes/C2/C3.html\">C2::C3</a>;method(*)\n</p>\n",
+                 @xref.convert('C2::C3;method(*)')
+  end
+
 end
+
+MiniTest::Unit.autorun