rdoc 4.0.0.preview2 → 4.0.0.preview2.1

data/test/test_rdoc_parser_ruby.rb

@@ -80,23 +80,53 @@ class C; end
     assert_equal 'A', name_t.text
     assert_equal 'A', given_name
 
-    cont, name_t, given_name = util_parser('A::B') .get_class_or_module ctxt
+    cont, name_t, given_name = util_parser('B::C') .get_class_or_module ctxt
 
-    assert_equal @store.find_module_named('A'), cont
-    assert_equal 'B', name_t.text
-    assert_equal 'A::B', given_name
+    b = @store.find_module_named('B')
+    assert_equal b, cont
+    assert_equal [@top_level], b.in_files
+    assert_equal 'C', name_t.text
+    assert_equal 'B::C', given_name
 
-    cont, name_t, given_name = util_parser('A:: B').get_class_or_module ctxt
+    cont, name_t, given_name = util_parser('D:: E').get_class_or_module ctxt
 
-    assert_equal @store.find_module_named('A'), cont
-    assert_equal 'B', name_t.text
-    assert_equal 'A::B', given_name
+    assert_equal @store.find_module_named('D'), cont
+    assert_equal 'E', name_t.text
+    assert_equal 'D::E', given_name
 
     assert_raises NoMethodError do
       util_parser("A::\nB").get_class_or_module ctxt
     end
   end
 
+  def test_get_class_or_module_document_children
+    ctxt = @top_level.add_class RDoc::NormalClass, 'A'
+    ctxt.stop_doc
+
+    util_parser('B::C').get_class_or_module ctxt
+
+    b = @store.find_module_named('A::B')
+    assert b.ignored?
+
+    d = @top_level.add_class RDoc::NormalClass, 'A::D'
+
+    util_parser('D::E').get_class_or_module ctxt
+
+    refute d.ignored?
+  end
+
+  def test_get_class_or_module_ignore_constants
+    ctxt = RDoc::Context.new
+    ctxt.store = @store
+
+    util_parser('A')   .get_class_or_module ctxt, true
+    util_parser('A::B').get_class_or_module ctxt, true
+
+    assert_empty ctxt.constants
+    assert_empty @store.modules_hash.keys
+    assert_empty @store.classes_hash.keys
+  end
+
   def test_get_class_specification
     assert_equal 'A',    util_parser('A')   .get_class_specification
     assert_equal 'A::B', util_parser('A::B').get_class_specification
@@ -1108,6 +1138,37 @@ EOF
     assert_equal 'A', bar.find_module_named('A').full_name
   end
 
+  def test_parse_constant_in_method
+    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
+
+    util_parser 'A::B = v'
+
+    tk = @parser.get_tk
+
+    @parser.parse_constant klass, tk, @comment, true
+
+    assert_empty klass.constants
+
+    assert_empty @store.modules_hash.keys
+    assert_equal %w[Foo], @store.classes_hash.keys
+  end
+
+  def test_parse_constant_rescue
+    klass = @top_level.add_class RDoc::NormalClass, 'Foo'
+
+    util_parser "A => e"
+
+    tk = @parser.get_tk
+
+    @parser.parse_constant klass, tk, @comment
+
+    assert_empty klass.constants
+    assert_empty klass.modules
+
+    assert_empty @store.modules_hash.keys
+    assert_equal %w[Foo], @store.classes_hash.keys
+  end
+
   def test_parse_constant_stopdoc
     klass = @top_level.add_class RDoc::NormalClass, 'Foo'
     klass.stop_doc
@@ -1121,6 +1182,27 @@ EOF
     assert_empty klass.constants
   end
 
+  def test_parse_comment_nested
+    content = <<-CONTENT
+A::B::C = 1
+    CONTENT
+
+    util_parser content
+
+    tk = @parser.get_tk
+
+    parsed = @parser.parse_constant @top_level, tk, 'comment'
+
+    assert parsed
+
+    a = @top_level.find_module_named 'A'
+    b = a.find_module_named 'B'
+    c = b.constants.first
+
+    assert_equal 'A::B::C', c.full_name
+    assert_equal 'comment', c.comment
+  end
+
   def test_parse_include
     klass = RDoc::NormalClass.new 'C'
     klass.parent = @top_level
@@ -2585,6 +2667,61 @@ end
     assert_equal 'A nice girl', m.comment.text
   end
 
