rdoc 4.2.1 → 6.3.1

data/test/test_rdoc_markup.rb

@@ -1,95 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocMarkup < RDoc::TestCase
-
-  def test_class_parse
-    expected = @RM::Document.new(
-      @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::Markup.parse('hello')
-  end
-
-  def test_convert
-    str = <<-STR
-now is
-the time
-
-  hello
-  dave
-
-1. l1
-2. l2
-    STR
-
-    m = RDoc::Markup.new
-
-    tt = RDoc::Markup::ToTest.new m
-
-    out = m.convert str, tt
-
-    expected = [
-      "now is the time",
-      "\n",
-      "  hello\n  dave\n",
-      "1: ",
-      "l1",
-      "1: ",
-      "l2",
-    ]
-
-    assert_equal expected, out
-  end
-
-  def test_convert_custom_markup
-    str = <<-STR
-{stricken}
-    STR
-
-    m = RDoc::Markup.new
-    m.add_word_pair '{', '}', :STRIKE
-
-    tt = RDoc::Markup::ToTest.new nil, m
-    tt.add_tag :STRIKE, 'STRIKE ', ' STRIKE'
-
-    out = m.convert str, tt
-
-    expected = [
-      "STRIKE stricken STRIKE",
-    ]
-
-    assert_equal expected, out
-  end
-
-  def test_convert_document
-    doc = RDoc::Markup::Parser.parse <<-STR
-now is
-the time
-
-  hello
-  dave
-
-1. l1
-2. l2
-    STR
-
-    m = RDoc::Markup.new
-
-    tt = RDoc::Markup::ToTest.new m
-
-    out = m.convert doc, tt
-
-    expected = [
-      "now is the time",
-      "\n",
-      "  hello\n  dave\n",
-      "1: ",
-      "l1",
-      "1: ",
-      "l2",
-    ]
-
-    assert_equal expected, out
-  end
-
-end
-

data/test/test_rdoc_markup_attribute_manager.rb

@@ -1,364 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocMarkupAttributeManager < RDoc::TestCase
-
-  def setup
-    super
-
-    @am = RDoc::Markup::AttributeManager.new
-
-    @bold_on  = @am.changed_attribute_by_name([], [:BOLD])
-    @bold_off = @am.changed_attribute_by_name([:BOLD], [])
-
-    @tt_on    = @am.changed_attribute_by_name([], [:TT])
-    @tt_off   = @am.changed_attribute_by_name([:TT], [])
-
-    @em_on    = @am.changed_attribute_by_name([], [:EM])
-    @em_off   = @am.changed_attribute_by_name([:EM], [])
-
-    @bold_em_on   = @am.changed_attribute_by_name([], [:BOLD] | [:EM])
-    @bold_em_off  = @am.changed_attribute_by_name([:BOLD] | [:EM], [])
-
-    @em_then_bold = @am.changed_attribute_by_name([:EM], [:EM] | [:BOLD])
-
-    @em_to_bold   = @am.changed_attribute_by_name([:EM], [:BOLD])
-
-    @am.add_word_pair("{", "}", :WOMBAT)
-    @wombat_on    = @am.changed_attribute_by_name([], [:WOMBAT])
-    @wombat_off   = @am.changed_attribute_by_name([:WOMBAT], [])
-
-    @klass = RDoc::Markup::AttributeManager
-    @formatter = RDoc::Markup::Formatter.new @rdoc.options
-    @formatter.add_tag :BOLD, '<B>', '</B>'
-    @formatter.add_tag :EM, '<EM>', '</EM>'
-    @formatter.add_tag :TT, '<CODE>', '</CODE>'
-  end
-
-  def crossref(text)
-    crossref_bitmap = @am.attributes.bitmap_for(:_SPECIAL_) |
-                      @am.attributes.bitmap_for(:CROSSREF)
-
-    [ @am.changed_attribute_by_name([], [:CROSSREF, :_SPECIAL_]),
-      RDoc::Markup::Special.new(crossref_bitmap, text),
-      @am.changed_attribute_by_name([:CROSSREF, :_SPECIAL_], [])
-    ]
-  end
-
-  def test_adding
-    assert_equal(["cat ", @wombat_on, "and", @wombat_off, " dog" ],
-                  @am.flow("cat {and} dog"))
-    #assert_equal(["cat {and} dog" ], @am.flow("cat \\{and} dog"))
-  end
-
-  def test_add_html_tag
-    @am.add_html("Test", :TEST)
-    tags = @am.html_tags
-    assert_equal(6, tags.size)
-    assert(tags.has_key?("test"))
-  end
-
-  def test_add_special
-    @am.add_special "WikiWord", :WIKIWORD
-    specials = @am.special
-
-    assert_equal 1, specials.size
-    assert specials.assoc "WikiWord"
-  end
-
-  def test_add_word_pair
-    @am.add_word_pair '%', '&', 'percent and'
-
-    assert @am.word_pair_map.include?(/(%)(\S+)(&)/)
-    assert @am.protectable.include?('%')
-    assert !@am.protectable.include?('&')
-  end
-
-  def test_add_word_pair_angle
-    e = assert_raises ArgumentError do
-      @am.add_word_pair '<', '>', 'angles'
-    end
-
-    assert_equal "Word flags may not start with '<'", e.message
-  end
-
-  def test_add_word_pair_invalid
-    assert_raises ArgumentError do
-      @am.add_word_pair("<", "<", :TEST)
-    end
-  end
-
-  def test_add_word_pair_map
-    @am.add_word_pair("x", "y", :TEST)
-
-    word_pair_map = @am.word_pair_map
-
-    assert_includes word_pair_map.keys.map { |r| r.source }, "(x)(\\S+)(y)"
-  end
-
-  def test_add_word_pair_matching
-    @am.add_word_pair '^', '^', 'caret'
-
-    assert @am.matching_word_pairs.include?('^')
-    assert @am.protectable.include?('^')
-  end
-
-  def test_basic
-    assert_equal(["cat"], @am.flow("cat"))
-
-    assert_equal(["cat ", @bold_on, "and", @bold_off, " dog"],
-                  @am.flow("cat *and* dog"))
-
-    assert_equal(["cat ", @bold_on, "AND", @bold_off, " dog"],
-                  @am.flow("cat *AND* dog"))
-
-    assert_equal(["cat ", @em_on, "And", @em_off, " dog"],
-                  @am.flow("cat _And_ dog"))
-
-    assert_equal(["cat *and dog*"], @am.flow("cat *and dog*"))
-
-    assert_equal(["*cat and* dog"], @am.flow("*cat and* dog"))
-
-    assert_equal(["cat *and ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat *and *dog*"))
-
-    assert_equal(["cat ", @em_on, "and", @em_off, " dog"],
-                  @am.flow("cat _and_ dog"))
-
-    assert_equal(["cat_and_dog"],
-                  @am.flow("cat_and_dog"))
-
-    assert_equal(["cat ", @tt_on, "and", @tt_off, " dog"],
-                  @am.flow("cat +and+ dog"))
-
-    assert_equal(["cat ", @tt_on, "X::Y", @tt_off, " dog"],
-                  @am.flow("cat +X::Y+ dog"))
-
-    assert_equal(["cat ", @bold_on, "a_b_c", @bold_off, " dog"],
-                  @am.flow("cat *a_b_c* dog"))
-
-    assert_equal(["cat __ dog"],
-                  @am.flow("cat __ dog"))
-
-    assert_equal(["cat ", @em_on, "_", @em_off, " dog"],
-                  @am.flow("cat ___ dog"))
-
-    assert_equal(["cat and ", @em_on, "5", @em_off, " dogs"],
-                  @am.flow("cat and _5_ dogs"))
-  end
-
-  def test_bold
-    assert_equal [@bold_on, 'bold', @bold_off],
-                 @am.flow("*bold*")
-
-    assert_equal [@bold_on, 'Bold:', @bold_off],
-                 @am.flow("*Bold:*")
-
-    assert_equal [@bold_on, '\\bold', @bold_off],
-                 @am.flow("*\\bold*")
-  end
-
-  def test_bold_html_escaped
-    assert_equal ['cat <b>dog</b>'], @am.flow('cat \<b>dog</b>')
-  end
-
-  def test_combined
-    assert_equal(["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat _and_ *dog*"))
-
-    assert_equal(["cat ", @em_on, "a__nd", @em_off, " ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat _a__nd_ *dog*"))
-  end
-
-  def test_convert_attrs
-    str = '+foo+'
-    attrs = RDoc::Markup::AttrSpan.new str.length
-
-    @am.convert_attrs str, attrs
-
-    assert_equal "\000foo\000", str
-
-    str = '+:foo:+'
-    attrs = RDoc::Markup::AttrSpan.new str.length
-
-    @am.convert_attrs str, attrs
-
-    assert_equal "\000:foo:\000", str
-
-    str = '+x-y+'
-    attrs = RDoc::Markup::AttrSpan.new str.length
-
-    @am.convert_attrs str, attrs
-
-    assert_equal "\000x-y\000", str
-  end
-
-  def test_convert_attrs_ignores_code
-    assert_equal 'foo <CODE>__send__</CODE> bar', output('foo <code>__send__</code> bar')
-  end
-
-  def test_convert_attrs_ignores_tt
-    assert_equal 'foo <CODE>__send__</CODE> 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 <CODE>IF:</CODE><EM>key</EM> directive', output('the <tt>IF:</tt>_key_ directive')
-  end
-
-  def test_escapes
-    assert_equal '<CODE>text</CODE>',   output('<tt>text</tt>')
-    assert_equal '<tt>text</tt>',       output('\\<tt>text</tt>')
-    assert_equal '<tt>',                output('\\<tt>')
-    assert_equal '<CODE><tt></CODE>',   output('<tt>\\<tt></tt>')
-    assert_equal '<CODE>\\<tt></CODE>', 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 <CODE>\\s</CODE> matches space',
-                 output('and <tt>\\s</tt> matches space')
-    assert_equal 'use <CODE><tt>text</CODE></tt> for code',
-                 output('use <tt>\\<tt>text</tt></tt> for code')
-    assert_equal 'use <CODE><tt>text</tt></CODE> 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><CODE>text</CODE></tt> for code',
-                 output('use \\<tt><tt>text</tt></tt> for code')
-    assert_equal 'use <CODE>+text+</CODE> for code',
-                 output('use <tt>\\+text+</tt> for code')
-    assert_equal 'use <tt><CODE>text</CODE></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 test_html_like_em_bold
-    assert_equal ["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
-                  @am.flow("cat <i>and </i><b>dog</b>")
-  end
-
-  def test_html_like_em_bold_SGML
-    assert_equal ["cat ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
-                  @am.flow("cat <i>and <b></i>dog</b>")
-  end
-
-  def test_html_like_em_bold_nested_1
-    assert_equal(["cat ", @bold_em_on, "and", @bold_em_off, " dog"],
-                  @am.flow("cat <i><b>and</b></i> dog"))
-  end
-
-  def test_html_like_em_bold_nested_2
-    assert_equal ["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off],
-                  @am.flow("cat <i>and <b>dog</b></i>")
-  end
-
-  def test_html_like_em_bold_nested_mixed_case
-    assert_equal ["cat ", @em_on, "and ", @em_then_bold, "dog", @bold_em_off],
-                  @am.flow("cat <i>and <B>dog</B></I>")
-  end
-
-  def test_html_like_em_bold_mixed_case
-    assert_equal ["cat ", @em_on, "and", @em_off, " ", @bold_on, "dog", @bold_off],
-                  @am.flow("cat <i>and</i> <B>dog</b>")
-  end
-
-  def test_html_like_teletype
-    assert_equal ["cat ", @tt_on, "dog", @tt_off],
-                 @am.flow("cat <tt>dog</Tt>")
-  end
-
-  def test_html_like_teletype_em_bold_SGML
-    assert_equal [@tt_on, "cat", @tt_off, " ", @em_on, "and ", @em_to_bold, "dog", @bold_off],
-                  @am.flow("<tt>cat</tt> <i>and <b></i>dog</b>")
-  end
-
-  def test_initial_html
-    html_tags = @am.html_tags
-    assert html_tags.is_a?(Hash)
-    assert_equal(5, html_tags.size)
-  end
-
-  def test_initial_word_pairs
-    word_pairs = @am.matching_word_pairs
-    assert word_pairs.is_a?(Hash)
-    assert_equal(3, word_pairs.size)
-  end
-
-  def test_mask_protected_sequence
-    def @am.str()     @str       end
-    def @am.str=(str) @str = str end
-
-    @am.str = '<code>foo</code>'
-    @am.mask_protected_sequences
-
-    assert_equal "<code>foo</code>",       @am.str
-
-    @am.str = '<code>foo\\</code>'
-    @am.mask_protected_sequences
-
-    assert_equal "<code>foo<\x04/code>", @am.str, 'escaped close'
-
-    @am.str = '<code>foo\\\\</code>'
-    @am.mask_protected_sequences
-
-    assert_equal "<code>foo\\</code>",     @am.str, 'escaped backslash'
-  end
-
-  def test_protect
-    assert_equal(['cat \\ dog'],
-                 @am.flow('cat \\ dog'))
-
-    assert_equal(["cat <tt>dog</Tt>"],
-                 @am.flow("cat \\<tt>dog</Tt>"))
-
-    assert_equal(["cat ", @em_on, "and", @em_off, " <B>dog</b>"],
-                  @am.flow("cat <i>and</i> \\<B>dog</b>"))
-
-    assert_equal(["*word* or <b>text</b>"],
-                 @am.flow("\\*word* or \\<b>text</b>"))
-
-    assert_equal(["_cat_", @em_on, "dog", @em_off],
-                  @am.flow("\\_cat_<i>dog</i>"))
-  end
-
-  def test_special
-    @am.add_special(RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF)
-
-    #
-    # The apostrophes in "cats'" and "dogs'" suppress the flagging of these
-    # words as potential cross-references, which is necessary for the unit
-    # tests.  Unfortunately, the markup engine right now does not actually
-    # check whether a cross-reference is valid before flagging it.
-    #
-    assert_equal(["cats'"], @am.flow("cats'"))
-
-    assert_equal(["cats' ", crossref("#fred"), " dogs'"].flatten,
-                  @am.flow("cats' #fred dogs'"))
-
-    assert_equal([crossref("#fred"), " dogs'"].flatten,
-                  @am.flow("#fred dogs'"))
-
-    assert_equal(["cats' ", crossref("#fred")].flatten, @am.flow("cats' #fred"))
-  end
-
-  def test_tt_html
-    assert_equal [@tt_on, '"\n"', @tt_off],
-                 @am.flow('<tt>"\n"</tt>')
-  end
-
-  def output str
-    @formatter.convert_flow @am.flow str
-  end
-
-end
-

data/test/test_rdoc_markup_attributes.rb

@@ -1,39 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocMarkupAttributes < RDoc::TestCase
-
-  def setup
-    super
-
-    @as = RDoc::Markup::Attributes.new
-  end
-
-  def test_bitmap_for
-    assert_equal 2, @as.bitmap_for('two')
-    assert_equal 2, @as.bitmap_for('two')
-    assert_equal 4, @as.bitmap_for('three')
-  end
-
-  def test_as_string
-    @as.bitmap_for 'two'
-    @as.bitmap_for 'three'
-
-    assert_equal 'none',          @as.as_string(0)
-    assert_equal '_SPECIAL_',     @as.as_string(1)
-    assert_equal 'two',           @as.as_string(2)
-    assert_equal '_SPECIAL_,two', @as.as_string(3)
-  end
-
-  def test_each_name_of
-    @as.bitmap_for 'two'
-    @as.bitmap_for 'three'
-
-    assert_equal %w[],          @as.each_name_of(0).to_a
-    assert_equal %w[],          @as.each_name_of(1).to_a
-    assert_equal %w[two],       @as.each_name_of(2).to_a
-    assert_equal %w[three],     @as.each_name_of(4).to_a
-    assert_equal %w[two three], @as.each_name_of(6).to_a
-  end
-
-end
-

data/test/test_rdoc_markup_document.rb

@@ -1,207 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocMarkupDocument < RDoc::TestCase
-
-  def setup
-    super
-
-    @d = @RM::Document.new
-  end
-
-  def test_append
-    @d << @RM::Paragraph.new('hi')
-
-    expected = @RM::Document.new @RM::Paragraph.new('hi')
-
-    assert_equal expected, @d
-  end
-
-  def test_append_document
-    @d << @RM::Document.new
-
-    assert_empty @d
-
-    @d << @RM::Document.new(@RM::Paragraph.new('hi'))
-
-    expected = @RM::Document.new @RM::Paragraph.new('hi'), @RM::BlankLine.new
-
-    assert_equal expected, @d
-  end
-
-  def test_append_string
-    @d << ''
-
-    assert_empty @d
-
-    assert_raises ArgumentError do
-      @d << 'hi'
-    end
-  end
-
-  def test_concat
-    @d.concat [@RM::BlankLine.new, @RM::BlankLine.new]
-
-    refute_empty @d
-  end
-
-  def test_each
-    a = @RM::Document.new
-    b = @RM::Document.new(@RM::Paragraph.new('hi'))
-
-    @d.push a, b
-
-    assert_equal [a, b], @d.map { |sub_doc| sub_doc }
-  end
-
-  def test_empty_eh
-    assert_empty @d
-
-    @d << @RM::BlankLine.new
-
-    refute_empty @d
-  end
-
-  def test_empty_eh_document
-    d = @RM::Document.new @d
-
-    assert_empty d
-  end
-
-  def test_equals2
-    d2 = @RM::Document.new
-
-    assert_equal @d, d2
-
-    d2 << @RM::BlankLine.new
-
-    refute_equal @d, d2
-  end
-
-  def test_equals2_file
-    d2 = @RM::Document.new
-    d2.file = 'file.rb'
-
-    refute_equal @d, d2
-
-    @d.file = 'file.rb'
-
-    assert_equal @d, d2
-  end
-
-  def test_file_equals
-    @d.file = 'file.rb'
-
-    assert_equal 'file.rb', @d.file
-  end
-
-  def test_file_equals_top_level
-    @d.file = @store.add_file 'file.rb'
-
-    assert_equal 'file.rb', @d.file
-  end
-
-  def test_lt2
-    @d << @RM::BlankLine.new
-
-    refute_empty @d
-  end
-
-  def test_merge
-    original = @RM::Document.new @RM::Paragraph.new 'original'
-    original.file = 'file.rb'
-    root = @RM::Document.new original
-
-    replace = @RM::Document.new @RM::Paragraph.new 'replace'
-    replace.file = 'file.rb'
-
-    other = @RM::Document.new replace
-
-    result = root.merge other
-
-    inner = @RM::Document.new @RM::Paragraph.new 'replace'
-    inner.file = 'file.rb'
-    expected = @RM::Document.new inner
-
-    assert_equal expected, result
-  end
-
-  def test_merge_add
-    original = @RM::Document.new @RM::Paragraph.new 'original'
-    original.file = 'file.rb'
-    root = @RM::Document.new original
-
-    addition = @RM::Document.new @RM::Paragraph.new 'addition'
-    addition.file = 'other.rb'
-
-    other = @RM::Document.new addition
-
-    result = root.merge other
-
-    expected = @RM::Document.new original, addition
-
-    assert_equal expected, result
-  end
-
-  def test_merge_empty
-    original = @RM::Document.new
-    root = @RM::Document.new original
-
-    replace = @RM::Document.new @RM::Paragraph.new 'replace'
-    replace.file = 'file.rb'
-
-    other = @RM::Document.new replace
-
-    result = root.merge other
-
-    inner = @RM::Document.new @RM::Paragraph.new 'replace'
-    inner.file = 'file.rb'
-    expected = @RM::Document.new inner
-
-    assert_equal expected, result
-  end
-
-  def test_push
-    @d.push @RM::BlankLine.new, @RM::BlankLine.new
-
-    refute_empty @d
-  end
-
-  def test_table_of_contents
-    doc = @RM::Document.new(
-      @RM::Heading.new(1, 'A'),
-      @RM::Paragraph.new('B'),
-      @RM::Heading.new(2, 'C'),
-      @RM::Paragraph.new('D'),
-      @RM::Heading.new(1, 'E'),
-      @RM::Paragraph.new('F'))
-
-    expected = [
-      @RM::Heading.new(1, 'A'),
-      @RM::Heading.new(2, 'C'),
-      @RM::Heading.new(1, 'E'),
-    ]
-
-    assert_equal expected, doc.table_of_contents
-  end
-
-  def test_table_of_contents_omit_headings_below
-    document = doc(
-      head(1, 'A'),
-      para('B'),
-      head(2, 'C'),
-      para('D'),
-      head(1, 'E'),
-      para('F'))
-
-    document.omit_headings_below = 1
-
-    expected = [
-      head(1, 'A'),
-      head(1, 'E'),
-    ]
-
-    assert_equal expected, document.table_of_contents
-  end
-
-end
-