rdoc 4.3.0 → 5.0.0.beta1

data/test/test_rdoc_parser_simple.rb

@@ -1,115 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocParserSimple < RDoc::TestCase
-
-  def setup
-    super
-
-    @tempfile = Tempfile.new self.class.name
-    filename = @tempfile.path
-
-    @top_level = @store.add_file filename
-    @fn = filename
-    @options = RDoc::Options.new
-    @stats = RDoc::Stats.new @store, 0
-  end
-
-  def teardown
-    super
-
-    @tempfile.close!
-  end
-
-  def test_initialize_metadata
-    parser = util_parser ":unhandled: \n"
-
-    assert_includes @top_level.metadata, 'unhandled'
-
-    assert_equal ":unhandled: \n", parser.content
-  end
-
-  def test_remove_coding_comment
-    parser = util_parser <<-TEXT
-# -*- mode: rdoc; coding: utf-8; fill-column: 74; -*-
-
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    TEXT
-
-    parser.scan
-
-    expected = <<-TEXT.strip
-Regular expressions (<i>regexp</i>s) are patterns which describe the
-contents of a string.
-    TEXT
-
-    assert_equal expected, @top_level.comment.text
-  end
-
-  # RDoc stops processing comments if it finds a comment line CONTAINING
-  # '<tt>#--</tt>'. This can be used to separate external from internal
-  # comments, or to stop a comment being associated with a method,
-  # class, or module. Commenting CAN be turned back on with
-  # a line that STARTS '<tt>#++</tt>'.
-  #
-  # I've seen guys that comment their code like this:
-  #   # This method....
-  #   #-----------------
-  #   def method
-  #
-  # => either we do it only in ruby code, or we require the leading #
-  #    (to avoid conflict with rules).
-  #
-  #   TODO: require the leading #, to provide the feature in simple text files.
-  #   Note: in ruby & C code, we require '#--' & '#++' or '*--' & '*++',
-  #   to allow rules:
-  #
-  #   # this is a comment
-  #   #---
-  #   # private text
-  #   #+++
-  #   # this is a rule:
-  #   # ---
-
-  def test_remove_private_comments
-    parser = util_parser "foo\n\n--\nbar\n++\n\nbaz\n"
-
-    parser.scan
-
-    expected = "foo\n\n\nbaz"
-
-    assert_equal expected, @top_level.comment.text
-  end
-
-  def test_remove_private_comments_rule
-    parser = util_parser "foo\n---\nbar"
-
-    parser.scan
-
-    expected = "foo\n---\nbar"
-
-    assert_equal expected, @top_level.comment.text
-  end
-
-  def test_remove_private_comments_star
-    parser = util_parser "* foo\n* bar\n"
-
-    parser.scan
-
-    assert_equal "* foo\n* bar", @top_level.comment.text
-  end
-
-  def test_scan
-    parser = util_parser 'it *really* works'
-
-    parser.scan
-
-    assert_equal 'it *really* works', @top_level.comment.text
-  end
-
-  def util_parser(content)
-    RDoc::Parser::Simple.new @top_level, @fn, content, @options, @stats
-  end
-
-end
-

data/test/test_rdoc_rd.rb

@@ -1,30 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocRd < RDoc::TestCase
-
-  def test_class_parse
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::RD.parse("hello")
-  end
-
-  def test_class_parse_begin_end
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::RD.parse("=begin\nhello\n=end\n")
-  end
-
-  def test_class_parse_newline
-    expected =
-      @RM::Document.new(
-        @RM::Paragraph.new('hello'))
-
-    assert_equal expected, RDoc::RD.parse("hello\n")
-  end
-
-end
-

data/test/test_rdoc_rd_block_parser.rb