+  def test_scan_constant_in_method
+    content = <<-CONTENT # newline is after M is important
+module M
+  def m
+    A
+    B::C
+  end
+end
+    CONTENT
+
+    util_parser content
+
+    @parser.scan
+
+    m = @top_level.modules.first
+
+    assert_empty m.constants
+
+    assert_empty @store.classes_hash.keys
+    assert_equal %w[M], @store.modules_hash.keys
+  end
+
+  def test_scan_constant_in_rescue
+    content = <<-CONTENT # newline is after M is important
+module M
+  def m
+  rescue A::B
+  rescue A::C => e
+  rescue A::D, A::E
+  rescue A::F,
+         A::G
+  rescue H
+  rescue I => e
+  rescue J, K
+  rescue L =>
+    e
+  rescue M;
+  rescue N,
+         O => e
+  end
+end
+    CONTENT
+
+    util_parser content
+
+    @parser.scan
+
+    m = @top_level.modules.first
+
+    assert_empty m.constants
+
+    assert_empty @store.classes_hash.keys
+    assert_equal %w[M], @store.modules_hash.keys
+  end
+
   def test_scan_constant_nodoc
     content = <<-CONTENT # newline is after M is important
 module M

data/test/test_rdoc_rdoc.rb

@@ -123,13 +123,14 @@ class TestRDocRDoc < RDoc::TestCase
   end
 
   def test_normalized_file_list_non_file_directory
-    skip '/dev/stdin is not a character special' unless
-      File.chardev? '/dev/stdin'
+    dev = defined?(File::NULL) ? File::NULL : '/dev/stdin'
+    skip "#{dev} is not a character special" unless
+      File.chardev? dev
 
     files = nil
 
     out, err = verbose_capture_io do
-      files = @rdoc.normalized_file_list %w[/dev/stdin]
+      files = @rdoc.normalized_file_list [dev]
     end
 
     files = files.map { |file| File.expand_path file }
@@ -137,8 +138,8 @@ class TestRDocRDoc < RDoc::TestCase
     assert_empty files
 
     assert_empty out
-    assert_match %r%^rdoc can't parse%, err
-    assert_match %r%/dev/stdin$%,       err
+    assert_match %r"^rdoc can't parse", err
+    assert_match %r"#{dev}$",           err
   end
 
   def test_parse_file
@@ -158,6 +159,25 @@ class TestRDocRDoc < RDoc::TestCase
     end
   end
 
+  def test_parse_file_page_dir
+    @rdoc.store = RDoc::Store.new
+
+    temp_dir do |dir|
+      FileUtils.mkdir 'pages'
+      @rdoc.options.page_dir = Pathname('pages')
+      @rdoc.options.root = Pathname(Dir.pwd)
+
+      open 'pages/test.txt', 'w' do |io|
+        io.puts 'hi'
+      end
+
+      top_level = @rdoc.parse_file 'pages/test.txt'
+
+      assert_equal 'pages/test.txt', top_level.absolute_name
+      assert_equal 'test.txt',       top_level.relative_name
+    end
+  end
+
   def test_parse_file_relative
     pwd = Dir.pwd
 

data/test/test_rdoc_ri_driver.rb

@@ -747,6 +747,25 @@ Foo::Bar#bother
     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
 
@@ -1147,6 +1166,14 @@ Foo::Bar#bother
     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'
 

data/test/test_rdoc_ruby_lex.rb

@@ -1,3 +1,5 @@
+# coding: UTF-8
+
 require 'rdoc/test_case'
 
 class TestRDocRubyLex < RDoc::TestCase
@@ -133,6 +135,14 @@ U
     assert_equal expected, tokens
   end
 
+  def test_class_tokenize_identifier_high_unicode
+    tokens = RDoc::RubyLex.tokenize '𝖒', nil
+
+    expected = @TK::TkIDENTIFIER.new(0, 1, 0, '𝖒')
+
+    assert_equal expected, tokens.first
+  end
+
   def test_class_tokenize_percent_1
     tokens = RDoc::RubyLex.tokenize 'v%10==10', nil
 

data/test/test_rdoc_rubygems_hook.rb

@@ -10,7 +10,15 @@ class TestRDocRubygemsHook < Gem::TestCase
     skip 'requires RubyGems 1.9+' unless
       Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.9')
 
-    @a = quick_spec 'a'
+    @a = quick_spec 'a' do |s|
+      s.rdoc_options = %w[--main MyTitle]
+      s.extra_rdoc_files = %w[README]
+    end
+
+    write_file File.join(@tempdir, 'lib', 'a.rb')
+    write_file File.join(@tempdir, 'README')
+
+    install_gem @a
 
     @hook = RDoc::RubygemsHook.new @a
 
