rdoc 3.1 → 6.3.3

data/test/test_rdoc_attr.rb

@@ -1,61 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'rdoc/rdoc'
-
-class TestRDocAttr < MiniTest::Unit::TestCase
-
-  def setup
-    @a = RDoc::Attr.new nil, 'attr', 'RW', ''
-  end
-
-  def test_aref
-    m = RDoc::Attr.new nil, 'attr', 'RW', nil
-
-    assert_equal 'attribute-i-attr', m.aref
-  end
-
-  def test_arglists
-    assert_nil @a.arglists
-  end
-
-  def test_block_params
-    assert_nil @a.block_params
-  end
-
-  def test_call_seq
-    assert_nil @a.call_seq
-  end
-
-  def test_definition
-    assert_equal 'attr_accessor', @a.definition
-
-    @a.rw = 'R'
-
-    assert_equal 'attr_reader', @a.definition
-
-    @a.rw = 'W'
-
-    assert_equal 'attr_writer', @a.definition
-  end
-
-  def test_full_name
-    assert_equal '(unknown)#attr', @a.full_name
-  end
-
-  def test_params
-    assert_nil @a.params
-  end
-
-  def test_singleton
-    refute @a.singleton
-  end
-
-  def test_type
-    assert_equal 'instance', @a.type
-
-    @a.singleton = true
-    assert_equal 'class', @a.type
-  end
-
-end
-

data/test/test_rdoc_class_module.rb

