rdoc 4.2.1 → 6.3.1

data/test/test_rdoc_context_section.rb

@@ -1,130 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocContextSection < RDoc::TestCase
-
-  def setup
-    super
-
-    @top_level = @store.add_file 'file.rb'
-
-    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
-
-    @S = RDoc::Context::Section
-    @s = @S.new @klass, 'section', comment('# comment', @top_level)
-  end
-
-  def test_add_comment
-    file1 = @store.add_file 'file1.rb'
-
-    klass = file1.add_class RDoc::NormalClass, 'Klass'
-
-    c1 = RDoc::Comment.new "# :section: section\n", file1
-    c2 = RDoc::Comment.new "# hello\n",             file1
-    c3 = RDoc::Comment.new "# world\n",             file1
-
-    s = @S.new klass, 'section', c1
-
-    assert_empty s.comments
-
-    s.add_comment nil
-
-    assert_empty s.comments
-
-    s.add_comment c2
-
-    assert_equal [c2], s.comments
-
-    s.add_comment c3
-
-    assert_equal [c2, c3], s.comments
-  end
-
-  def test_aref
-    assert_equal 'section', @s.aref
-
-    assert_equal '5Buntitled-5D', @S.new(nil, nil, nil).aref
-
-    assert_equal 'one+two', @S.new(nil, 'one two', nil).aref
-  end
-
-  def test_extract_comment
-    assert_equal '',    @s.extract_comment(comment('')).text
-    assert_equal '',    @s.extract_comment(comment("# :section: b\n")).text
-    assert_equal '# c', @s.extract_comment(comment("# :section: b\n# c")).text
-    assert_equal '# c',
-                 @s.extract_comment(comment("# a\n# :section: b\n# c")).text
-  end
-
-  def test_marshal_dump
-    loaded = Marshal.load Marshal.dump @s
-
-    expected = RDoc::Comment.new('comment', @top_level).parse
-    expected = doc(expected)
-
-    assert_equal 'section', loaded.title
-    assert_equal expected,  loaded.comments
-    assert_nil              loaded.parent, 'parent is set manually'
-  end
-
-  def test_marshal_dump_no_comment
-    s = @S.new @klass, 'section', comment('')
-
-    loaded = Marshal.load Marshal.dump s
-
-    assert_equal 'section', loaded.title
-    assert_empty            loaded.comments
-    assert_nil              loaded.parent, 'parent is set manually'
-  end
-
-  def test_marshal_load_version_0
-    loaded = Marshal.load "\x04\bU:\eRDoc::Context::Section" +
-                          "[\bi\x00I\"\fsection\x06:\x06EFo" +
-                          ":\eRDoc::Markup::Document\a:\v@parts" +
-                          "[\x06o;\a\a;\b[\x06o" +
-                          ":\x1CRDoc::Markup::Paragraph\x06;\b" +
-                          "[\x06I\"\fcomment\x06;\x06F:\n@fileI" +
-                          "\"\ffile.rb\x06;\x06F;\n0"
-
-    expected = doc RDoc::Comment.new('comment', @top_level).parse
-
-    assert_equal 'section', loaded.title
-    assert_equal expected,  loaded.comments
-    assert_nil              loaded.parent, 'parent is set manually'
-  end
-
-  def test_remove_comment_array
-    other = @store.add_file 'other.rb'
-
-    other_comment = comment('bogus', other)
-
-    @s.add_comment other_comment
-
-    @s.remove_comment comment('bogus', @top_level)
-
-    assert_equal [other_comment], @s.comments
-  end
-
-  def test_remove_comment_document
-    other = @store.add_file 'other.rb'
-
-    other_comment = comment('bogus', other)
-
-    @s.add_comment other_comment
-
-    loaded = Marshal.load Marshal.dump @s
-
-    loaded.remove_comment comment('bogus', @top_level)
-
-    assert_equal doc(other_comment.parse), loaded.comments
-  end
-
-  def test_sequence
-    _, err = verbose_capture_io do
-      assert_match(/\ASEC\d{5}\Z/, @s.sequence)
-    end
-
-    assert_equal "#{@S}#sequence is deprecated, use #aref\n", err
-  end
-
-end
-

data/test/test_rdoc_cross_reference.rb