@@ -24,7 +32,7 @@ class TestRDocRubygemsHook < Gem::TestCase
   end
 
   def test_initialize
-    assert @hook.generate_rdoc
+    refute @hook.generate_rdoc
     assert @hook.generate_ri
 
     rdoc = RDoc::RubygemsHook.new @a, false, false
@@ -66,12 +74,37 @@ class TestRDocRubygemsHook < Gem::TestCase
 
     @hook.generate
 
+    refute @hook.rdoc_installed?
+    assert @hook.ri_installed?
+
+    rdoc = @hook.instance_variable_get :@rdoc
+
+    refute rdoc.options.hyperlink_all
+    assert_equal Pathname(@a.full_gem_path), rdoc.options.root
+    assert_equal %w[README lib], rdoc.options.files.sort
+
+    assert_equal 'MyTitle', rdoc.store.main
+  end
+
+  def test_generate_all
+    @hook.generate_rdoc = true
+    @hook.generate_ri   = true
+
+    FileUtils.mkdir_p @a.doc_dir
+    FileUtils.mkdir_p File.join(@a.gem_dir, 'lib')
+
+    @hook.generate
+
     assert @hook.rdoc_installed?
     assert @hook.ri_installed?
 
     rdoc = @hook.instance_variable_get :@rdoc
 
     refute rdoc.options.hyperlink_all
+    assert_equal Pathname(@a.full_gem_path), rdoc.options.root
+    assert_equal %w[README lib], rdoc.options.files.sort
+
+    assert_equal 'MyTitle', rdoc.store.main
   end
 
   def test_generate_configuration_rdoc_array
@@ -133,7 +166,7 @@ class TestRDocRubygemsHook < Gem::TestCase
 
     @hook.generate
 
-    assert_path_exists File.join(@a.doc_dir('rdoc'), 'index.html')
+    refute_path_exists File.join(@a.doc_dir('rdoc'), 'index.html')
     assert_path_exists File.join(@a.doc_dir('ri'),   'cache.ri')
   end
 
@@ -183,7 +216,7 @@ class TestRDocRubygemsHook < Gem::TestCase
 
     assert_equal @a.base_dir, e.directory
   ensure
-    FileUtils.chmod 0755, @a.base_dir
+    FileUtils.chmod(0755, @a.base_dir) if File.directory?(@a.base_dir)
   end
 
   def test_ri_installed?
@@ -202,20 +235,18 @@ class TestRDocRubygemsHook < Gem::TestCase
 
   def test_setup_unwritable
     skip 'chmod not supported' if Gem.win_platform?
-    begin
-      FileUtils.mkdir_p @a.doc_dir
-      FileUtils.chmod 0, @a.doc_dir
-
-      e = assert_raises Gem::FilePermissionError do
-        @hook.setup
-      end
-
-      assert_equal @a.doc_dir, e.directory
-    ensure
-      if File.exist? @a.doc_dir
-        FileUtils.chmod 0755, @a.doc_dir
-        FileUtils.rm_r @a.doc_dir
-      end
+    FileUtils.mkdir_p @a.doc_dir
+    FileUtils.chmod 0, @a.doc_dir
+
+    e = assert_raises Gem::FilePermissionError do
+      @hook.setup
+    end
+
+    assert_equal @a.doc_dir, e.directory
+  ensure
+    if File.exist? @a.doc_dir
+      FileUtils.chmod 0755, @a.doc_dir
+      FileUtils.rm_r @a.doc_dir
     end
   end
 

data/test/test_rdoc_store.rb

@@ -18,6 +18,7 @@ class TestRDocStore < XrefTestCase
 
     @klass = @top_level.add_class RDoc::NormalClass, 'Object'
     @klass.add_comment 'original', @top_level
+    @klass.record_location @top_level
 
     @cmeth = RDoc::AnyMethod.new nil, 'cmethod'
     @cmeth.singleton = true
@@ -87,15 +88,17 @@ class TestRDocStore < XrefTestCase
     @s.clean_cache_collection ancestors
 
     expected = {
-      :ancestors        => ancestors,
-      :attributes       => attrs,
-      :class_methods    => cmethods,
-      :encoding         => nil,
-      :instance_methods => imethods,
-      :modules          => modules,
-      :pages            => pages,
-      :main             => main,
-      :title            => title,
+      :ancestors                   => ancestors,
+      :attributes                  => attrs,
+      :class_methods               => cmethods,
+      :c_class_variables           => {},
+      :c_singleton_class_variables => {},
+      :encoding                    => nil,
+      :instance_methods            => imethods,
+      :modules                     => modules,
+      :pages                       => pages,
+      :main                        => main,
+      :title                       => title,
     }
 
     @s.save_cache