@@ -1,233 +0,0 @@
-require File.expand_path '../xref_test_case', __FILE__
-
-class TestRDocClassModule < XrefTestCase
-
-  def setup
-    super
-
-    @RM = RDoc::Markup
-  end
-
-  def test_comment_equals
-    cm = RDoc::ClassModule.new 'Klass'
-    cm.comment = '# comment 1'
-
-    assert_equal 'comment 1', cm.comment
-
-    cm.comment = '# comment 2'
-
-    assert_equal "comment 1\n---\ncomment 2", cm.comment
-
-    cm.comment = "# * comment 3"
-
-    assert_equal "comment 1\n---\ncomment 2\n---\n* comment 3", cm.comment
-  end
-
-  # handle making a short module alias of yourself
-
-  def test_find_class_named
-    @c2.classes_hash['C2'] = @c2
-
-    assert_nil @c2.find_class_named('C1')
-  end
-
-  def test_merge
-    cm1 = RDoc::ClassModule.new 'Klass'
-    cm1.comment = 'klass 1'
-    cm1.add_attribute RDoc::Attr.new(nil, 'a1', 'RW', '')
-    cm1.add_attribute RDoc::Attr.new(nil, 'a3', 'R', '')
-    cm1.add_constant RDoc::Constant.new('C1', nil, '')
-    cm1.add_include RDoc::Include.new('I1', '')
-    cm1.add_method RDoc::AnyMethod.new(nil, 'm1')
-
-    cm2 = RDoc::ClassModule.new 'Klass'
-    cm2.instance_variable_set(:@comment,
-                              @RM::Document.new(
-                                @RM::Paragraph.new('klass 2')))
-    cm2.add_attribute RDoc::Attr.new(nil, 'a2', 'RW', '')
-    cm2.add_attribute RDoc::Attr.new(nil, 'a3', 'W', '')
-    cm2.add_constant RDoc::Constant.new('C2', nil, '')
-    cm2.add_include RDoc::Include.new('I2', '')
-    cm2.add_method RDoc::AnyMethod.new(nil, 'm2')
-
-    cm1.merge cm2
-
-    document = @RM::Document.new(
-      @RM::Paragraph.new('klass 2'),
-      @RM::Paragraph.new('klass 1'))
-
-    assert_equal document, cm1.comment
-
-    expected = [
-      RDoc::Attr.new(nil, 'a1', 'RW', ''),
-      RDoc::Attr.new(nil, 'a2', 'RW', ''),
-      RDoc::Attr.new(nil, 'a3', 'RW', ''),
-    ]
-
-    expected.each do |a| a.parent = cm1 end
-    assert_equal expected, cm1.attributes.sort
-
-    expected = [
-      RDoc::Constant.new('C1', nil, ''),
-      RDoc::Constant.new('C2', nil, ''),
-    ]
-
-    expected.each do |c| c.parent = cm1 end
-    assert_equal expected, cm1.constants.sort
-
-    expected = [
-      RDoc::Include.new('I1', ''),
-      RDoc::Include.new('I2', ''),
-    ]
-
-    expected.each do |i| i.parent = cm1 end
-    assert_equal expected, cm1.includes.sort
-
-    expected = [
-      RDoc::AnyMethod.new(nil, 'm1'),
-      RDoc::AnyMethod.new(nil, 'm2'),
-    ]
-
-    expected.each do |m| m.parent = cm1 end
-    assert_equal expected, cm1.method_list.sort
-  end
-
-  def test_remove_nodoc_children
-    parent = RDoc::ClassModule.new 'A'
-    parent.modules_hash.replace 'B' => true, 'C' => true
-    RDoc::TopLevel.all_modules_hash.replace 'A::B' => true
-
-    parent.classes_hash.replace 'D' => true, 'E' => true
-    RDoc::TopLevel.all_classes_hash.replace 'A::D' => true
-
-    parent.remove_nodoc_children
-
-    assert_equal %w[B], parent.modules_hash.keys
-    assert_equal %w[D], parent.classes_hash.keys
-  end
-
-  def test_superclass
-    assert_equal @c3_h1, @c3_h2.superclass
-  end
-
-  def test_update_aliases_class
-    n1 = @xref_data.add_module RDoc::NormalClass, 'N1'
-    n1_k2 = n1.add_module RDoc::NormalClass, 'N2'
-
-    n1.add_module_alias n1_k2, 'A1'
-
-    n1_a1_c = n1.constants.find { |c| c.name == 'A1' }
-    refute_nil n1_a1_c
-    assert_equal n1_k2, n1_a1_c.is_alias_for, 'sanity check'
-
-    n1.update_aliases
-
-    n1_a1_k = @xref_data.find_class_or_module 'N1::A1'
-    refute_nil n1_a1_k
-    assert_equal n1_k2, n1_a1_k.is_alias_for
-    refute_equal n1_k2, n1_a1_k
-
-    assert_equal 1, n1_k2.aliases.length
-    assert_equal n1_a1_k, n1_k2.aliases.first
-
-    assert_equal 'N1::N2', n1_k2.full_name
-    assert_equal 'N1::A1', n1_a1_k.full_name
-  end
-
-  def test_update_aliases_module
-    n1 = @xref_data.add_module RDoc::NormalModule, 'N1'
-    n1_n2 = n1.add_module RDoc::NormalModule, 'N2'
-
-    n1.add_module_alias n1_n2, 'A1'
-
-    n1_a1_c = n1.constants.find { |c| c.name == 'A1' }
-    refute_nil n1_a1_c
-    assert_equal n1_n2, n1_a1_c.is_alias_for, 'sanity check'
-
-    n1.update_aliases
-
-    n1_a1_m = @xref_data.find_class_or_module 'N1::A1'
-    refute_nil n1_a1_m
-    assert_equal n1_n2, n1_a1_m.is_alias_for
-    refute_equal n1_n2, n1_a1_m
-
-    assert_equal 1, n1_n2.aliases.length
-    assert_equal n1_a1_m, n1_n2.aliases.first
-
-    assert_equal 'N1::N2', n1_n2.full_name
-    assert_equal 'N1::A1', n1_a1_m.full_name
-  end
-
-  def test_update_aliases_reparent
-    l1 = @xref_data.add_module RDoc::NormalModule, 'L1'
-    l1_l2 = l1.add_module RDoc::NormalModule, 'L2'
-    o1 = @xref_data.add_module RDoc::NormalModule, 'O1'
-
-    o1.add_module_alias l1_l2, 'A1'
-
-    o1_a1_c = o1.constants.find { |c| c.name == 'A1' }
-    refute_nil o1_a1_c
-    assert_equal l1_l2, o1_a1_c.is_alias_for
-    refute_equal l1_l2, o1_a1_c
-
-    o1.update_aliases
-
-    o1_a1_m = @xref_data.find_class_or_module 'O1::A1'
-    refute_nil o1_a1_m
-    assert_equal l1_l2, o1_a1_m.is_alias_for
-
-    assert_equal 1, l1_l2.aliases.length
-    assert_equal o1_a1_m, l1_l2.aliases[0]
-
-    assert_equal 'L1::L2', l1_l2.full_name
-    assert_equal 'O1::A1', o1_a1_m.full_name
-  end
-
-  def test_update_includes
-    a = RDoc::Include.new 'M1', nil
-    b = RDoc::Include.new 'M2', nil
-    c = RDoc::Include.new 'C', nil
-
-    @c1.add_include a
-    @c1.add_include b
-    @c1.add_include c
-    @c1.ancestors # cache included modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert RDoc::TopLevel.all_modules_hash.key? @m1_m2.full_name
-    refute RDoc::TopLevel.all_modules_hash[@m1_m2.full_name].nil?
-    RDoc::TopLevel.remove_nodoc RDoc::TopLevel.all_modules_hash
-    refute RDoc::TopLevel.all_modules_hash.key? @m1_m2.full_name
-
-    @c1.update_includes
-
-    assert_equal [a, c], @c1.includes
-  end
-
-  def test_update_includes_with_colons
-    a = RDoc::Include.new 'M1', nil
-    b = RDoc::Include.new 'M1::M2', nil
-    c = RDoc::Include.new 'C', nil
-
-    @c1.add_include a
-    @c1.add_include b
-    @c1.add_include c
-    @c1.ancestors # cache included modules
-
-    @m1_m2.document_self = nil
-    assert @m1_m2.remove_from_documentation?
-
-    assert RDoc::TopLevel.all_modules_hash.key? @m1_m2.full_name
-    refute RDoc::TopLevel.all_modules_hash[@m1_m2.full_name].nil?
-    RDoc::TopLevel.remove_nodoc RDoc::TopLevel.all_modules_hash
-    refute RDoc::TopLevel.all_modules_hash.key? @m1_m2.full_name
-
-    @c1.update_includes
-
-    assert_equal [a, c], @c1.includes
-  end
-
-end
-

