rdoc 3.12.2 → 4.0.0.preview2

data/test/{test_rdoc_ri_store.rb → test_rdoc_store.rb}

@@ -1,6 +1,6 @@
-require 'rdoc/test_case'
+require File.expand_path '../xref_test_case', __FILE__
 
-class TestRDocRIStore < RDoc::TestCase
+class TestRDocStore < XrefTestCase
 
   OBJECT_ANCESTORS = defined?(::BasicObject) ? %w[BasicObject] : []
 
@@ -10,7 +10,11 @@ class TestRDocRIStore < RDoc::TestCase
     @tmpdir = File.join Dir.tmpdir, "test_rdoc_ri_store_#{$$}"
     @s = RDoc::RI::Store.new @tmpdir
 
-    @top_level = RDoc::TopLevel.new 'file.rb'
+    @top_level = @s.add_file 'file.rb'
+
+    @page = @s.add_file 'README.txt'
+    @page.parser = RDoc::Parser::Simple
+    @page.comment = RDoc::Comment.new 'This is a page', @page
 
     @klass = @top_level.add_class RDoc::NormalClass, 'Object'
     @klass.add_comment 'original', @top_level
@@ -19,14 +23,27 @@ class TestRDocRIStore < RDoc::TestCase
     @cmeth.singleton = true
     @cmeth.record_location @top_level
 
+    @meth_comment = RDoc::Comment.new 'method comment'
+    @meth_comment.location = @top_level
+
     @meth = RDoc::AnyMethod.new nil, 'method'
     @meth.record_location @top_level
+    @meth.comment = @meth_comment
 
     @meth_bang = RDoc::AnyMethod.new nil, 'method!'
     @meth_bang.record_location @top_level
 
+    @meth_bang_alias = RDoc::Alias.new nil, 'method!', 'method_bang', ''
+    @meth_bang_alias.record_location @top_level
+
+    @meth_bang.add_alias @meth_bang_alias, @klass
+
+    @attr_comment = RDoc::Comment.new 'attribute comment'
+    @attr_comment.location = @top_level
+
     @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
     @attr.record_location @top_level
+    @attr.comment = @attr_comment
 
     @klass.add_method @cmeth
     @klass.add_method @meth
@@ -42,6 +59,9 @@ class TestRDocRIStore < RDoc::TestCase
 
     @nest_klass.add_method @nest_meth
     @nest_klass.add_include @nest_incl
+
+    @mod = @top_level.add_module RDoc::NormalModule, 'Mod'
+    @mod.record_location @top_level
   end
 
   def teardown
@@ -57,8 +77,9 @@ class TestRDocRIStore < RDoc::TestCase
     s.chomp
   end
 
-  def assert_cache imethods, cmethods, attrs, modules, ancestors = {}
-    imethods ||= { 'Object' => %w[method method!] }
+  def assert_cache imethods, cmethods, attrs, modules,
+                   ancestors = {}, pages = [], main = nil, title = nil
+    imethods ||= { 'Object' => %w[method method! method_bang] }
     cmethods ||= { 'Object' => %w[cmethod] }
     attrs    ||= { 'Object' => ['attr_accessor attr'] }
 
@@ -72,6 +93,9 @@ class TestRDocRIStore < RDoc::TestCase
       :encoding         => nil,
       :instance_methods => imethods,
       :modules          => modules,
+      :pages            => pages,
+      :main             => main,
+      :title            => title,
     }
 
     @s.save_cache
@@ -91,6 +115,55 @@ class TestRDocRIStore < RDoc::TestCase
     refute File.exist?(path), "#{path} exists"
   end
 
