rdoc 4.3.0 → 5.0.0.beta1

data/test/test_rdoc_require.rb

@@ -1,25 +0,0 @@
-require File.expand_path '../xref_test_case', __FILE__
-
-class TestRDocRequire < XrefTestCase
-
-  def setup
-    super
-
-    @req = RDoc::Require.new 'foo', 'comment'
-  end
-
-  def test_initialize
-    assert_equal 'foo', @req.name
-
-    req = RDoc::Require.new '"foo"', ''
-    assert_equal 'foo', @req.name
-
-    req = RDoc::Require.new '\'foo\'', ''
-    assert_equal 'foo', @req.name
-
-    req = RDoc::Require.new '|foo|', ''
-    assert_equal 'foo', @req.name, 'for fortran?'
-  end
-
-end
-

data/test/test_rdoc_ri_driver.rb

@@ -1,1436 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocRIDriver < RDoc::TestCase
-
-  def setup
-    super
-
-    @tmpdir = File.join Dir.tmpdir, "test_rdoc_ri_driver_#{$$}"
-    @home_ri = File.join @tmpdir, 'dot_ri'
-
-    FileUtils.mkdir_p @tmpdir
-    FileUtils.mkdir_p @home_ri
-
-    @orig_ri = ENV['RI']
-    @orig_home = ENV['HOME']
-    ENV['HOME'] = @tmpdir
-    ENV.delete 'RI'
-
-    @options = RDoc::RI::Driver.default_options
-    @options[:use_system] = false
-    @options[:use_site]   = false
-    @options[:use_home]   = false
-    @options[:use_gems]   = false
-
-    @options[:home]       = @tmpdir
-    @options[:use_stdout] = true
-    @options[:formatter]  = @RM::ToRdoc
-
-    @driver = RDoc::RI::Driver.new @options
-  end
-
-  def teardown
-    super
-
-    ENV['HOME'] = @orig_home
-    ENV['RI'] = @orig_ri
-    FileUtils.rm_rf @tmpdir
-  end
-
-  DUMMY_PAGER = ":;\n"
-
-  def with_dummy_pager
-    pager_env, ENV['RI_PAGER'] = ENV['RI_PAGER'], DUMMY_PAGER
-    yield
-  ensure
-    ENV['RI_PAGER'] = pager_env
-  end
-
-  def test_self_dump
-    util_store
-
-    out, = capture_io do
-      RDoc::RI::Driver.dump @store1.cache_path
-    end
-
-    assert_match %r%:class_methods%,    out
-    assert_match %r%:modules%,          out
-    assert_match %r%:instance_methods%, out
-    assert_match %r%:ancestors%,        out
-  end
-
-  def test_add_also_in_empty
-    out = @RM::Document.new
-
-    @driver.add_also_in out, []
-
-    assert_empty out
-  end
-
-  def test_add_also_in
-    util_multi_store
-    @store1.type = :system
-    @store2.type = :home
-
-    out = @RM::Document.new
-
-    @driver.add_also_in out, [@store1, @store2]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Paragraph.new('Also found in:'),
-      @RM::Verbatim.new("ruby core", "\n",
-                        "~/.rdoc", "\n"))
-
-    assert_equal expected, out
-  end
-
-  def test_add_class
-    util_multi_store
-
-    out = @RM::Document.new
-
-    @driver.add_class out, 'Bar', [@cBar]
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, 'Bar < Foo'),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_from
-    util_store
-    @store1.type = :system
-
-    out = @RM::Document.new
-
-    @driver.add_from out, @store1
-
-    expected = @RM::Document.new @RM::Paragraph.new("(from ruby core)")
-
-    assert_equal expected, out
-  end
-
-  def test_add_extends
-    util_store
-
-    out = @RM::Document.new
-
-    @driver.add_extends out, [[[@cFooExt], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Extended by:"),
-      @RM::Paragraph.new("Ext (from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Extend thingy"),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_extension_modules_empty
-    out = @RM::Document.new
-
-    @driver.add_extension_modules out, 'Includes', []
-
-    assert_empty out
-  end
-
-  def test_add_extension_modules_many
-    util_store
-
-    out = @RM::Document.new
-
-    enum = RDoc::Include.new 'Enumerable', nil
-    @cFoo.add_include enum
-
-    @driver.add_extension_modules out, 'Includes', [[[@cFooInc, enum], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("(from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Inc"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Include thingy"),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new("Enumerable", "\n"))
-
-    assert_equal expected, out
-  end
-
-  def test_add_extension_modules_many_no_doc
-    util_store
-
-    out = @RM::Document.new
-
-    enum = RDoc::Include.new 'Enumerable', nil
-    @cFoo.add_include enum
-    @cFooInc.instance_variable_set :@comment, ''
-
-    @driver.add_extension_modules out, 'Includes', [[[@cFooInc, enum], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("(from #{@store1.friendly_path})"),
-      @RM::Verbatim.new("Inc", "\n",
-                        "Enumerable", "\n"))
-
-    assert_equal expected, out
-  end
-
-  def test_add_extension_modules_one
-    util_store
-
-    out = @RM::Document.new
-
-    @driver.add_extension_modules out, 'Includes', [[[@cFooInc], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("Inc (from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Include thingy"),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_includes
-    util_store
-
-    out = @RM::Document.new
-
-    @driver.add_includes out, [[[@cFooInc], @store1]]
-
-    expected = @RM::Document.new(
-      @RM::Rule.new(1),
-      @RM::Heading.new(1, "Includes:"),
-      @RM::Paragraph.new("Inc (from #{@store1.friendly_path})"),
-      @RM::BlankLine.new,
-      @RM::Paragraph.new("Include thingy"),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Foo::Bar#blah'
-
-    expected =
-      doc(
-        head(1, 'Foo::Bar#blah'),
-        blank_line,
-        para('(from ~/.rdoc)'),
-        head(3, 'Implementation from Bar'),
-        rule(1),
-        verb("blah(5) => 5\n",
-             "blah(6) => 6\n"),
-        rule(1),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_attribute
-    util_store
-
-    out = doc
-
-    @driver.add_method out, 'Foo::Bar#attr'
-
-    expected =
-      doc(
-        head(1, 'Foo::Bar#attr'),
-        blank_line,
-        para('(from ~/.rdoc)'),
-        rule(1),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_inherited
-    util_multi_store
-
-    out = doc
-
-    @driver.add_method out, 'Bar#inherit'
-
-    expected =
-      doc(
-        head(1, 'Bar#inherit'),
-        blank_line,
-        para('(from ~/.rdoc)'),
-        head(3, 'Implementation from Foo'),
-        rule(1),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_overriden
-    util_multi_store
-
-    out = doc
-
-    @driver.add_method out, 'Bar#override'
-
-    expected =
-      doc(
-        head(1, 'Bar#override'),
-        blank_line,
-        para("(from #{@store2.path})"),
-        rule(1),
-        blank_line,
-        para('must be displayed'),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_documentation
-    util_store
-
-    out = doc()
-
-    missing = RDoc::AnyMethod.new nil, 'missing'
-    @cFoo.add_method missing
-
-    @driver.add_method_documentation out, @cFoo
-
-    expected =
-      doc(
-        head(1, 'Foo#inherit'),
-        blank_line,
-        para('(from ~/.rdoc)'),
-        rule(1),
-        blank_line,
-        blank_line,
-        head(1, 'Foo#override'),
-        blank_line,
-        para('(from ~/.rdoc)'),
-        rule(1),
-        blank_line,
-        para('must not be displayed in Bar#override'),
-        blank_line,
-        blank_line)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_list
-    out = @RM::Document.new
-
-    @driver.add_method_list out, %w[new parse], 'Class methods'
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, 'Class methods:'),
-      @RM::BlankLine.new,
-      @RM::Verbatim.new('new'),
-      @RM::Verbatim.new('parse'),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_list_interative
-    @options[:interactive] = true
-    driver = RDoc::RI::Driver.new @options
-
-    out = @RM::Document.new
-
-    driver.add_method_list out, %w[new parse], 'Class methods'
-
-    expected = @RM::Document.new(
-      @RM::Heading.new(1, 'Class methods:'),
-      @RM::BlankLine.new,
-      @RM::IndentedParagraph.new(2, 'new, parse'),
-      @RM::BlankLine.new)
-
-    assert_equal expected, out
-  end
-
-  def test_add_method_list_none
-    out = @RM::Document.new
-
-    @driver.add_method_list out, [], 'Class'
-
-    assert_equal @RM::Document.new, out
-  end
-
-  def test_ancestors_of
-    util_ancestors_store
-
-    assert_equal %w[X Mixin Object Foo], @driver.ancestors_of('Foo::Bar')
-  end
-
-  def test_classes
-    util_multi_store
-
-    expected = {
-      'Ambiguous' => [@store1, @store2],
-      'Bar'       => [@store2],
-      'Ext'       => [@store1],
-      'Foo'       => [@store1, @store2],
-      'Foo::Bar'  => [@store1],
-      'Foo::Baz'  => [@store1, @store2],
-      'Inc'       => [@store1],
-    }
-
-    classes = @driver.classes
-
-    assert_equal expected.keys.sort, classes.keys.sort
-
-    expected.each do |klass, stores|
-      assert_equal stores, classes[klass].sort_by { |store| store.path },
-                   "mismatch for #{klass}"
-    end
-  end
-
-  def test_class_document
-    util_store
-
-    tl1 = @store1.add_file 'one.rb'
-    tl2 = @store1.add_file 'two.rb'
-
-    @cFoo.add_comment 'one', tl1
-    @cFoo.add_comment 'two', tl2
-
-    @store1.save_class @cFoo
-
-    found = [
-      [@store1, @store1.load_class(@cFoo.full_name)]
-    ]
-
-    extends  = [[[@cFooExt], @store1]]
-    includes = [[[@cFooInc], @store1]]
-
-    out = @driver.class_document @cFoo.full_name, found, [], includes, extends
-
-    expected = @RM::Document.new
-    @driver.add_class expected, 'Foo', []
-    @driver.add_includes expected, includes
-    @driver.add_extends  expected, extends
-    @driver.add_from expected, @store1
-    expected << @RM::Rule.new(1)
-
-    doc = @RM::Document.new(@RM::Paragraph.new('one'))
-    doc.file = 'one.rb'
-    expected.push doc
-    expected << @RM::BlankLine.new
-    doc = @RM::Document.new(@RM::Paragraph.new('two'))
-    doc.file = 'two.rb'
-    expected.push doc
-
-    expected << @RM::Rule.new(1)
-    expected << @RM::Heading.new(1, 'Instance methods:')
-    expected << @RM::BlankLine.new
-    expected << @RM::Verbatim.new('inherit')
-    expected << @RM::Verbatim.new('override')
-    expected << @RM::BlankLine.new
-
-    assert_equal expected, out
-  end
-
-  def test_complete
-    store = RDoc::RI::Store.new @home_ri
-    store.cache[:ancestors] = {
-      'Foo'      => %w[Object],
-      'Foo::Bar' => %w[Object],
-    }
-    store.cache[:class_methods] = {
-      'Foo' => %w[bar]
-    }
-    store.cache[:instance_methods] = {
-      'Foo' => %w[Bar]
-    }
-    store.cache[:modules] = %w[
-      Foo
-      Foo::Bar
-    ]
-
-    @driver.stores = [store]
-
-    assert_equal %w[Foo         ], @driver.complete('F')
-    assert_equal %w[    Foo::Bar], @driver.complete('Foo::B')
-
-    assert_equal %w[Foo#Bar],           @driver.complete('Foo#'),   'Foo#'
-    assert_equal %w[Foo#Bar  Foo::bar], @driver.complete('Foo.'),   'Foo.'
-    assert_equal %w[Foo::Bar Foo::bar], @driver.complete('Foo::'),  'Foo::'
-
-    assert_equal %w[         Foo::bar], @driver.complete('Foo::b'), 'Foo::b'
-  end
-
-  def test_complete_ancestor
-    util_ancestors_store
-
-    assert_equal %w[Foo::Bar#i_method], @driver.complete('Foo::Bar#')
-
-    assert_equal %w[Foo::Bar#i_method Foo::Bar::c_method Foo::Bar::new],
-                 @driver.complete('Foo::Bar.')
-  end
-
-  def test_complete_classes
-    util_store
-
-    assert_equal %w[                       ], @driver.complete('[')
-    assert_equal %w[                       ], @driver.complete('[::')
-    assert_equal %w[Foo                    ], @driver.complete('F')
-    assert_equal %w[Foo:: Foo::Bar Foo::Baz], @driver.complete('Foo::')
-    assert_equal %w[      Foo::Bar Foo::Baz], @driver.complete('Foo::B')
-  end
-
-  def test_complete_multistore
-    util_multi_store
-
-    assert_equal %w[Bar], @driver.complete('B')
-    assert_equal %w[Foo], @driver.complete('F')
-    assert_equal %w[Foo::Bar Foo::Baz], @driver.complete('Foo::B')
-  end
-
-  def test_display
-    doc = @RM::Document.new(
-            @RM::Paragraph.new('hi'))
-
-    out, = capture_io do
-      @driver.display doc
-    end
-
-    assert_equal "hi\n", out
-  end
-
-  def test_display_class
-    util_store
-
-    out, = capture_io do
-      @driver.display_class 'Foo::Bar'
-    end
-
-    assert_match %r%^= Foo::Bar%, out
-    assert_match %r%^\(from%, out
-
-    assert_match %r%^= Class methods:%, out
-    assert_match %r%^  new%, out
-    assert_match %r%^= Instance methods:%, out
-    assert_match %r%^  blah%, out
-    assert_match %r%^= Attributes:%, out
-    assert_match %r%^  attr_accessor attr%, out
-
-    assert_equal 1, out.scan(/-\n/).length
-
-    refute_match %r%Foo::Bar#blah%, out
-  end
-
-  def test_display_class_all
-    util_store
-
-    @driver.show_all = true
-
-    out, = capture_io do
-      @driver.display_class 'Foo::Bar'
-    end
-
-    assert_match %r%^= Foo::Bar%, out
-    assert_match %r%^\(from%, out
-
-    assert_match %r%^= Class methods:%, out
-    assert_match %r%^  new%, out
-    assert_match %r%^= Instance methods:%, out
-    assert_match %r%^  blah%, out
-    assert_match %r%^= Attributes:%, out
-    assert_match %r%^  attr_accessor attr%, out
-
-    assert_equal 6, out.scan(/-\n/).length
-
-    assert_match %r%Foo::Bar#blah%, out
-  end
-
-  def test_display_class_ambiguous
-    util_multi_store
-
-    out, = capture_io do
-      @driver.display_class 'Ambiguous'
-    end
-
-    assert_match %r%^= Ambiguous < Object$%, out
-  end
-
-  def test_display_class_multi_no_doc
-    util_multi_store
-
-    out, = capture_io do
-      @driver.display_class 'Foo::Baz'
-    end
-
-    assert_match %r%^= Foo::Baz%, out
-    assert_match %r%-\n%, out
-    assert_match %r%Also found in:%, out
-    assert_match %r%#{Regexp.escape @home_ri}%, out
-    assert_match %r%#{Regexp.escape @home_ri2}%, out
-  end
-
-  def test_display_class_superclass
-    util_multi_store
-
-    out, = capture_io do
-      @driver.display_class 'Bar'
-    end
-
-    assert_match %r%^= Bar < Foo%, out
-  end
-
-  def test_display_class_module
-    util_store
-
-    out, = capture_io do
-      @driver.display_class 'Inc'
-    end
-
-    assert_match %r%^= Inc$%, out
-  end
-
-  def test_display_class_page
-    out, = capture_io do
-      @driver.display_class 'ruby:README'
-    end
-
-    assert_empty out
-  end
-
-  def test_display_method
-    util_store
-
-    out, = capture_io do
-      @driver.display_method 'Foo::Bar#blah'
-    end
-
-    assert_match %r%Foo::Bar#blah%, out
-    assert_match %r%blah.5%,        out
-    assert_match %r%blah.6%,        out
-  end
-
-  def test_display_method_attribute
-    util_store
-
-    out, = capture_io do
-      @driver.display_method 'Foo::Bar#attr'
-    end
-
-    assert_match %r%Foo::Bar#attr%, out
-    refute_match %r%Implementation from%, out
-  end
-
-  def test_display_method_inherited
-    util_multi_store
-
-    out, = capture_io do
-      @driver.display_method 'Bar#inherit'
-    end
-
-    assert_match %r%^= Bar#inherit%, out
-    assert_match %r%^=== Implementation from Foo%, out
-  end
-
-  def test_display_method_overriden
-    util_multi_store
-
-    out, = capture_io do
-      @driver.display_method 'Bar#override'
-    end
-
-    refute_match %r%must not be displayed%, out
-  end
-
-  def test_display_name_not_found_class
-    util_store
-
-    out, = capture_io do
-      assert_equal false, @driver.display_name('Foo::B')
-    end
-
-    expected = <<-EXPECTED
-Foo::B not found, maybe you meant:
-
-Foo::Bar
-Foo::Baz
-    EXPECTED
-
-    assert_equal expected, out
-  end
-
-  def test_display_name_not_found_method
-    util_store
-
-    out, = capture_io do
-      assert_equal false, @driver.display_name('Foo::Bar#b')
-    end
-
-    expected = <<-EXPECTED
-Foo::Bar#b not found, maybe you meant:
-
-Foo::Bar#blah
-Foo::Bar#bother
-    EXPECTED
-
-    assert_equal expected, out
-  end
-
-  def test_display_name_not_found_special
-    util_store
-
-    assert_raises RDoc::RI::Driver::NotFoundError do
-      assert_equal false, @driver.display_name('Set#[]')
-    end
-  end
-
-  def test_display_method_params
-    util_store
-
-    out, = capture_io do
-      @driver.display_method 'Foo::Bar#bother'
-    end
-
-    assert_match %r%things.*stuff%, out
-  end
-
-  def test_display_page
-    util_store
-
-    out, = capture_io do
-      @driver.display_page 'home:README.rdoc'
-    end
-
-    assert_match %r%= README%, out
-  end
-
-  def test_display_page_add_extension
-    util_store
-
-    out, = capture_io do
-      @driver.display_page 'home:README'
-    end
-
-    assert_match %r%= README%, out
-  end
-
-  def test_display_page_ambiguous
-    util_store
-
-    other = @store1.add_file 'README.md'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      doc(
-        head(1, 'README.md'),
-        para('This is the other README'))
-
-    @store1.save_page other
-
-    out, = capture_io do
-      @driver.display_page 'home:README'
-    end
-
-    assert_match %r%= README pages in ~/\.rdoc%, out
-    assert_match %r%README\.rdoc%,               out
-    assert_match %r%README\.md%,                 out
-  end
-
-  def test_display_page_extension
-    util_store
-
-    other = @store1.add_file 'README.EXT'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      doc(
-        head(1, 'README.EXT'),
-        para('This is the other README'))
-
-    @store1.save_page other
-
-    out, = capture_io do
-      @driver.display_page 'home:README.EXT'
-    end
-
-    assert_match 'other README', out
-  end
-
-  def test_display_page_ignore_directory
-    util_store
-
-    other = @store1.add_file 'doc/globals.rdoc'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      doc(
-        head(1, 'globals.rdoc'),
-        para('Globals go here'))
-
-    @store1.save_page other
-
-    out, = capture_io do
-      @driver.display_page 'home:globals'
-    end
-
-    assert_match %r%= globals\.rdoc%, out
-  end
-
-  def test_display_page_missing
-    util_store
-
-    out, = capture_io do
-      @driver.display_page 'home:missing'
-    end
-
-    out, = capture_io do
-      @driver.display_page_list @store1
-    end
-
-    assert_match %r%= Pages in ~/\.rdoc%, out
-    assert_match %r%README\.rdoc%,        out
-  end
-
-  def test_display_page_list
-    util_store
-
-    other = @store1.add_file 'OTHER.rdoc'
-    other.parser = RDoc::Parser::Simple
-    other.comment =
-      doc(
-        head(1, 'OTHER'),
-        para('This is OTHER'))
-
-    @store1.save_page other
-
-    out, = capture_io do
-      @driver.display_page_list @store1
-    end
-
-    assert_match %r%= Pages in ~/\.rdoc%, out
-    assert_match %r%README\.rdoc%,        out
-    assert_match %r%OTHER\.rdoc%,         out
-  end
-
-  def test_expand_class
-    util_store
-
-    assert_equal 'Foo',       @driver.expand_class('F')
-    assert_equal 'Foo::Bar',  @driver.expand_class('F::Bar')
-
-    assert_raises RDoc::RI::Driver::NotFoundError do
-      @driver.expand_class 'F::B'
-    end
-  end
-
-  def test_expand_name
-    util_store
-
-    assert_equal '.b',        @driver.expand_name('b')
-    assert_equal 'Foo',       @driver.expand_name('F')
-    assert_equal 'Foo::Bar#', @driver.expand_name('F::Bar#')
-
-    e = assert_raises RDoc::RI::Driver::NotFoundError do
-      @driver.expand_name 'Z'
-    end
-
-    assert_equal 'Z', e.name
-
-    @driver.stores << RDoc::Store.new(nil, :system)
-
-    assert_equal 'ruby:README', @driver.expand_name('ruby:README')
-    assert_equal 'ruby:',       @driver.expand_name('ruby:')
-
-    e = assert_raises RDoc::RI::Driver::NotFoundError do
-      @driver.expand_name 'nonexistent_gem:'
-    end
-
-    assert_equal 'nonexistent_gem', e.name
-  end
-
-  def test_find_methods
-    util_store
-
-    items = []
-
-    @driver.find_methods 'Foo::Bar.' do |store, klass, ancestor, types, method|
-      items << [store, klass, ancestor, types, method]
-    end
-
-    expected = [
-      [@store1, 'Foo::Bar', 'Foo::Bar', :both, nil],
-    ]
-
-    assert_equal expected, items
-  end
-
-  def test_find_methods_method
-    util_store
-
-    items = []
-
-    @driver.find_methods '.blah' do |store, klass, ancestor, types, method|
-      items << [store, klass, ancestor, types, method]
-    end
-
-    expected = [
-      [@store1, 'Ambiguous', 'Ambiguous', :both, 'blah'],
-      [@store1, 'Ext',       'Ext',       :both, 'blah'],
-      [@store1, 'Foo',       'Foo',       :both, 'blah'],
-      [@store1, 'Foo::Bar',  'Foo::Bar',  :both, 'blah'],
-      [@store1, 'Foo::Baz',  'Foo::Baz',  :both, 'blah'],
-      [@store1, 'Inc',       'Inc',       :both, 'blah'],
-    ]
-
-    assert_equal expected, items
-  end
-
-  def test_filter_methods
-    util_multi_store
-
-    name = 'Bar#override'
-
-    found = @driver.load_methods_matching name
-
-    sorted = @driver.filter_methods found, name
-
-    expected = [[@store2, [@override]]]
-
-    assert_equal expected, sorted
-  end
-
-  def test_filter_methods_not_found
-    util_multi_store
-
-    name = 'Bar#inherit'
-
-    found = @driver.load_methods_matching name
-
-    sorted = @driver.filter_methods found, name
-
-    assert_equal found, sorted
-  end
-
-  def test_find_store
-    @driver.stores << RDoc::Store.new(nil,              :system)
-    @driver.stores << RDoc::Store.new('doc/gem-1.0/ri', :gem)
-
-    assert_equal 'ruby',    @driver.find_store('ruby')
-    assert_equal 'gem-1.0', @driver.find_store('gem-1.0')
-    assert_equal 'gem-1.0', @driver.find_store('gem')
-
-    e = assert_raises RDoc::RI::Driver::NotFoundError do
-      @driver.find_store 'nonexistent'
-    end
-
-    assert_equal 'nonexistent', e.name
-  end
-
-  def test_formatter
-    tty = Object.new
-    def tty.tty?() true; end
-
-    @options.delete :use_stdout
-    @options.delete :formatter
-
-    driver = RDoc::RI::Driver.new @options
-
-    assert_instance_of @RM::ToAnsi, driver.formatter(tty)
-
-    assert_instance_of @RM::ToBs, driver.formatter(StringIO.new)
-
-    driver.instance_variable_set :@paging, true
-
-    assert_instance_of @RM::ToBs, driver.formatter(StringIO.new)
-  end
-
-  def test_in_path_eh
-    path = ENV['PATH']
-
-    test_path = File.expand_path '..', __FILE__
-
-    temp_dir do |dir|
-      nonexistent = File.join dir, 'nonexistent'
-      refute @driver.in_path?(nonexistent)
-
-      ENV['PATH'] = test_path
-
-      assert @driver.in_path?(File.basename(__FILE__))
-    end
-  ensure
-    ENV['PATH'] = path
-  end
-
-  def test_method_type
-    assert_equal :both,     @driver.method_type(nil)
-    assert_equal :both,     @driver.method_type('.')
-    assert_equal :instance, @driver.method_type('#')
-    assert_equal :class,    @driver.method_type('::')
-  end
-
-  def test_name_regexp
-    assert_equal %r%^RDoc::AnyMethod#new$%,
-                 @driver.name_regexp('RDoc::AnyMethod#new')
-
-    assert_equal %r%^RDoc::AnyMethod::new$%,
-                 @driver.name_regexp('RDoc::AnyMethod::new')
-
-    assert_equal %r%^RDoc::AnyMethod(#|::)new$%,
-                 @driver.name_regexp('RDoc::AnyMethod.new')
-
-    assert_equal %r%^Hash(#|::)\[\]$%,
-                 @driver.name_regexp('Hash.[]')
-
-    assert_equal %r%^Hash::\[\]$%,
-                 @driver.name_regexp('Hash::[]')
-  end
-
-  def test_list_known_classes
-    util_store
-
-    out, = capture_io do
-      @driver.list_known_classes
-    end
-
-    assert_equal "Ambiguous\nExt\nFoo\nFoo::Bar\nFoo::Baz\nInc\n", out
-  end
-
-  def test_list_known_classes_name
-    util_store
-
-    out, = capture_io do
-      @driver.list_known_classes %w[F I]
-    end
-
-    assert_equal "Foo\nFoo::Bar\nFoo::Baz\nInc\n", out
-  end
-
-  def test_list_methods_matching
-    util_store
-
-    assert_equal %w[
-        Foo::Bar#attr
-        Foo::Bar#blah
-        Foo::Bar#bother
-        Foo::Bar::new
-      ],
-      @driver.list_methods_matching('Foo::Bar.').sort
-  end
-
-  def test_list_methods_matching_inherit
-    util_multi_store
-
-    assert_equal %w[
-        Bar#baz
-        Bar#inherit
-        Bar#override
-      ],
-      @driver.list_methods_matching('Bar.').sort
-  end
-
-  def test_list_methods_matching_regexp
-    util_store
-
-    index = RDoc::AnyMethod.new nil, '[]'
-    index.record_location @top_level
-    @cFoo.add_method index
-    @store1.save_method @cFoo, index
-
-    c_index = RDoc::AnyMethod.new nil, '[]'
-    c_index.singleton = true
-    c_index.record_location @top_level
-    @cFoo.add_method c_index
-    @store1.save_method @cFoo, c_index
-
-    @store1.save_cache
-
-    assert_equal %w[Foo#[]], @driver.list_methods_matching('Foo#[]')
-    assert_equal %w[Foo::[]], @driver.list_methods_matching('Foo::[]')
-  end
-
-  def test_load_method
-    util_store
-
-    method = @driver.load_method(@store1, :instance_methods, 'Foo', '#',
-                                 'inherit')
-
-    assert_equal @inherit, method
-  end
-
-  def test_load_method_inherited
-    util_multi_store
-
-    method = @driver.load_method(@store2, :instance_methods, 'Bar', '#',
-                                 'inherit')
-
-    assert_equal nil, method
-  end
-
-  def test_load_methods_matching
-    util_store
-
-    expected = [[@store1, [@inherit]]]
-
-    assert_equal expected, @driver.load_methods_matching('Foo#inherit')
-
-    expected = [[@store1, [@blah]]]
-
-    assert_equal expected, @driver.load_methods_matching('.blah')
-
-    assert_empty @driver.load_methods_matching('.b')
-  end
-
-  def test_load_methods_matching_inherited
-    util_multi_store
-
-    expected = [[@store1, [@inherit]]]
-
-    assert_equal expected, @driver.load_methods_matching('Bar#inherit')
-  end
-
-  def test_load_method_missing
-    util_store
-
-    FileUtils.rm @store1.method_file 'Foo', '#inherit'
-
-    method = @driver.load_method(@store1, :instance_methods, 'Foo', '#',
-                                 'inherit')
-
-    assert_equal '(unknown)#inherit', method.full_name
-  end
-
-  def _test_page # this test doesn't do anything anymore :(
-    @driver.use_stdout = false
-
-    with_dummy_pager do
-      @driver.page do |io|
-        skip "couldn't find a standard pager" if io == $stdout
-
-        assert @driver.paging?
-      end
-    end
-
-    refute @driver.paging?
-  end
-
-  # this test is too fragile. Perhaps using Process.spawn will make this
-  # reliable
-  def _test_page_in_presence_of_child_status
-    skip 'this test hangs on travis-ci.org' if ENV['CI']
-    @driver.use_stdout = false
-
-    with_dummy_pager do
-      @driver.page do |io|
-        refute_equal $stdout, io
-        assert @driver.paging?
-      end
-    end
-  end
-
-  def test_page_stdout
-    @driver.use_stdout = true
-
-    @driver.page do |io|
-      assert_equal $stdout, io
-    end
-
-    refute @driver.paging?
-  end
-
-  def test_parse_name_method
-    klass, type, meth = @driver.parse_name 'foo'
-
-    assert_equal '',    klass, 'foo class'
-    assert_equal '.',   type,  'foo type'
-    assert_equal 'foo', meth,  'foo method'
-
-    klass, type, meth = @driver.parse_name '#foo'
-
-    assert_equal '',    klass, '#foo class'
-    assert_equal '#',   type,  '#foo type'
-    assert_equal 'foo', meth,  '#foo method'
-
-    klass, type, meth = @driver.parse_name '::foo'
-
-    assert_equal '',    klass, '::foo class'
-    assert_equal '::',  type,  '::foo type'
-    assert_equal 'foo', meth,  '::foo method'
-  end
-
-  def test_parse_name_page
-    klass, type, meth = @driver.parse_name 'ruby:README'
-
-    assert_equal 'ruby',   klass, 'ruby project'
-    assert_equal ':',      type,  'ruby type'
-    assert_equal 'README', meth,  'ruby page'
-
-    klass, type, meth = @driver.parse_name 'ruby:'
-
-    assert_equal 'ruby',   klass, 'ruby project'
-    assert_equal ':',      type,  'ruby type'
-    assert_equal nil,      meth,  'ruby page'
-  end
-
-  def test_parse_name_page_extenson
-    klass, type, meth = @driver.parse_name 'ruby:README.EXT'
-
-    assert_equal 'ruby',      klass, 'ruby project'
-    assert_equal ':',         type,  'ruby type'
-    assert_equal 'README.EXT', meth,  'ruby page'
-  end
-
-  def test_parse_name_single_class
-    klass, type, meth = @driver.parse_name 'Foo'
-
-    assert_equal 'Foo', klass, 'Foo class'
-    assert_equal nil,   type,  'Foo type'
-    assert_equal nil,   meth,  'Foo method'
-
-    klass, type, meth = @driver.parse_name 'Foo#'
-
-    assert_equal 'Foo', klass, 'Foo# class'
-    assert_equal '#',   type,  'Foo# type'
-    assert_equal nil,   meth,  'Foo# method'
-
-    klass, type, meth = @driver.parse_name 'Foo::'
-
-    assert_equal 'Foo', klass, 'Foo:: class'
-    assert_equal '::',  type,  'Foo:: type'
-    assert_equal nil,   meth,  'Foo:: method'
-
-    klass, type, meth = @driver.parse_name 'Foo.'
-
-    assert_equal 'Foo', klass, 'Foo. class'
-    assert_equal '.',   type,  'Foo. type'
-    assert_equal nil,   meth,  'Foo. method'
-
-    klass, type, meth = @driver.parse_name 'Foo#Bar'
-
-    assert_equal 'Foo', klass, 'Foo#Bar class'
-    assert_equal '#',   type,  'Foo#Bar type'
-    assert_equal 'Bar', meth,  'Foo#Bar method'
-
-    klass, type, meth = @driver.parse_name 'Foo.Bar'
-
-    assert_equal 'Foo', klass, 'Foo.Bar class'
-    assert_equal '.',   type,  'Foo.Bar type'
-    assert_equal 'Bar', meth,  'Foo.Bar method'
-
-    klass, type, meth = @driver.parse_name 'Foo::bar'
-
-    assert_equal 'Foo', klass, 'Foo::bar class'
-    assert_equal '::',  type,  'Foo::bar type'
-    assert_equal 'bar', meth,  'Foo::bar method'
-  end
-
-  def test_parse_name_namespace
-    klass, type, meth = @driver.parse_name 'Foo::Bar'
-
-    assert_equal 'Foo::Bar', klass, 'Foo::Bar class'
-    assert_equal nil,        type,  'Foo::Bar type'
-    assert_equal nil,        meth,  'Foo::Bar method'
-
-    klass, type, meth = @driver.parse_name 'Foo::Bar#'
-
-    assert_equal 'Foo::Bar', klass, 'Foo::Bar# class'
-    assert_equal '#',        type,  'Foo::Bar# type'
-    assert_equal nil,        meth,  'Foo::Bar# method'
-
-    klass, type, meth = @driver.parse_name 'Foo::Bar#baz'
-
-    assert_equal 'Foo::Bar', klass, 'Foo::Bar#baz class'
-    assert_equal '#',        type,  'Foo::Bar#baz type'
-    assert_equal 'baz',      meth,  'Foo::Bar#baz method'
-  end
-
-  def test_parse_name_special
-    specials = %w[
-      %
-      &
-      *
-      +
-      +@
-      -
-      -@
-      /
-      <
-      <<
-      <=
-      <=>
-      ==
-      ===
-      =>
-      =~
-      >
-      >>
-      []
-      []=
-      ^
-      `
-      |
-      ~
-      ~@
-    ]
-
-    specials.each do |special|
-      parsed = @driver.parse_name special
-
-      assert_equal ['', '.', special], parsed
-    end
-  end
-
-  def _test_setup_pager # this test doesn't do anything anymore :(
-    @driver.use_stdout = false
-
-    pager = with_dummy_pager do @driver.setup_pager end
-
-    skip "couldn't find a standard pager" unless pager
-
-    assert @driver.paging?
-  ensure
-    pager.close if pager
-  end
-
-  def util_ancestors_store
-    store1 = RDoc::RI::Store.new @home_ri
-    store1.cache[:ancestors] = {
-      'Foo'      => %w[Object],
-      'Foo::Bar' => %w[Foo],
-    }
-    store1.cache[:class_methods] = {
-      'Foo'      => %w[c_method new],
-      'Foo::Bar' => %w[new],
-    }
-    store1.cache[:instance_methods] = {
-      'Foo' => %w[i_method],
-    }
-    store1.cache[:modules] = %w[
-      Foo
-      Foo::Bar
-    ]
-
-    store2 = RDoc::RI::Store.new @home_ri
-    store2.cache[:ancestors] = {
-      'Foo'    => %w[Mixin Object],
-      'Mixin'  => %w[],
-      'Object' => %w[X Object],
-      'X'      => %w[Object],
-    }
-    store2.cache[:class_methods] = {
-      'Foo'    => %w[c_method new],
-      'Mixin'  => %w[],
-      'X'      => %w[],
-      'Object' => %w[],
-    }
-    store2.cache[:instance_methods] = {
-      'Foo'   => %w[i_method],
-      'Mixin' => %w[],
-    }
-    store2.cache[:modules] = %w[
-      Foo
-      Mixin
-      Object
-      X
-    ]
-
-    @driver.stores = store1, store2
-  end
-
-  def util_multi_store
-    util_store
-
-    @home_ri2 = "#{@home_ri}2"
-    @store2 = RDoc::RI::Store.new @home_ri2
-
-    @top_level = @store2.add_file 'file.rb'
-
-    # as if seen in a namespace like class Ambiguous::Other
-    @mAmbiguous = @top_level.add_module RDoc::NormalModule, 'Ambiguous'
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-
-    @cBar = @top_level.add_class RDoc::NormalClass, 'Bar', 'Foo'
-    @cFoo_Baz = @cFoo.add_class RDoc::NormalClass, 'Baz'
-
-    @baz = @cBar.add_method RDoc::AnyMethod.new(nil, 'baz')
-    @baz.record_location @top_level
-
-    @override = @cBar.add_method RDoc::AnyMethod.new(nil, 'override')
-    @override.comment = 'must be displayed'
-    @override.record_location @top_level
-
-    @store2.save
-
-    @driver.stores = [@store1, @store2]
-  end
-
-  def util_store
-    @store1 = RDoc::RI::Store.new @home_ri, :home
-
-    @top_level = @store1.add_file 'file.rb'
-
-    @readme = @store1.add_file 'README.rdoc'
-    @readme.parser = RDoc::Parser::Simple
-    @readme.comment =
-      doc(
-        head(1, 'README'),
-        para('This is a README'))
-
-    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
-    @mExt = @top_level.add_module RDoc::NormalModule, 'Ext'
-    @mInc = @top_level.add_module RDoc::NormalModule, 'Inc'
-    @cAmbiguous = @top_level.add_class RDoc::NormalClass, 'Ambiguous'
-
-    doc = @RM::Document.new @RM::Paragraph.new('Extend thingy')
-    @cFooExt = @cFoo.add_extend RDoc::Extend.new('Ext', doc)
-    @cFooExt.record_location @top_level
-    doc = @RM::Document.new @RM::Paragraph.new('Include thingy')
-    @cFooInc = @cFoo.add_include RDoc::Include.new('Inc', doc)
-    @cFooInc.record_location @top_level
-
-    @cFoo_Bar = @cFoo.add_class RDoc::NormalClass, 'Bar'
-
-    @blah = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'blah')
-    @blah.call_seq = "blah(5) => 5\nblah(6) => 6\n"
-    @blah.record_location @top_level
-
-    @bother = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'bother')
-    @bother.block_params = "stuff"
-    @bother.params = "(things)"
-    @bother.record_location @top_level
-
-    @new = @cFoo_Bar.add_method RDoc::AnyMethod.new nil, 'new'
-    @new.record_location @top_level
-    @new.singleton = true
-
-    @attr = @cFoo_Bar.add_attribute RDoc::Attr.new nil, 'attr', 'RW', ''
-    @attr.record_location @top_level
-
-    @cFoo_Baz = @cFoo.add_class RDoc::NormalClass, 'Baz'
-    @cFoo_Baz.record_location @top_level
-
-    @inherit = @cFoo.add_method RDoc::AnyMethod.new(nil, 'inherit')
-    @inherit.record_location @top_level
-
-    # overriden by Bar in multi_store
-    @overriden = @cFoo.add_method RDoc::AnyMethod.new(nil, 'override')
-    @overriden.comment = 'must not be displayed in Bar#override'
-    @overriden.record_location @top_level
-
-    @store1.save
-
-    @driver.stores = [@store1]
-  end
-
-end
-