data/test/test_rdoc_code_object.rb

@@ -1,165 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require File.expand_path '../xref_test_case', __FILE__
-require 'rdoc/code_object'
-
-class TestRDocCodeObject < XrefTestCase
-
-  def setup
-    super
-
-    @co = RDoc::CodeObject.new
-  end
-
-  def test_initialize
-    assert @co.document_self, 'document_self'
-    assert @co.document_children, 'document_children'
-    refute @co.force_documentation, 'force_documentation'
-    refute @co.done_documenting, 'done_documenting'
-    refute @co.received_nodoc, 'received_nodoc'
-    assert_equal '', @co.comment, 'comment is empty'
-  end
-
-  def test_comment_equals
-    @co.comment = ''
-
-    assert_equal '', @co.comment
-
-    @co.comment = 'I am a comment'
-
-    assert_equal 'I am a comment', @co.comment
-  end
-
-  def test_document_children_equals
-    @co.document_children = false
-    refute @co.document_children
-
-    # TODO this is not true anymore:
-    # test all the nodoc stuff etc...
-    #@c2.document_children = false
-    #assert_empty @c2.classes
-  end
-
-  def test_document_self_equals
-    @co.document_self = false
-    refute @co.document_self
-
-    # TODO this is not true anymore:
-    # test all the nodoc stuff etc...
-    #@c1.document_self = false
-    #assert_empty @c1.method_list
-  end
-
-  def test_documented_eh
-    refute @co.documented?
-
-    @co.comment = 'hi'
-
-    assert @co.documented?
-
-    @co.comment.replace ''
-
-    refute @co.documented?
-
-    @co.document_self = nil # notify :nodoc:
-
-    assert @co.documented?
-  end
-
-  def test_done_documenting
-    # once done_documenting is set, other properties refuse to go to "true"
-    @co.done_documenting = true
-
-    @co.document_self = true
-    refute @co.document_self
-
-    @co.document_children = true
-    refute @co.document_children
-
-    @co.force_documentation = true
-    refute @co.force_documentation
-
-    @co.start_doc
-    refute @co.document_self
-    refute @co.document_children
-
-    # turning done_documenting on
-    # resets others to true
-
-    @co.done_documenting = false
-    assert @co.document_self
-    assert @co.document_children
-  end
-
-  def test_full_name_equals
-    @co.full_name = 'hi'
-
-    assert_equal 'hi', @co.instance_variable_get(:@full_name)
-
-    @co.full_name = nil
-
-    assert_nil @co.instance_variable_get(:@full_name)
-  end
-
-  def test_metadata
-    assert_empty @co.metadata
-
-    @co.metadata['markup'] = 'not_rdoc'
-
-    expected = { 'markup' => 'not_rdoc' }
-
-    assert_equal expected, @co.metadata
-
-    assert_equal 'not_rdoc', @co.metadata['markup']
-  end
-
-  def test_parent_file_name
-    assert_equal '(unknown)', @co.parent_file_name
-    assert_equal 'xref_data.rb', @c1.parent_file_name
-  end
-
-  def test_parent_name
-    assert_equal '(unknown)', @co.parent_name
-    assert_equal 'xref_data.rb', @c1.parent_name
-    assert_equal 'C2', @c2_c3.parent_name
-  end
-
-  def test_received_ndoc
-    @co.document_self = false
-    refute @co.received_nodoc
-
-    @co.document_self = nil
-    assert @co.received_nodoc
-
-    @co.document_self = true
-  end
-
-  def test_record_location
-    c = RDoc::CodeObject.new
-    c.record_location @xref_data
-
-    assert_equal 'xref_data.rb', c.file.relative_name
-  end
-
-  def test_start_doc
-    @co.document_self = false
-    @co.document_children = false
-
-    @co.start_doc
-
-    assert @co.document_self
-    assert @co.document_children
-  end
-
-  def test_stop_doc
-    @co.document_self = true
-    @co.document_children = true
-
-    @co.stop_doc
-
-    refute @co.document_self
-    refute @co.document_children
-  end
-
-end
-

data/test/test_rdoc_constant.rb

@@ -1,15 +0,0 @@
-require File.expand_path '../xref_test_case', __FILE__
-
-class TestRDocConstant < XrefTestCase
-
-  def setup
-    super
-
-    @const = @c1.constants.first
-  end
-
-  def test_path
-    assert_equal 'C1.html#CONST', @const.path
-  end
-
-end