+  def test_add_file
+    top_level = @store.add_file 'file.rb'
+
+    assert_kind_of RDoc::TopLevel, top_level
+    assert_equal @store, top_level.store
+    assert_equal 'file.rb', top_level.name
+    assert_includes @store.all_files, top_level
+
+    assert_same top_level, @store.add_file('file.rb')
+    refute_same top_level, @store.add_file('other.rb')
+  end
+
+  def test_add_file_relative
+    top_level = @store.add_file 'path/file.rb', 'file.rb'
+
+    assert_kind_of RDoc::TopLevel, top_level
+    assert_equal @store, top_level.store
+
+    assert_equal 'path/file.rb', top_level.absolute_name
+    assert_equal 'file.rb',      top_level.relative_name
+
+    assert_includes @store.all_files, top_level
+
+    assert_same top_level, @store.add_file('file.rb')
+    refute_same top_level, @store.add_file('other.rb')
+  end
+
+  def test_all_classes_and_modules
+    expected = %w[
+      C1 C2 C2::C3 C2::C3::H1 C3 C3::H1 C3::H2 C4 C4::C4 C5 C5::C1
+      Child
+      M1 M1::M2
+      Parent
+    ]
+
+    assert_equal expected,
+                 @store.all_classes_and_modules.map { |m| m.full_name }.sort
+  end
+
+  def test_all_files
+    assert_equal %w[xref_data.rb],
+                 @store.all_files.map { |m| m.full_name }.sort
+  end
+
+  def test_all_modules
+    assert_equal %w[M1 M1::M2],
+                 @store.all_modules.map { |m| m.full_name }.sort
+  end
+
   def test_attributes
     @s.cache[:attributes]['Object'] = %w[attr]
 
@@ -120,12 +193,63 @@ class TestRDocRIStore < RDoc::TestCase
                  @s.class_path('Object::SubClass')
   end
 
-  def test_dry_run
-    refute @s.dry_run
+  def test_classes
+    expected = %w[
+      C1 C2 C2::C3 C2::C3::H1 C3 C3::H1 C3::H2 C4 C4::C4 C5 C5::C1
+      Child
+      Parent
+    ]
 
-    @s.dry_run = true
+    assert_equal expected, @store.all_classes.map { |m| m.full_name }.sort
+  end
 
-    assert @s.dry_run
+  def test_complete
+    @c2.add_module_alias @c2_c3, 'A1', @top_level
+
+    @store.complete :public
+
+    a1 = @xref_data.find_class_or_module 'C2::A1'
+
+    assert_equal 'C2::A1', a1.full_name
+    refute_empty a1.aliases
+  end
+
+  def test_find_class_named
+    assert_equal @c1, @store.find_class_named('C1')
+
+    assert_equal @c2_c3, @store.find_class_named('C2::C3')
+  end
+
+  def test_find_class_named_from
+    assert_equal @c5_c1, @store.find_class_named_from('C1', 'C5')
+
+    assert_equal @c1,    @store.find_class_named_from('C1', 'C4')
+  end
+
+  def test_find_class_or_module
+    assert_equal @m1, @store.find_class_or_module('M1')
+    assert_equal @c1, @store.find_class_or_module('C1')
+
+    assert_equal @m1, @store.find_class_or_module('::M1')
+    assert_equal @c1, @store.find_class_or_module('::C1')
+  end
+
+  def test_find_file_named
+    assert_equal @xref_data, @store.find_file_named(@file_name)
+  end
+
+  def test_find_module_named
+    assert_equal @m1,    @store.find_module_named('M1')
+    assert_equal @m1_m2, @store.find_module_named('M1::M2')
+  end
+
+  def test_find_text_page
+    page = @store.add_file 'PAGE.txt'
+    page.parser = RDoc::Parser::Simple
+
+    assert_nil @store.find_text_page 'no such page'
+
+    assert_equal page, @store.find_text_page('PAGE.txt')
   end
 
   def test_friendly_path
@@ -143,13 +267,21 @@ class TestRDocRIStore < RDoc::TestCase
     assert_equal "ruby site", @s.friendly_path
 
     @s.type = :home
-    assert_equal "~/.ri", @s.friendly_path
+    assert_equal "~/.rdoc", @s.friendly_path
 
     @s.type = :gem
     @s.path = "#{@tmpdir}/gem_repository/doc/gem_name-1.0/ri"
     assert_equal "gem gem_name-1.0", @s.friendly_path
   end
 
