rdoc 2.5.11 → 3.0

data/test/test_attribute_manager.rb

@@ -2,13 +2,35 @@ require 'rubygems'
 require 'minitest/autorun'
 require 'rdoc'
 require 'rdoc/markup'
+require 'rdoc/markup/formatter'
 require 'rdoc/markup/attribute_manager'
 
-class TestAttributeManager < MiniTest::Unit::TestCase
+class TestAttributeManager < MiniTest::Unit::TestCase # HACK fix test name
 
   def setup
     @am = RDoc::Markup::AttributeManager.new
     @klass = RDoc::Markup::AttributeManager
+    @formatter = RDoc::Markup::Formatter.new
+    @formatter.add_tag :BOLD, '<B>', '</B>'
+    @formatter.add_tag :EM, '<EM>', '</EM>'
+    @formatter.add_tag :TT, '<TT>', '</TT>'
+  end
+
+  def test_convert_attrs_ignores_code
+    assert_equal 'foo <TT>__send__</TT> bar', output('foo <code>__send__</code> bar')
+  end
+
+  def test_convert_attrs_ignores_tt
+    assert_equal 'foo <TT>__send__</TT> bar', output('foo <tt>__send__</tt> bar')
+  end
+
+  def test_convert_attrs_preserves_double
+    assert_equal 'foo.__send__ :bar', output('foo.__send__ :bar')
+    assert_equal 'use __FILE__ to', output('use __FILE__ to')
+  end
+
+  def test_convert_attrs_does_not_ignore_after_tt
+    assert_equal 'the <TT>IF:</TT><EM>key</EM> directive', output('the <tt>IF:</tt>_key_ directive')
   end
 
   def test_initial_word_pairs
@@ -57,12 +79,41 @@ class TestAttributeManager < MiniTest::Unit::TestCase
     assert(specials.has_key?("WikiWord"))
   end
 
-  def silently(&block)
-    warn_level = $VERBOSE
-    $VERBOSE = nil
-    result = block.call
-    $VERBOSE = warn_level
-    result
+  def test_escapes
+    assert_equal '<TT>text</TT>',   output('<tt>text</tt>')
+    assert_equal '<tt>text</tt>',   output('\\<tt>text</tt>')
+    assert_equal '<tt>',            output('\\<tt>')
+    assert_equal '<TT><tt></TT>',   output('<tt>\\<tt></tt>')
+    assert_equal '<TT>\\<tt></TT>', output('<tt>\\\\<tt></tt>')
+    assert_equal '<B>text</B>',     output('*text*')
+    assert_equal '*text*',          output('\\*text*')
+    assert_equal '\\',              output('\\')
+    assert_equal '\\text',          output('\\text')
+    assert_equal '\\\\text',        output('\\\\text')
+    assert_equal 'text \\ text',    output('text \\ text')
+
+    assert_equal 'and <TT>\\s</TT> matches space',
+                 output('and <tt>\\s</tt> matches space')
+    assert_equal 'use <TT><tt>text</TT></tt> for code',
+                 output('use <tt>\\<tt>text</tt></tt> for code')
+    assert_equal 'use <TT><tt>text</tt></TT> for code',
+                 output('use <tt>\\<tt>text\\</tt></tt> for code')
+    assert_equal 'use <tt><tt>text</tt></tt> for code',
+                 output('use \\<tt>\\<tt>text</tt></tt> for code')
+    assert_equal 'use <tt><TT>text</TT></tt> for code',
+                 output('use \\<tt><tt>text</tt></tt> for code')
+    assert_equal 'use <TT>+text+</TT> for code',
+                 output('use <tt>\\+text+</tt> for code')
+    assert_equal 'use <tt><TT>text</TT></tt> for code',
+                 output('use \\<tt>+text+</tt> for code')
+    assert_equal 'illegal <tag>not</tag> changed',
+                 output('illegal <tag>not</tag> changed')
+    assert_equal 'unhandled <p>tag</p> unchanged',
+                 output('unhandled <p>tag</p> unchanged')
+  end
+
+  def output str
+    @formatter.convert_flow @am.flow str
   end
 
 end

data/test/test_rdoc_alias.rb

@@ -0,0 +1,13 @@
+require File.expand_path '../xref_test_case', __FILE__
+
+class TestRDocAlias < XrefTestCase
+
+  def test_to_s
+    a = RDoc::Alias.new nil, 'a', 'b', ''
+    a.parent = @c2
+
+    assert_equal 'alias: b -> #a in: RDoc::NormalClass C2 < Object', a.to_s
+  end
+
+end
+

