From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/test/rdoc/test_rdoc_ri_driver.rb | 1436 +++++++++++++++++++++++++++++ 1 file changed, 1436 insertions(+) create mode 100644 jni/ruby/test/rdoc/test_rdoc_ri_driver.rb (limited to 'jni/ruby/test/rdoc/test_rdoc_ri_driver.rb') diff --git a/jni/ruby/test/rdoc/test_rdoc_ri_driver.rb b/jni/ruby/test/rdoc/test_rdoc_ri_driver.rb new file mode 100644 index 0000000..d0987a0 --- /dev/null +++ b/jni/ruby/test/rdoc/test_rdoc_ri_driver.rb @@ -0,0 +1,1436 @@ +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 + -- cgit v1.2.3