+  def test_dry_run
+    refute @s.dry_run
+
+    @s.dry_run = true
+
+    assert @s.dry_run
+  end
+
   def test_instance_methods
     @s.cache[:instance_methods]['Object'] = %w[method]
 
@@ -158,11 +290,50 @@ class TestRDocRIStore < RDoc::TestCase
     assert_equal expected, @s.instance_methods
   end
 
+  def test_load_all
+    FileUtils.mkdir_p @tmpdir
+
+    @s.save
+
+    s = RDoc::Store.new @tmpdir
+
+    s.load_all
+
+    assert_equal [@klass, @nest_klass], s.all_classes.sort
+    assert_equal [@mod],                s.all_modules.sort
+    assert_equal [@page, @top_level],   s.all_files.sort
+
+    methods = s.all_classes_and_modules.map do |mod|
+      mod.method_list
+    end.flatten.sort
+
+    _meth_bang_alias = RDoc::AnyMethod.new nil, 'method_bang'
+    _meth_bang_alias.parent = @klass
+
+    assert_equal [@meth, @meth_bang, _meth_bang_alias, @nest_meth, @cmeth],
+                 methods.sort_by { |m| m.full_name }
+
+    method = methods.find { |m| m == @meth }
+    assert_equal @meth_comment.parse, method.comment
+
+    assert_equal @klass, methods.last.parent
+
+    attributes = s.all_classes_and_modules.map do |mod|
+      mod.attributes
+    end.flatten.sort
+
+    assert_equal [@attr], attributes
+
+    assert_equal @attr_comment.parse, attributes.first.comment
+  end
+
   def test_load_cache
     cache = {
       :encoding => :encoding_value,
-      :methods  => %w[Object#method],
+      :methods  => { "Object" => %w[Object#method] },
+      :main     => @page.full_name,
       :modules  => %w[Object],
+      :pages    => [],
     }
 
     Dir.mkdir @tmpdir
@@ -176,6 +347,7 @@ class TestRDocRIStore < RDoc::TestCase
     assert_equal cache, @s.cache
 
     assert_equal :encoding_value, @s.encoding
+    assert_equal 'README.txt',    @s.main
   end
 
   def test_load_cache_encoding_differs
@@ -183,8 +355,10 @@ class TestRDocRIStore < RDoc::TestCase
 
     cache = {
       :encoding => Encoding::ISO_8859_1,
-      :methods  => %w[Object#method],
+      :main     => nil,
+      :methods  => { "Object" => %w[Object#method] },
       :modules  => %w[Object],
+      :pages    => [],
     }
 
     Dir.mkdir @tmpdir
@@ -209,7 +383,10 @@ class TestRDocRIStore < RDoc::TestCase
       :class_methods    => {},
       :encoding         => nil,
       :instance_methods => {},
+      :main             => nil,
       :modules          => [],
+      :pages            => [],
+      :title            => nil,
     }
 
     @s.load_cache
@@ -217,17 +394,96 @@ class TestRDocRIStore < RDoc::TestCase
     assert_equal cache, @s.cache
   end
 
+  def test_load_cache_legacy
+    cache = {
+      :ancestors        => {},
+      :attributes       => {},
+      :class_methods    => {},
+      :encoding         => :encoding_value,
+      :instance_methods => { "Object" => %w[Object#method] },
+      :modules          => %w[Object],
+      # no :pages
+      # no :main
+    }
+
+    Dir.mkdir @tmpdir
+
+    open File.join(@tmpdir, 'cache.ri'), 'wb' do |io|
+      Marshal.dump cache, io
+    end
+
+    @s.load_cache
+
+    expected = {
+      :ancestors        => {},
+      :attributes       => {},
+      :class_methods    => {},
+      :encoding         => :encoding_value,
+      :instance_methods => { "Object" => %w[Object#method] },
+      :main             => nil,
+      :modules          => %w[Object],
+      :pages            => [],
+    }
+
+    assert_equal expected, @s.cache
+
+    assert_equal :encoding_value, @s.encoding
+    assert_nil                    @s.main
+  end
+
   def test_load_class
     @s.save_class @klass
+    @s.classes_hash.clear
 
     assert_equal @klass, @s.load_class('Object')
+
+    assert_includes @s.classes_hash, 'Object'
   end
 
-  def test_load_method_bang
+  def test_load_method
     @s.save_method @klass, @meth_bang
 
     meth = @s.load_method('Object', '#method!')
     assert_equal @meth_bang, meth
+    assert_equal @klass, meth.parent
+    assert_equal @s, meth.store
+  end
+
+  def test_load_method_legacy
+    @s.save_method @klass, @meth
+
+    file = @s.method_file @klass.full_name, @meth.full_name
+
+    open file, 'wb' do |io|
+      io.write "\x04\bU:\x14RDoc::AnyMethod[\x0Fi\x00I" +
+               "\"\vmethod\x06:\x06EF\"\x11Klass#method0:\vpublic" +
+               "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
+               "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
+               "\"\x16this is a comment\x06;\x06FI" +
+               "\"\rcall_seq\x06;\x06FI\"\x0Fsome_block\x06;\x06F" +
+               "[\x06[\aI\"\faliased\x06;\x06Fo;\b\x06;\t[\x06" +
+               "o;\n\x06;\t[\x06I\"\x12alias comment\x06;\x06FI" +
+               "\"\nparam\x06;\x06F"
+    end
+
+    meth = @s.load_method('Object', '#method')
+    assert_equal 'Klass#method', meth.full_name
+    assert_equal @klass,         meth.parent
+    assert_equal @s,             meth.store
+  end
+
+  def test_load_page
+    @s.save_page @page
+
+    assert_equal @page, @s.load_page('README.txt')
+  end
+
+  def test_main
+    assert_equal nil, @s.main
+
+    @s.main = 'README.txt'
+
+    assert_equal 'README.txt', @s.main
   end
 
   def test_method_file
@@ -244,29 +500,89 @@ class TestRDocRIStore < RDoc::TestCase
                  @s.method_file('Object', 'Object::method')
   end
 
+  def test_module_names
+    @s.save_class @klass
+
+    assert_equal %w[Object], @s.module_names
+  end
+
+  def test_page
+    page = @store.add_file 'PAGE.txt'
+    page.parser = RDoc::Parser::Simple
+
+    assert_nil @store.page 'no such page'
+
+    assert_equal page, @store.page('PAGE')
+  end
+
+  def test_save
+    FileUtils.mkdir_p @tmpdir
+
+    @s.save
+
+    assert_directory File.join(@tmpdir, 'Object')
+
+    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
+    assert_file File.join(@tmpdir, 'Object', 'method-i.ri')
+    assert_file File.join(@tmpdir, 'page-README_txt.ri')
+
+    assert_file File.join(@tmpdir, 'cache.ri')
+
+    expected = {
+      :ancestors => {
+        'Object::SubClass' => %w[Incl Object],
+      },
+      :attributes => { 'Object' => ['attr_accessor attr'] },
+      :class_methods => { 'Object' => %w[cmethod] },
+      :instance_methods => {
+        'Object' => %w[attr method method! method_bang],
+        'Object::SubClass' => %w[method],
+      },
+      :main => nil,
+      :modules => %w[Mod Object Object::SubClass],
+      :encoding => nil,
+      :pages => %w[README.txt],
+      :title => nil,
+    }
+
+    expected[:ancestors]['Object'] = %w[BasicObject] if defined?(::BasicObject)
+
+    open File.join(@tmpdir, 'cache.ri'), 'rb' do |io|
+      cache = Marshal.load io.read
+
+      assert_equal expected, cache
+    end
+  end
+
   def test_save_cache
     @s.save_class @klass
     @s.save_method @klass, @meth
     @s.save_method @klass, @cmeth
     @s.save_class @nest_klass
+    @s.save_page @page
     @s.encoding = :encoding_value
+    @s.main     = @page.full_name
+    @s.title    = 'title'
 
     @s.save_cache
 
     assert_file File.join(@tmpdir, 'cache.ri')
 
     expected = {
+      :ancestors => {
+        'Object::SubClass' => %w[Incl Object],
+      },
       :attributes => { 'Object' => ['attr_accessor attr'] },
       :class_methods => { 'Object' => %w[cmethod] },
       :instance_methods => {
-        'Object' => %w[method method!],
+        'Object' => %w[method method! method_bang],
         'Object::SubClass' => %w[method],
       },
+      :main => @page.full_name,
       :modules => %w[Object Object::SubClass],
-      :ancestors => {
-        'Object::SubClass' => %w[Incl Object],
-      },
       :encoding => :encoding_value,
+      :pages => %w[README.txt],
+      :title => 'title',
     }
 
     expected[:ancestors]['Object'] = %w[BasicObject] if defined?(::BasicObject)
@@ -300,6 +616,15 @@ class TestRDocRIStore < RDoc::TestCase
     assert_cache({ 'Object' => %w[method] }, {}, {}, [])
   end
 
+  def test_save_cache_duplicate_pages
+    @s.save_page @page
+    @s.save_page @page
+
+    @s.save_cache
+
+    assert_cache({}, {}, {}, [], {}, %w[README.txt])
+  end
+
   def test_save_class
     @s.save_class @klass
 
@@ -388,8 +713,10 @@ class TestRDocRIStore < RDoc::TestCase
 
   # This is a functional test
   def test_save_class_merge_constant
-    tl = RDoc::TopLevel.new 'file.rb'
-    klass = RDoc::NormalClass.new 'C'
+    store = RDoc::Store.new
+    tl = store.add_file 'file.rb'
+
+    klass = tl.add_class RDoc::NormalClass, 'C'
     klass.add_comment 'comment', tl
 
     const = klass.add_constant RDoc::Constant.new('CONST', nil, nil)
@@ -397,14 +724,16 @@ class TestRDocRIStore < RDoc::TestCase
 
     @s.save_class klass
 
-    RDoc::RDoc.reset
-
-    klass2 = RDoc::NormalClass.new 'C'
+    # separate parse run, independent store
+    store = RDoc::Store.new
+    tl = store.add_file 'file.rb'
+    klass2 = tl.add_class RDoc::NormalClass, 'C'
     klass2.record_location tl
 
     s = RDoc::RI::Store.new @tmpdir
     s.save_class klass2
 
+    # separate `ri` run, independent store
     s = RDoc::RI::Store.new @tmpdir
 
     result = s.load_class 'C'
@@ -462,5 +791,49 @@ class TestRDocRIStore < RDoc::TestCase
     assert_cache({ 'Object::SubClass' => %w[method] }, {}, {}, [])
   end
 
+  def test_save_page
+    @s.save_page @page
+
+    assert_file File.join(@tmpdir, 'page-README_txt.ri')
+
+    assert_cache({}, {}, {}, [], {}, %w[README.txt])
+  end
+
+  def test_save_page_file
+    @s.save_page @top_level
+
+    refute_file File.join(@tmpdir, 'page-file_rb.ri')
+  end
+
+  def test_source
+    @s.path = @tmpdir
+    @s.type = nil
+    assert_equal @s.path, @s.source
+
+    @s.type = :extra
+    assert_equal @s.path, @s.source
+
+    @s.type = :system
+    assert_equal "ruby", @s.source
+
+    @s.type = :site
+    assert_equal "site", @s.source
+
+    @s.type = :home
+    assert_equal "home", @s.source
+
+    @s.type = :gem
+    @s.path = "#{@tmpdir}/gem_repository/doc/gem_name-1.0/ri"
+    assert_equal "gem_name-1.0", @s.source
+  end
+
+  def test_title
+    assert_equal nil, @s.title
+
+    @s.title = 'rdoc'
+
+    assert_equal 'rdoc', @s.title
+  end
+
 end