iownbey-rdoc 2.0.1

data/lib/rdoc/tokenstream.rb

@@ -0,0 +1,33 @@
+module RDoc; end
+
+##
+# A TokenStream is a list of tokens, gathered during the parse of some entity
+# (say a method). Entities populate these streams by being registered with the
+# lexer. Any class can collect tokens by including TokenStream. From the
+# outside, you use such an object by calling the start_collecting_tokens
+# method, followed by calls to add_token and pop_token.
+
+module RDoc::TokenStream
+
+  def token_stream
+    @token_stream
+  end
+
+  def start_collecting_tokens
+    @token_stream = []
+  end
+
+  def add_token(tk)
+    @token_stream << tk
+  end
+
+  def add_tokens(tks)
+    tks.each  {|tk| add_token(tk)}
+  end
+
+  def pop_token
+    @token_stream.pop
+  end
+
+end
+

data/test/test_rdoc_c_parser.rb

@@ -0,0 +1,261 @@
+require 'stringio'
+require 'tempfile'
+require 'test/unit'
+require 'rdoc/parsers/parse_c'
+
+class RDoc::C_Parser
+  attr_accessor :classes
+
+  public :do_classes, :do_constants
+end
+
+class TestRdocC_Parser < Test::Unit::TestCase
+
+  def setup
+    @tempfile = Tempfile.new self.class.name
+    filename = @tempfile.path
+
+    @top_level = RDoc::TopLevel.new filename
+    @fn = filename
+    @options = RDoc::Options.new Hash.new
+    @stats = RDoc::Stats.new
+
+    @progress = StringIO.new
+  end
+
+  def teardown
+    @tempfile.unlink
+  end
+
+  def test_do_classes_boot_class
+    content = <<-EOF
+/* Document-class: Foo
+ * this is the Foo boot class
+ */
+VALUE cFoo = boot_defclass("Foo", 0);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "   this is the Foo boot class\n   ", klass.comment
+  end
+
+  def test_do_classes_class
+    content = <<-EOF
+/* Document-class: Foo
+ * this is the Foo class
+ */
+VALUE cFoo = rb_define_class("Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "   this is the Foo class\n   ", klass.comment
+  end
+
+  def test_do_classes_class_under
+    content = <<-EOF
+/* Document-class: Kernel::Foo
+ * this is the Foo class under Kernel
+ */
+VALUE cFoo = rb_define_class_under(rb_mKernel, "Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'cFoo'
+    assert_equal "   this is the Foo class under Kernel\n   ", klass.comment
+  end
+
+  def test_do_classes_module
+    content = <<-EOF
+/* Document-module: Foo
+ * this is the Foo module
+ */
+VALUE mFoo = rb_define_module("Foo");
+    EOF
+
+    klass = util_get_class content, 'mFoo'
+    assert_equal "   this is the Foo module\n   ", klass.comment
+  end
+
+  def test_do_classes_module_under
+    content = <<-EOF
+/* Document-module: Kernel::Foo
+ * this is the Foo module under Kernel
+ */
+VALUE mFoo = rb_define_module_under(rb_mKernel, "Foo");
+    EOF
+
+    klass = util_get_class content, 'mFoo'
+    assert_equal "   this is the Foo module under Kernel\n   ", klass.comment
+  end
+
+  def test_do_constants
+    content = <<-EOF
+#include <ruby.h>
+
+void Init_foo(){
+   VALUE cFoo = rb_define_class("Foo", rb_cObject);
+
+   /* 300: The highest possible score in bowling */
+   rb_define_const(cFoo, "PERFECT", INT2FIX(300));
+
+   /* Huzzah!: What you cheer when you roll a perfect game */
+   rb_define_const(cFoo, "CHEER", rb_str_new2("Huzzah!"));
+
+   /* TEST\:TEST: Checking to see if escaped semicolon works */
+   rb_define_const(cFoo, "TEST", rb_str_new2("TEST:TEST"));
+
+   /* \\: The file separator on MS Windows */
+   rb_define_const(cFoo, "MSEPARATOR", rb_str_new2("\\"));
+
+   /* /: The file separator on Unix */
+   rb_define_const(cFoo, "SEPARATOR", rb_str_new2("/"));
+
+   /* C:\\Program Files\\Stuff: A directory on MS Windows */
+   rb_define_const(cFoo, "STUFF", rb_str_new2("C:\\Program Files\\Stuff"));
+
+   /* Default definition */
+   rb_define_const(cFoo, "NOSEMI", INT2FIX(99));
+
+   rb_define_const(cFoo, "NOCOMMENT", rb_str_new2("No comment"));
+
+   /*
+    * Multiline comment goes here because this comment spans multiple lines.
+    * Multiline comment goes here because this comment spans multiple lines.
+    */
+   rb_define_const(cFoo, "MULTILINE", INT2FIX(1));
+
+   /*
+    * 1: Multiline comment goes here because this comment spans multiple lines.
+    * Multiline comment goes here because this comment spans multiple lines.
+    */
+   rb_define_const(cFoo, "MULTILINE_VALUE", INT2FIX(1));
+
+   /* Multiline comment goes here because this comment spans multiple lines.
+    * Multiline comment goes here because this comment spans multiple lines.
+    */
+   rb_define_const(cFoo, "MULTILINE_NOT_EMPTY", INT2FIX(1));
+
+}
+    EOF
+
+    parser = util_parser content
+
+    parser.do_classes
+    parser.do_constants
+
+    klass = parser.classes['cFoo']
+    assert klass
+
+    constants = klass.constants
+    assert !klass.constants.empty?
+
+    constants = constants.map { |c| [c.name, c.value, c.comment] }
+
+    assert_equal ['PERFECT', '300',
+                  "\n      The highest possible score in bowling   \n   "],
+                 constants.shift
+    assert_equal ['CHEER', 'Huzzah!',
+                  "\n      What you cheer when you roll a perfect game   \n   "],
+                 constants.shift
+    assert_equal ['TEST', 'TEST:TEST',
+                  "\n      Checking to see if escaped semicolon works   \n   "],
+                 constants.shift
+    assert_equal ['MSEPARATOR', '\\',
+                  "\n      The file separator on MS Windows   \n   "],
+                 constants.shift
+    assert_equal ['SEPARATOR', '/',
+                  "\n      The file separator on Unix   \n   "],
+                 constants.shift
+    assert_equal ['STUFF', 'C:\\Program Files\\Stuff',
+                  "\n      A directory on MS Windows   \n   "],
+                 constants.shift
+    assert_equal ['NOSEMI', 'INT2FIX(99)',
+                  "\n      Default definition   \n   "],
+                 constants.shift
+    assert_equal ['NOCOMMENT', 'rb_str_new2("No comment")', nil],
+                 constants.shift
+
+    comment = <<-EOF.chomp
+
+     
+      Multiline comment goes here because this comment spans multiple lines.
+      Multiline comment goes here because this comment spans multiple lines.
+      
+   
+    EOF
+    assert_equal ['MULTILINE', 'INT2FIX(1)', comment], constants.shift
+    assert_equal ['MULTILINE_VALUE', '1', comment], constants.shift
+
+    comment = <<-EOF.chomp
+
+      Multiline comment goes here because this comment spans multiple lines.
+      Multiline comment goes here because this comment spans multiple lines.
+      
+   
+    EOF
+    assert_equal ['MULTILINE_NOT_EMPTY', 'INT2FIX(1)', comment], constants.shift
+
+    assert constants.empty?, constants.inspect
+  end
+
+  def test_find_class_comment_init
+    content = <<-EOF
+/*
+ * a comment for class Foo
+ */
+void
+Init_Foo(void) {
+  VALUE foo = rb_define_class("Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "  \n   a comment for class Foo\n   \n", klass.comment
+  end
+
+  def test_find_class_comment_define_class
+    content = <<-EOF
+/*
+ * a comment for class Foo
+ */
+VALUE foo = rb_define_class("Foo", rb_cObject);
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "  \n   a comment for class Foo\n   ", klass.comment
+  end
+
+  def test_find_class_comment_define_class_Init_Foo
+    content = <<-EOF
+/*
+ * a comment for class Foo on Init
+ */
+void
+Init_Foo(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE foo = rb_define_class("Foo", rb_cObject);
+}
+    EOF
+
+    klass = util_get_class content, 'foo'
+
+    assert_equal "  \n   a comment for class Foo on Init\n   \n", klass.comment
+  end
+
+  def util_get_class(content, name)
+    parser = util_parser content
+    parser.do_classes
+    parser.classes[name]
+  end
+
+  def util_parser(content)
+    parser = RDoc::C_Parser.new @top_level, @fn, content, @options, @stats
+    parser.progress = @progress
+    parser
+  end
+
+end
+

data/test/test_rdoc_info_formatting.rb

@@ -0,0 +1,179 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib/'
+require 'fileutils'
+require 'test/unit'
+require 'rdoc/generator/texinfo'
+require 'yaml'
+
+# From chapter 18 of the Pickaxe 3rd ed. and the TexInfo manual.
+class TestRdocInfoFormatting < Test::Unit::TestCase
+  OUTPUT_DIR = "/tmp/rdoc-#{$$}"
+
+  def setup
+    # supress stdout
+    $stdout = File.new('/dev/null','w')
+    $stderr = File.new('/dev/null','w')
+
+    RDoc::RDoc.new.document(['--fmt=texinfo',
+                             File.expand_path(__FILE__),
+                             "--op=#{OUTPUT_DIR}"])
+    @text = File.read(OUTPUT_DIR + '/rdoc.texinfo')
+    # File.open('rdoc.texinfo', 'w') { |f| f.puts @text }
+  end
+
+  def teardown
+    $stdout = STDOUT
+    $stderr = STDERR
+    FileUtils.rm_rf OUTPUT_DIR
+  end
+
+  # Make sure tags like *this* do not make HTML
+  def test_descriptions_are_not_html
+    assert_no_match Regexp.new("\<b\>this\<\/b\>"), @text, "We had some HTML; icky!"
+  end
+
+  # Ensure we get a reasonable amount
+  #
+  # of space in between paragraphs.
+  def test_paragraphs_are_spaced
+    assert_match(/amount\n\n\nof space/, @text)
+  end
+
+  # @ and {} should be at-sign-prefixed
+  def test_escaping
+    assert_match(/@@ and @\{@\} should be at-sign-prefixed/)
+  end
+  
+  # This tests that *bold* and <b>bold me</b> become @strong{bolded}
+  def test_bold
+    # Seems like a limitation of the Info format: @strong{bold}
+    # becomes *bold* when read in Info or M-x info. highly lame!
+    assert_match(/@strong\{bold\}/)
+    assert_match(/@strong\{bold me\}/)
+  end
+
+  # Test that _italics_ and <em>italicize me</em> becomes @emph{italicized}
+  def test_italics
+    assert_match(/@emph\{italics\}/)
+    assert_match(/@emph\{italicize me\}/)
+  end
+
+  # And that typewriter +text+ and <tt>typewriter me</tt> becomes @code{typewriter}
+  def test_tt
+    assert_match(/@code\{text\}/)
+    assert_match(/@code\{typewriter me\}/)
+  end
+
+  # Check that
+  #   anything indented is
+  #   verbatim @verb{|foo bar baz|}
+  def test_literal_code
+    assert_match("@verb{|  anything indented is
+  verbatim @@verb@{|foo bar baz|@}
+|}")
+  end
+
+  # = Huge heading should be a @majorheading
+  # == There is also @chapheading
+  # === Everything deeper becomes a regular @heading
+  # ====== Regardless of its nesting level
+  def test_headings
+    assert_match(/@majorheading\{Huge heading should be a @@majorheading\}/)
+    assert_match(/@chapheading\{There is also @@chapheading\}/)
+    assert_match(/@heading\{Everything deeper becomes a regular @@heading\}/)
+    assert_match(/@heading\{Regardless of its nesting level\}/)
+  end
+
+  # * list item
+  # * list item2
+  #
+  # with a paragraph in between
+  #
+  # - hyphen lists
+  # - are also allowed
+  #   and items may flow over lines
+  def test_bullet_lists
+    assert_match("@itemize @bullet
+@item
+list item
+@item
+list item2
+@end itemize")
+    assert_match("@itemize @bullet
+@item
+hyphen lists
+@item
+are also allowed and items may flow over lines
+@end itemize")
+  end
+
+  # 2. numbered lists
+  # 8. are made by
+  # 9. a digit followed by a period
+  def test_numbered_lists
+  end
+
+  # a. alpha lists
+  # b. should be parsed too
+  def test_alpha_lists
+  end
+
+  # [cat]   small domestic animal
+  # [+cat+] command to copy standard input
+  #         to standard output
+  def test_labelled_lists
+  end
+
+  # * First item.
+  #   * Inner item.
+  #   * Second inner item.
+  # * Second outer item.
+  def test_nested_lists
+    assert_match("@itemize @bullet
+@item
+First item.
+@itemize @bullet
+@item
+Inner item.
+@item
+Second inner item.
+@end itemize
+@item
+Second outer item.
+@end itemize")
+  end
+  
+  def test_internal_hyperlinks
+    # be sure to test multi-word hyperlinks as well.
+  end
+
+  def test_hyperlink_targets
+  end
+
+  def test_web_links
+    # An example of the two-argument form: The official
+    # @uref{ftp://ftp.gnu.org/gnu, GNU ftp site} holds programs and texts.
+
+    # produces:
+    #      The official GNU ftp site (ftp://ftp.gnu.org/gnu)
+    #      holds programs and texts.
+    # and the HTML output is this:
+    #      The official <a href="ftp://ftp.gnu.org/gnu">GNU ftp site</a>
+    #      holds programs and texts.
+  end
+
+  # three or more hyphens
+  # ----
+  # should produce a horizontal rule
+  def test_horizontal_rule
+    # gah; not sure texinfo supports horizontal rules
+  end
+
+  private
+
+  # We don't want the whole string inspected if we pass our own
+  # message in.
+  def assert_match(regex, string = @text,
+                   message = "Didn't find #{regex.inspect} in #{string}.")
+    assert string[regex] #, message
+  end
+end