data/test/test_rdoc_any_method.rb

@@ -1,15 +1,17 @@
 require File.expand_path '../xref_test_case', __FILE__
+require 'rdoc/code_objects'
+require 'rdoc/generator/markup'
 
 class RDocAnyMethodTest < XrefTestCase
 
   def test_aref
     m = RDoc::AnyMethod.new nil, 'method?'
 
-    assert_equal 'method-i-method%3F', m.aref
+    assert_equal 'method-i-method-3F', m.aref
 
     m.singleton = true
 
-    assert_equal 'method-c-method%3F', m.aref
+    assert_equal 'method-c-method-3F', m.aref
   end
 
   def test_arglists
@@ -36,6 +38,45 @@ method(a, b) { |c, d| ... }
     assert_equal 'C1::m', @c1.method_list.first.full_name
   end
 
+  def test_markup_code
+    tokens = [
+      RDoc::RubyToken::TkCONSTANT. new(0, 0, 0, 'CONSTANT'),
+      RDoc::RubyToken::TkKW.       new(0, 0, 0, 'KW'),
+      RDoc::RubyToken::TkIVAR.     new(0, 0, 0, 'IVAR'),
+      RDoc::RubyToken::TkOp.       new(0, 0, 0, 'Op'),
+      RDoc::RubyToken::TkId.       new(0, 0, 0, 'Id'),
+      RDoc::RubyToken::TkNode.     new(0, 0, 0, 'Node'),
+      RDoc::RubyToken::TkCOMMENT.  new(0, 0, 0, 'COMMENT'),
+      RDoc::RubyToken::TkREGEXP.   new(0, 0, 0, 'REGEXP'),
+      RDoc::RubyToken::TkSTRING.   new(0, 0, 0, 'STRING'),
+      RDoc::RubyToken::TkVal.      new(0, 0, 0, 'Val'),
+      RDoc::RubyToken::TkBACKSLASH.new(0, 0, 0, '\\'),
+    ]
+
+    @c2_a.collect_tokens
+    @c2_a.add_tokens(*tokens)
+
+    expected = [
+      '<span class="ruby-constant">CONSTANT</span>',
+      '<span class="ruby-keyword">KW</span>',
+      '<span class="ruby-ivar">IVAR</span>',
+      '<span class="ruby-operator">Op</span>',
+      '<span class="ruby-identifier">Id</span>',
+      '<span class="ruby-node">Node</span>',
+      '<span class="ruby-comment">COMMENT</span>',
+      '<span class="ruby-regexp">REGEXP</span>',
+      '<span class="ruby-string">STRING</span>',
+      '<span class="ruby-value">Val</span>',
+      '\\'
+    ].join
+
+    assert_equal expected, @c2_a.markup_code
+  end
+
+  def test_markup_code_empty
+    assert_equal '', @c2_a.markup_code
+  end
+
   def test_marshal_load
     instance_method = Marshal.load Marshal.dump(@c1.method_list.last)
 

data/test/test_rdoc_attr.rb

@@ -26,6 +26,18 @@ class TestRDocAttr < MiniTest::Unit::TestCase
     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
@@ -39,15 +51,10 @@ class TestRDocAttr < MiniTest::Unit::TestCase
   end
 
   def test_type
-    assert_equal 'attr_accessor', @a.type
-
-    @a.rw = 'R'
-
-    assert_equal 'attr_reader', @a.type
-
-    @a.rw = 'W'
+    assert_equal 'instance', @a.type
 
-    assert_equal 'attr_writer', @a.type
+    @a.singleton = true
+    assert_equal 'class', @a.type
   end
 
 end

data/test/test_rdoc_class_module.rb

@@ -92,9 +92,142 @@ class TestRDocClassModule < XrefTestCase
     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

@@ -16,6 +16,7 @@ class TestRDocCodeObject < XrefTestCase
     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
 
@@ -33,16 +34,20 @@ class TestRDocCodeObject < XrefTestCase
     @co.document_children = false
     refute @co.document_children
 
-    @c2.document_children = false
-    assert_empty @c2.classes
+    # 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
 
-    @c1.document_self = false
-    assert_empty @c1.method_list
+    # 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
@@ -56,11 +61,46 @@ class TestRDocCodeObject < XrefTestCase
 
     refute @co.documented?
 
-    @co.document_self = false
+    @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
 
@@ -84,6 +124,23 @@ class TestRDocCodeObject < XrefTestCase
     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