@@ -115,6 +118,38 @@ class TestRDocStore < XrefTestCase
     refute File.exist?(path), "#{path} exists"
   end
 
+  def test_add_c_enclosure
+    @s.add_c_enclosure 'cC1', @c1
+
+    expected = { 'cC1' => @c1 }
+
+    assert_equal expected, @s.c_enclosure_classes
+  end
+
+  def test_add_c_variables
+    options = RDoc::Options.new
+
+    c_file = @s.add_file 'ext.c'
+
+    some_ext   = c_file.add_class RDoc::NormalClass, 'SomeExt'
+                 c_file.add_class RDoc::SingleClass, 'SomeExtSingle'
+
+    c_parser = RDoc::Parser::C.new c_file, 'ext.c', '', options, nil
+
+    c_parser.classes['cSomeExt']             = some_ext
+    c_parser.singleton_classes['s_cSomeExt'] = 'SomeExtSingle'
+
+    @s.add_c_variables c_parser
+
+    expected = { 'ext.c' => { 'cSomeExt' => 'SomeExt' } }
+
+    assert_equal expected, @s.c_class_variables
+
+    expected = { 'ext.c' => { 's_cSomeExt' => 'SomeExtSingle' } }
+
+    assert_equal expected, @s.c_singleton_class_variables
+  end
+
   def test_add_file
     top_level = @store.add_file 'file.rb'
 
@@ -214,6 +249,31 @@ class TestRDocStore < XrefTestCase
     refute_empty a1.aliases
   end
 
+  def test_find_c_enclosure
+    assert_nil @s.find_c_enclosure 'cC1'
+
+    @s.add_c_enclosure 'cC1', @c1
+
+    assert_equal @c1, @s.find_c_enclosure('cC1')
+  end
+
+  def test_find_c_enclosure_from_cache
+    @s.save_class @klass
+    @s.classes_hash.clear
+
+    assert_nil @s.find_c_enclosure 'cObject'
+
+    @s.c_enclosure_names['cObject'] = 'Object'
+
+    klass = @s.find_c_enclosure('cObject')
+    assert_equal @klass, klass
+
+    assert_empty klass.comment_location
+    assert_equal @top_level, klass.parent
+
+    assert_includes @s.c_enclosure_classes, 'cObject'
+  end
+
   def test_find_class_named
     assert_equal @c1, @store.find_class_named('C1')
 