@@ -1,192 +0,0 @@
-require File.expand_path '../xref_test_case', __FILE__
-
-class TestRDocCrossReference < XrefTestCase
-
-  def setup
-    super
-
-    @xref = RDoc::CrossReference.new @c1
-  end
-
-  def assert_ref expected, name
-    assert_equal expected, @xref.resolve(name, 'fail')
-  end
-
-  def refute_ref name
-    assert_equal name, @xref.resolve(name, name)
-  end
-
-  def test_METHOD_REGEXP_STR
-    re = /#{RDoc::CrossReference::METHOD_REGEXP_STR}/
-
-    %w'=== [] []= << >>'.each do |x|
-      re =~ x
-      assert_equal x, $&
-    end
-  end
-
-  def test_resolve_C2
-    @xref = RDoc::CrossReference.new @c2
-
-    refute_ref '#m'
-
-    assert_ref @c1__m,    'C1::m'
-    assert_ref @c2_c3,    'C2::C3'
-    assert_ref @c2_c3_m,  'C2::C3#m'
-    assert_ref @c2_c3_h1, 'C3::H1'
-    assert_ref @c4,       'C4'
-
-    assert_ref @c3_h2, 'C3::H2'
-    refute_ref 'H1'
-  end
-
-  def test_resolve_C2_C3
-    @xref = RDoc::CrossReference.new @c2_c3
-
-    assert_ref @c2_c3_m, '#m'
-
-    assert_ref @c2_c3, 'C3'
-    assert_ref @c2_c3_m, 'C3#m'
-
-    assert_ref @c2_c3_h1, 'H1'
-    assert_ref @c2_c3_h1, 'C3::H1'
-
-    assert_ref @c4, 'C4'
-
-    assert_ref @c3_h2, 'C3::H2'
-  end
-
-  def test_resolve_C3
-    @xref = RDoc::CrossReference.new @c3
-
-    assert_ref @c3, 'C3'
-
-    refute_ref '#m'
-    refute_ref 'C3#m'
-
-    assert_ref @c3_h1, 'H1'
-
-    assert_ref @c3_h1, 'C3::H1'
-    assert_ref @c3_h2, 'C3::H2'
-
-    assert_ref @c4, 'C4'
-  end
-
-  def test_resolve_C4
-    @xref = RDoc::CrossReference.new @c4
-
-    # C4 ref inside a C4 containing a C4 should resolve to the contained class
-    assert_ref @c4_c4, 'C4'
-  end
-
-  def test_resolve_C4_C4
-    @xref = RDoc::CrossReference.new @c4_c4
-
-    # A C4 reference inside a C4 class contained within a C4 class should
-    # resolve to the inner C4 class.
-    assert_ref @c4_c4, 'C4'
-  end
-
-  def test_resolve_class
-    assert_ref @c1, 'C1'
-    refute_ref 'H1'
-
-    assert_ref @c2,       'C2'
-    assert_ref @c2_c3,    'C2::C3'
-    assert_ref @c2_c3_h1, 'C2::C3::H1'
-
-    assert_ref @c3,    '::C3'
-    assert_ref @c3_h1, '::C3::H1'
-
-    assert_ref @c4_c4, 'C4::C4'
-  end
-
-  def test_resolve_file
-    refute_ref 'xref_data.rb'
-  end
-
-  def test_resolve_method
-    assert_ref @c1__m, 'm'
-    assert_ref @c1_m,  '#m'
-    assert_ref @c1__m, '::m'
-
-    assert_ref @c1_m,  'C1#m'
-    assert_ref @c1__m, 'C1.m'
-    assert_ref @c1__m, 'C1::m'
-
-    assert_ref @c1_m, 'C1#m'
-    assert_ref @c1_m, 'C1#m()'
-    assert_ref @c1_m, 'C1#m(*)'
-
-    assert_ref @c1__m, 'C1.m'
-    assert_ref @c1__m, 'C1.m()'
-    assert_ref @c1__m, 'C1.m(*)'
-
-    assert_ref @c1__m, 'C1::m'
-    assert_ref @c1__m, 'C1::m()'
-    assert_ref @c1__m, 'C1::m(*)'
-
-    assert_ref @c2_c3_m, 'C2::C3#m'
-
-    assert_ref @c2_c3_m, 'C2::C3.m'
-
-    # TODO stop escaping - HTML5 allows anything but space
-    assert_ref @c2_c3_h1_meh, 'C2::C3::H1#m?'
-
-    assert_ref @c2_c3_m, '::C2::C3#m'
-    assert_ref @c2_c3_m, '::C2::C3#m()'
-    assert_ref @c2_c3_m, '::C2::C3#m(*)'
-  end
-
-  def test_resolve_method_equals3
-    m = RDoc::AnyMethod.new '', '==='
-    @c1.add_method m
-
-    assert_ref m, '==='
-  end
-
-  def test_resolve_page
-    page = @store.add_file 'README.txt'
-    page.parser = RDoc::Parser::Simple
-
-    assert_ref page, 'README'
-  end
-
-  def test_resolve_percent
-    i_percent = RDoc::AnyMethod.new nil, '%'
-    i_percent.singleton = false
-    @c1.add_method i_percent
-
-    c_percent = RDoc::AnyMethod.new nil, '%'
-    c_percent.singleton = true
-    @c1.add_method c_percent
-
-    assert_ref i_percent, '%'
-    assert_ref i_percent, '#%'
-    assert_ref c_percent, '::%'
-
-    assert_ref i_percent, 'C1#%'
-    assert_ref c_percent, 'C1::%'
-  end
-
-  def test_resolve_no_ref
-    assert_equal '', @xref.resolve('', '')
-
-    assert_equal "bogus",     @xref.resolve("bogus",     "bogus")
-    assert_equal "\\bogus",   @xref.resolve("\\bogus",   "\\bogus")
-    assert_equal "\\\\bogus", @xref.resolve("\\\\bogus", "\\\\bogus")
-
-    assert_equal "\\#n",    @xref.resolve("\\#n",    "fail")
-    assert_equal "\\#n()",  @xref.resolve("\\#n()",  "fail")
-    assert_equal "\\#n(*)", @xref.resolve("\\#n(*)", "fail")
-
-    assert_equal "C1",   @xref.resolve("\\C1",   "fail")
-    assert_equal "::C3", @xref.resolve("\\::C3", "fail")
-
-    assert_equal "succeed",      @xref.resolve("::C3::H1#n",    "succeed")
-    assert_equal "succeed",      @xref.resolve("::C3::H1#n(*)", "succeed")
-    assert_equal "\\::C3::H1#n", @xref.resolve("\\::C3::H1#n",  "fail")
-  end
-
-end
-