@@ -1,535 +0,0 @@
-require 'rdoc/test_case'
-
-class TestRDocRdBlockParser < RDoc::TestCase
-
-  def setup
-    super
-
-    @block_parser = RDoc::RD::BlockParser.new
-  end
-
-  def test_add_footnote
-    index = @block_parser.add_footnote 'context'
-
-    assert_equal 1, index
-
-    expected = [
-      para('{^1}[rdoc-label:footmark-1:foottext-1]', ' ', 'context'),
-      blank_line,
-    ]
-
-    assert_equal expected, @block_parser.footnotes
-
-    index = @block_parser.add_footnote 'other'
-
-    assert_equal 2, index
-  end
-
-  def test_parse_desclist
-    list = <<-LIST
-:one
-  desc one
-:two
-  desc two
-    LIST
-
-    expected =
-      doc(
-        list(:NOTE,
-          item("one", para("desc one")),
-          item("two", para("desc two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist
-    list = <<-LIST
-(1) one
-(1) two
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil, para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_paragraphs
-    list = <<-LIST
-(1) one
-
-    two
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil,
-            para("one"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_multiline
-    list = <<-LIST
-(1) one
-    two
-    LIST
-
-    contents = "one\n     two" # 1.8 vs 1.9
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para(*contents))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_verbatim
-    list = <<-LIST
-(1) item
-      verbatim
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil,
-            para("item"),
-            verb("verbatim\n"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_enumlist_verbatim_continue
-    list = <<-LIST
-(1) one
-      verbatim
-    two
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil,
-            para("one"),
-            verb("verbatim\n"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_footnote
-    expected =
-      doc(
-        para("{*1}[rdoc-label:foottext-1:footmark-1]"),
-        rule(1),
-        para("{^1}[rdoc-label:footmark-1:foottext-1]", " ", "text"),
-        blank_line)
-
-    assert_equal expected, parse("((-text-))")
-  end
-
-  def test_parse_include
-    @block_parser.include_path = [Dir.tmpdir]
-
-    expected = doc(@RM::Include.new("parse_include", [Dir.tmpdir]))
-
-    assert_equal expected, parse("<<< parse_include")
-  end
-
-  def test_parse_include_subtree
-    @block_parser.include_path = [Dir.tmpdir]
-
-    expected =
-      doc(
-        blank_line,
-        para("include <em>worked</em>"),
-        blank_line,
-        blank_line)
-
-    tf = Tempfile.open %w[parse_include .rd] do |io|
-      io.puts "=begin\ninclude ((*worked*))\n=end"
-      io.flush
-
-      str = <<-STR
-<<< #{File.basename io.path}
-      STR
-
-      assert_equal expected, parse(str)
-      io
-    end
-    tf.close! if tf.respond_to? :close!
-  end
-
-  def test_parse_heading
-    assert_equal doc(head(1, "H")), parse("= H")
-    assert_equal doc(head(2, "H")), parse("== H")
-    assert_equal doc(head(3, "H")), parse("=== H")
-    assert_equal doc(head(4, "H")), parse("==== H")
-    assert_equal doc(head(5, "H")), parse("+ H")
-    assert_equal doc(head(6, "H")), parse("++ H")
-  end
-
-  def test_parse_itemlist
-    list = <<-LIST
-* one
-* two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil, para("one")),
-          item(nil, para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_multiline
-    list = <<-LIST
-* one
-  two
-    LIST
-
-    contents = "one\n   two" # 1.8 vs 1.9
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil, para(*contents))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_nest
-    list = <<-LIST
-* one
-  * inner
-* two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("one"),
-            list(:BULLET,
-              item(nil, para("inner")))),
-          item(nil,
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_paragraphs
-    list = <<-LIST
-* one
-
-  two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("one"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_verbatim
-    list = <<-LIST
-* item
-    verbatim
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("item"),
-            verb("verbatim\n"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_itemlist_verbatim_continue
-    list = <<-LIST
-* one
-    verbatim
-  two
-    LIST
-
-    expected =
-      doc(
-        list(:BULLET,
-          item(nil,
-            para("one"),
-            verb("verbatim\n"),
-            para("two"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists
-    list = <<-LIST
-(1) one
-(1) two
-* three
-* four
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil, para("two"))),
-        list(:BULLET,
-          item(nil, para("three")),
-          item(nil, para("four"))),
-        list(:NUMBER,
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists_nest
-    list = <<-LIST
-(1) one
-(1) two
-      * three
-      * four
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil,
-            para("two"),
-            list(:BULLET,
-              item(nil, para("three")),
-              item(nil, para("four")))),
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists_nest_verbatim
-    list = <<-LIST
-(1) one
-(1) two
-      * three
-      * four
-     verbatim
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil,
-            para("two"),
-            list(:BULLET,
-              item(nil, para("three")),
-              item(nil, para("four"))),
-            verb("verbatim\n")),
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_lists_nest_verbatim2
-    list = <<-LIST
-(1) one
-(1) two
-      * three
-      * four
-      verbatim
-(1) five
-(1) six
-    LIST
-
-    expected =
-      doc(
-        list(:NUMBER,
-          item(nil, para("one")),
-          item(nil,
-            para("two"),
-            list(:BULLET,
-              item(nil, para("three")),
-              item(nil, para("four"))),
-            verb("verbatim\n")),
-          item(nil, para("five")),
-          item(nil, para("six"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist
-    list = <<-LIST
---- Array#each {|i| ... }
-      yield block for each item.
---- Array#index(val)
-      return index of first item which equals with val. if it hasn't
-      same item, return nil.
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>Array#each {|i| ... }</tt>",
-            para("yield block for each item.")),
-          item(
-            "<tt>Array#index(val)</tt>",
-            para("return index of first item which equals with val. if it hasn't same item, return nil."))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_empty
-    list = <<-LIST
---- A#b
-
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item("<tt>A#b</tt>")))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_paragraph
-    list = <<-LIST
---- A#b
-
-    one
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>A#b</tt>",
-            para("one"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_paragraph2
-    list = <<-LIST.chomp
---- A#b
-
-    one
-two
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>A#b</tt>",
-            para("one"))),
-        para("two"))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_methodlist_paragraph_verbatim
-    list = <<-LIST.chomp
---- A#b
-
-    text
-      verbatim
-    LIST
-
-    expected =
-      doc(
-        list(:LABEL,
-          item(
-            "<tt>A#b</tt>",
-            para("text"),
-            verb("verbatim\n"))))
-
-    assert_equal expected, parse(list)
-  end
-
-  def test_parse_verbatim
-    assert_equal doc(verb("verbatim\n")), parse("  verbatim")
-  end
-
-  def test_parse_verbatim_blankline
-    expected = doc(verb("one\n", "\n", "two\n"))
-
-    verbatim = <<-VERBATIM
-  one
-
-  two
-    VERBATIM
-
-    assert_equal expected, parse(verbatim)
-  end
-
-  def test_parse_verbatim_indent
-    expected = doc(verb("one\n", " two\n"))
-
-    verbatim = <<-VERBATIM
-  one
-   two
-    VERBATIM
-
-    assert_equal expected, parse(verbatim)
-  end
-
-  def test_parse_verbatim_multi
-    expected = doc(verb("one\n", "two\n"))
-
-    verbatim = <<-VERBATIM
-  one
-  two
-    VERBATIM
-
-    assert_equal expected, parse(verbatim)
-  end
-
-  def test_parse_textblock
-    assert_equal doc(para("text")), parse("text")
-  end
-
-  def test_parse_textblock_multi
-    expected = doc(para("one two"))
-
-    assert_equal expected, parse("one\ntwo")
-  end
-
-  def parse text
-    text = ["=begin", text, "=end"].join "\n"
-
-    doc = @block_parser.parse text.lines.to_a
-
-    assert_equal blank_line, doc.parts.shift, "=begin blankline"
-    assert_equal blank_line, doc.parts.pop, "=end blankline"
-
-    doc
-  end
-
-end