@@ -329,11 +389,15 @@ class TestRDocStore < XrefTestCase
 
   def test_load_cache
     cache = {
-      :encoding => :encoding_value,
-      :methods  => { "Object" => %w[Object#method] },
-      :main     => @page.full_name,
-      :modules  => %w[Object],
-      :pages    => [],
+      :c_class_variables           =>
+        { 'file.c' => { 'cKlass' => 'Klass' } },
+      :c_singleton_class_variables =>
+        { 'file.c' => { 'sKlass' => 'KlassSingle' } },
+      :encoding                    => :encoding_value,
+      :methods                     => { "Object" => %w[Object#method] },
+      :main                        => @page.full_name,
+      :modules                     => %w[Object],
+      :pages                       => [],
     }
 
     Dir.mkdir @tmpdir
@@ -348,17 +412,28 @@ class TestRDocStore < XrefTestCase
 
     assert_equal :encoding_value, @s.encoding
     assert_equal 'README.txt',    @s.main
+
+    expected = { 'file.c' => { 'cKlass' => 'Klass' } }
+    assert_equal expected, @s.cache[:c_class_variables]
+
+    expected = { 'file.c' => { 'sKlass' => 'KlassSingle' } }
+    assert_equal expected, @s.cache[:c_singleton_class_variables]
+
+    expected = { 'cKlass' => 'Klass' }
+    assert_equal expected, @s.c_enclosure_names
   end
 
   def test_load_cache_encoding_differs
     skip "Encoding not implemented" unless Object.const_defined? :Encoding
 
     cache = {
-      :encoding => Encoding::ISO_8859_1,
-      :main     => nil,
-      :methods  => { "Object" => %w[Object#method] },
-      :modules  => %w[Object],
-      :pages    => [],
+      :c_class_variables           => {},
+      :c_singleton_class_variables => {},
+      :encoding                    => Encoding::ISO_8859_1,
+      :main                        => nil,
+      :methods                     => { "Object" => %w[Object#method] },
+      :modules                     => %w[Object],
+      :pages                       => [],
     }
 
     Dir.mkdir @tmpdir
@@ -378,15 +453,17 @@ class TestRDocStore < XrefTestCase
 
   def test_load_cache_no_cache
     cache = {
-      :ancestors        => {},
-      :attributes       => {},
-      :class_methods    => {},
-      :encoding         => nil,
-      :instance_methods => {},
-      :main             => nil,
-      :modules          => [],
-      :pages            => [],
-      :title            => nil,
+      :ancestors                   => {},
+      :attributes                  => {},
+      :class_methods               => {},
+      :c_class_variables           => {},
+      :c_singleton_class_variables => {},
+      :encoding                    => nil,
+      :instance_methods            => {},
+      :main                        => nil,
+      :modules                     => [],
+      :pages                       => [],
+      :title                       => nil,
     }
 
     @s.load_cache
@@ -404,6 +481,8 @@ class TestRDocStore < XrefTestCase
       :modules          => %w[Object],
       # no :pages
       # no :main
+      # no :c_class_variables
+      # no :c_singleton_class_variables
     }
 
     Dir.mkdir @tmpdir
@@ -415,14 +494,16 @@ class TestRDocStore < XrefTestCase
     @s.load_cache
 
     expected = {
-      :ancestors        => {},
-      :attributes       => {},
-      :class_methods    => {},
-      :encoding         => :encoding_value,
-      :instance_methods => { "Object" => %w[Object#method] },
-      :main             => nil,
-      :modules          => %w[Object],
-      :pages            => [],
+      :ancestors                   => {},
+      :attributes                  => {},
+      :class_methods               => {},
+      :c_class_variables           => {},
+      :c_singleton_class_variables => {},
+      :encoding                    => :encoding_value,
+      :instance_methods            => { "Object" => %w[Object#method] },
+      :main                        => nil,
+      :modules                     => %w[Object],
+      :pages                       => [],
     }
 
     assert_equal expected, @s.cache
@@ -534,6 +615,8 @@ class TestRDocStore < XrefTestCase
       },
       :attributes => { 'Object' => ['attr_accessor attr'] },
       :class_methods => { 'Object' => %w[cmethod] },
+      :c_class_variables => {},
+      :c_singleton_class_variables => {},
       :instance_methods => {
         'Object' => %w[attr method method! method_bang],
         'Object::SubClass' => %w[method],
@@ -564,16 +647,44 @@ class TestRDocStore < XrefTestCase
     @s.main     = @page.full_name
     @s.title    = 'title'
 
+    options = RDoc::Options.new
+
+    c_file = @s.add_file 'ext.c'
+
+    some_ext   = c_file.add_class RDoc::NormalClass, 'SomeExt'
+                 c_file.add_class RDoc::SingleClass, 'SomeExtSingle'
+
+    c_parser = RDoc::Parser::C.new c_file, 'ext.c', '', options, nil
+
+    c_parser.classes['cSomeExt']             = some_ext
+    c_parser.singleton_classes['s_cSomeExt'] = 'SomeExtSingle'
+
+    @s.add_c_variables c_parser
+
     @s.save_cache
 
     assert_file File.join(@tmpdir, 'cache.ri')
 
+    c_class_variables = {
+      'ext.c' => {
+        'cSomeExt' => 'SomeExt'
+      }
+    }
+
+    c_singleton_class_variables = {
+      'ext.c' => {
+        's_cSomeExt' => 'SomeExtSingle'
+      }
+    }
+
     expected = {
       :ancestors => {
         'Object::SubClass' => %w[Incl Object],
       },
       :attributes => { 'Object' => ['attr_accessor attr'] },
       :class_methods => { 'Object' => %w[cmethod] },
+      :c_class_variables => c_class_variables,
+      :c_singleton_class_variables => c_singleton_class_variables,
       :instance_methods => {
         'Object' => %w[method method! method_bang],
         'Object::SubClass' => %w[method],
@@ -708,7 +819,7 @@ class TestRDocStore < XrefTestCase
 
     document = @RM::Document.new inner
 
-    assert_equal document, s.load_class('Object').comment
+    assert_equal document, s.load_class('Object').comment_location
   end
 
   # This is a functional test