data/test/test_rdoc_encoding.rb

@@ -1,227 +0,0 @@
-# coding: US-ASCII
-
-require 'rdoc/test_case'
-
-class TestRDocEncoding < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new 'test_rdoc_encoding'
-  end
-
-  def teardown
-    @tempfile.close!
-
-    super
-  end
-
-  def test_class_read_file
-    @tempfile.write "hi everybody"
-    @tempfile.flush
-
-    assert_equal "hi everybody", RDoc::Encoding.read_file(@tempfile.path, nil)
-  end
-
-  def test_class_read_file_encoding
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    expected = "# coding: utf-8\nhi everybody"
-
-    @tempfile.write expected
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal "hi everybody", contents
-    assert_equal Encoding::UTF_8, contents.encoding
-  end
-
-  def test_class_read_file_encoding_convert
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    content = ""
-    content.encode! 'ISO-8859-1'
-    content << "# coding: ISO-8859-1\nhi \xE9verybody"
-
-    @tempfile.write content
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal Encoding::UTF_8, contents.encoding
-    assert_equal "hi \u00e9verybody", contents.sub("\r", '')
-  end
-
-  def test_class_read_file_encoding_fail
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    @tempfile.write "# coding: utf-8\n\317\200" # pi
-    @tempfile.flush
-
-    contents = :junk
-
-    _, err = verbose_capture_io do
-      contents = RDoc::Encoding.read_file @tempfile.path, Encoding::US_ASCII
-    end
-
-    assert_nil contents
-
-    assert_match %r%^unable to convert%, err
-  end
-
-  def test_class_read_file_encoding_fancy
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    expected = "# -*- coding: utf-8; fill-column: 74 -*-\nhi everybody"
-    expected.encode! Encoding::UTF_8
-
-    @tempfile.write expected
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal "hi everybody", contents
-    assert_equal Encoding::UTF_8, contents.encoding
-  end
-
-  def test_class_read_file_encoding_force_transcode
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    @tempfile.write "# coding: utf-8\n\317\200" # pi
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::US_ASCII, true
-
-    assert_equal '?', contents
-    assert_equal Encoding::US_ASCII, contents.encoding
-  end
-
-  def test_class_read_file_encoding_guess
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    path = File.expand_path '../test.ja.txt', __FILE__
-    content = RDoc::Encoding.read_file path, Encoding::UTF_8
-
-    assert_equal Encoding::UTF_8, content.encoding
-  end
-
-  def test_class_read_file_encoding_invalid
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    @tempfile.write "# coding: ascii\nM\xE4r"
-    @tempfile.flush
-
-    contents = :junk
-    _, err = verbose_capture_io do
-      contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    end
-
-    assert_equal "unable to convert \"\\xE4\" on US-ASCII for #{@tempfile.path}, skipping\n", err
-
-    assert_nil contents
-  end
-
-  def test_class_read_file_encoding_with_signature
-    skip "Encoding not implemented" unless defined? ::Encoding
-
-    @tempfile.write "\xEF\xBB\xBFhi everybody"
-    @tempfile.flush
-
-    bug3360 = '[ruby-dev:41452]'
-    content = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-    assert_equal Encoding::UTF_8, content.encoding, bug3360
-    assert_equal "hi everybody", content, bug3360
-  end
-
-  def test_class_read_file_encoding_iso_2022_jp
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    input = "# coding: ISO-2022-JP\n:\e$B%3%^%s%I\e(B:"
-
-    @tempfile.write input
-    @tempfile.flush
-
-    contents = RDoc::Encoding.read_file @tempfile.path, Encoding::UTF_8
-
-    expected = ":\xe3\x82\xb3\xe3\x83\x9e\xe3\x83\xb3\xe3\x83\x89:"
-    expected.force_encoding Encoding::UTF_8
-
-    assert_equal expected, contents
-    assert_equal Encoding::UTF_8, contents.encoding
-  end
-
-  def test_class_set_encoding
-    s = "# coding: UTF-8\n"
-    RDoc::Encoding.set_encoding s
-
-    # sanity check for 1.8
-
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    assert_equal Encoding::UTF_8, s.encoding
-
-    s = "#!/bin/ruby\n# coding: UTF-8\n"
-    RDoc::Encoding.set_encoding s
-
-    assert_equal Encoding::UTF_8, s.encoding
-
-    s = "<?xml version='1.0' encoding='UTF-8'?>\n"
-    expected = s.encoding
-    RDoc::Encoding.set_encoding s
-
-    assert_equal Encoding::UTF_8, s.encoding
-
-    s = "<?xml version='1.0' encoding=\"UTF-8\"?>\n"
-    expected = s.encoding
-    RDoc::Encoding.set_encoding s
-
-    assert_equal Encoding::UTF_8, s.encoding
-  end
-
-  def test_class_set_encoding_strip
-    s = "# coding: UTF-8\n# more comments"
-
-    RDoc::Encoding.set_encoding s
-
-    assert_equal "# more comments", s
-
-    s = "#!/bin/ruby\n# coding: UTF-8\n# more comments"
-
-    RDoc::Encoding.set_encoding s
-
-    assert_equal "#!/bin/ruby\n# more comments", s
-  end
-
-  def test_class_set_encoding_bad
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    s = ""
-    expected = s.encoding
-    RDoc::Encoding.set_encoding s
-
-    assert_equal expected, s.encoding
-
-    s = "# vim:set fileencoding=utf-8:\n"
-    expected = s.encoding
-    RDoc::Encoding.set_encoding s
-
-    assert_equal expected, s.encoding
-
-    s = "# vim:set fileencoding=utf-8:\n"
-    expected = s.encoding
-    RDoc::Encoding.set_encoding s
-
-    assert_equal expected, s.encoding
-
-    assert_raises ArgumentError do
-      RDoc::Encoding.set_encoding "# -*- encoding: undecided -*-\n"
-    end
-  end
-
-  def test_sanity
-    skip "Encoding not implemented" unless Object.const_defined? :Encoding
-
-    assert_equal Encoding::US_ASCII, ''.encoding,
-                 'If this file is not ASCII tests may incorrectly pass'
-  end
-
-end
-

data/test/test_rdoc_extend.rb

@@ -1,94 +0,0 @@
-require File.expand_path '../xref_test_case', __FILE__
-
-class TestRDocExtend < XrefTestCase
-
-  def setup
-    super
-
-    @ext = RDoc::Extend.new 'M1', 'comment'
-    @ext.parent = @m1
-    @ext.store = @store
-  end
-
-  def test_module
-    assert_equal @m1, @ext.module
-    assert_equal 'Unknown', RDoc::Extend.new('Unknown', 'comment').module
-  end
-
-  def test_module_extended
-    m1 = @xref_data.add_module RDoc::NormalModule, 'Mod1'
-                  m1.add_module RDoc::NormalModule, 'Mod3'
-    m1_m2       = m1.add_module RDoc::NormalModule, 'Mod2'
-    m1_m2_m3    = m1_m2.add_module RDoc::NormalModule, 'Mod3'
-                  m1_m2_m3.add_module RDoc::NormalModule, 'Mod4'
-                  m1_m2.add_module RDoc::NormalModule, 'Mod4'
-    m1_m2_k0    = m1_m2.add_class RDoc::NormalClass, 'Klass0'
-    m1_m2_k0_m4 = m1_m2_k0.add_module RDoc::NormalModule, 'Mod4'
-                  m1_m2_k0_m4.add_module RDoc::NormalModule, 'Mod6'
-                  m1_m2_k0.add_module RDoc::NormalModule, 'Mod5'
-
-    e0_m4 = RDoc::Extend.new 'Mod4', nil
-    e0_m5 = RDoc::Extend.new 'Mod5', nil
-    e0_m6 = RDoc::Extend.new 'Mod6', nil
-    e0_m1 = RDoc::Extend.new 'Mod1', nil
-    e0_m2 = RDoc::Extend.new 'Mod2', nil
-    e0_m3 = RDoc::Extend.new 'Mod3', nil
-
-    m1_m2_k0.add_extend e0_m4
-    m1_m2_k0.add_extend e0_m5
-    m1_m2_k0.add_extend e0_m6
-    m1_m2_k0.add_extend e0_m1
-    m1_m2_k0.add_extend e0_m2
-    m1_m2_k0.add_extend e0_m3
-
-    assert_equal [e0_m4, e0_m5, e0_m6, e0_m1, e0_m2, e0_m3], m1_m2_k0.extends
-    assert_equal ['Object'], m1_m2_k0.ancestors
-
-    m1_k1 = m1.add_class RDoc::NormalClass, 'Klass1'
-
-    e1_m1 = RDoc::Extend.new 'Mod1', nil
-    e1_m2 = RDoc::Extend.new 'Mod2', nil
-    e1_m3 = RDoc::Extend.new 'Mod3', nil
-    e1_m4 = RDoc::Extend.new 'Mod4', nil
-    e1_k0_m4 = RDoc::Extend.new 'Klass0::Mod4', nil
-
-    m1_k1.add_extend e1_m1
-    m1_k1.add_extend e1_m2
-    m1_k1.add_extend e1_m3
-    m1_k1.add_extend e1_m4
-    m1_k1.add_extend e1_k0_m4
-
-    assert_equal [e1_m1, e1_m2, e1_m3, e1_m4, e1_k0_m4], m1_k1.extends
-    assert_equal ['Object'], m1_k1.ancestors
-
-    m1_k2 = m1.add_class RDoc::NormalClass, 'Klass2'
-
-    e2_m1 = RDoc::Extend.new 'Mod1', nil
-    e2_m2 = RDoc::Extend.new 'Mod2', nil
-    e2_m3 = RDoc::Extend.new 'Mod3', nil
-    e2_k0_m4 = RDoc::Extend.new 'Klass0::Mod4', nil
-
-    m1_k2.add_extend e2_m1
-    m1_k2.add_extend e2_m3
-    m1_k2.add_extend e2_m2
-    m1_k2.add_extend e2_k0_m4
-
-    assert_equal [e2_m1, e2_m3, e2_m2, e2_k0_m4], m1_k2.extends
-    assert_equal ['Object'], m1_k2.ancestors
-
-    m1_k3 = m1.add_class RDoc::NormalClass, 'Klass3'
-
-    e3_m1 = RDoc::Extend.new 'Mod1', nil
-    e3_m2 = RDoc::Extend.new 'Mod2', nil
-    e3_m4 = RDoc::Extend.new 'Mod4', nil
-
-    m1_k3.add_extend e3_m1
-    m1_k3.add_extend e3_m2
-    m1_k3.add_extend e3_m4
-
-    assert_equal [e3_m1, e3_m2, e3_m4], m1_k3.extends
-    assert_equal ['Object'], m1_k3.ancestors
-  end
-
-end
-