rdoc 2.0.0

data/test/test_rdoc_markup_attribute_manager.rb

@@ -0,0 +1,224 @@
+require "test/unit"
+require "rdoc/markup/inline"
+
+class TestRDocMarkupAttributeManager < Test::Unit::TestCase
+
+  def setup
+    @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], [])
+  end
+
+  def crossref(text)
+    crossref_bitmap = RDoc::Markup::Attribute.bitmap_for(:_SPECIAL_) |
+                      RDoc::Markup::Attribute.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_word_pair
+    @am.add_word_pair '%', '&', 'percent and'
+
+    assert RDoc::Markup::AttributeManager::WORD_PAIR_MAP.include?(/(%)(\S+)(&)/)
+    assert RDoc::Markup::AttributeManager::PROTECTABLE.include?('%')
+    assert !RDoc::Markup::AttributeManager::PROTECTABLE.include?('&')
+  end
+
+  def test_add_word_pair_angle
+    e = assert_raise ArgumentError do
+      @am.add_word_pair '<', '>', 'angles'
+    end
+
+    assert_equal "Word flags may not start with '<'", e.message
+  end
+
+  def test_add_word_pair_matching
+    @am.add_word_pair '^', '^', 'caret'
+
+    assert RDoc::Markup::AttributeManager::MATCHING_WORD_PAIRS.include?('^')
+    assert RDoc::Markup::AttributeManager::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 ", @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"))
+  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_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_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_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
+    # class names, variable names, file names, or instance variables
+    @am.add_special(/(
+                       \b([A-Z]\w+(::\w+)*)
+                       | \#\w+[!?=]?
+                       | \b\w+([_\/\.]+\w+)+[!?=]?
+                      )/x,
+                    :CROSSREF)
+
+    assert_equal(["cat"], @am.flow("cat"))
+
+    assert_equal(["cat ", crossref("#fred"), " dog"].flatten,
+                  @am.flow("cat #fred dog"))
+
+    assert_equal([crossref("#fred"), " dog"].flatten,
+                  @am.flow("#fred dog"))
+
+    assert_equal(["cat ", crossref("#fred")].flatten, @am.flow("cat #fred"))
+  end
+
+end
+

data/test/test_rdoc_ri_attribute_formatter.rb

@@ -0,0 +1,42 @@
+require 'stringio'
+require 'test/unit'
+require 'rdoc/ri/formatter'
+
+class TestRDocRIAttributeFormatter < Test::Unit::TestCase
+
+  def setup
+    @output = StringIO.new
+    @width = 78
+    @indent = '  '
+
+    @f = RDoc::RI::AttributeFormatter.new @output, @width, @indent
+  end
+
+  def test_wrap_empty
+    @f.wrap ''
+    assert_equal '', @output.string
+  end
+
+  def test_wrap_long
+    @f.wrap 'a ' * (@width / 2)
+    assert_equal "  a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a \n  a \n",
+                 @output.string
+  end
+
+  def test_wrap_markup
+    @f.wrap 'a <tt>b</tt> c'
+    assert_equal "  a b c\n", @output.string
+  end
+
+  def test_wrap_nil
+    @f.wrap nil
+    assert_equal '', @output.string
+  end
+
+  def test_wrap_short
+    @f.wrap 'a b c'
+    assert_equal "  a b c\n", @output.string
+  end
+
+end
+

data/test/test_rdoc_ri_default_display.rb

@@ -0,0 +1,295 @@
+require 'stringio'
+require 'test/unit'
+require 'rdoc/ri/formatter'
+require 'rdoc/ri/display'
+require 'rdoc/ri/driver'
+
+class TestRDocRIDefaultDisplay < Test::Unit::TestCase
+
+  def setup
+    @output = StringIO.new
+    @width = 78
+    @indent = '  '
+
+    @dd = RDoc::RI::DefaultDisplay.new RDoc::RI::Formatter, @width, true,
+                                       @output
+
+    @some_method = {
+      'aliases' => [{'name' => 'some_method_alias'}],
+      'block_params' => 'block_param',
+      'comment' => [RDoc::Markup::Flow::P.new('some comment')],
+      'full_name' => 'SomeClass#some_method',
+      'is_singleton' => false,
+      'name' => 'some_method',
+      'params' => '(arg1, arg2) {|block_param| ...}',
+      'source_path' => '/nonexistent',
+      'visibility' => 'public',
+    }
+  end
+
+  def test_display_class_info
+    ri_reader = nil
+    klass = {
+      'attributes' => [
+        { 'name' => 'attribute', 'rw' => 'RW',
+          'comment' => [RDoc::Markup::Flow::P.new('attribute comment')] },
+        { 'name' => 'attribute_no_comment', 'rw' => 'RW',
+          'comment' => nil },
+      ],
+      'class_methods' => [
+        { 'name' => 'class_method' },
+      ],
+      'class_method_extensions' => [
+        { 'name' => 'class_method_extension' },
+      ],
+      'comment' => [RDoc::Markup::Flow::P.new('SomeClass comment')],
+      'constants' => [
+        { 'name' => 'CONSTANT', 'value' => '"value"',
+          'comment' => [RDoc::Markup::Flow::P.new('CONSTANT value')] },
+        { 'name' => 'CONSTANT_NOCOMMENT', 'value' => '"value"',
+          'comment' => nil },
+      ],
+      'display_name' => 'Class',
+      'full_name' => 'SomeClass',
+      'includes' => [],
+      'instance_methods' => [
+        { 'name' => 'instance_method' },
+      ],
+      'instance_method_extensions' => [
+        { 'name' => 'instance_method_extension' },
+      ],
+      'superclass_string' => 'Object',
+    }
+
+    @dd.display_class_info klass, ri_reader
+
+    expected = <<-EOF
+---------------------------------------------------- Class: SomeClass < Object
+     SomeClass comment
+
+------------------------------------------------------------------------------
+
+
+Constants:
+----------
+
+     CONSTANT:
+          CONSTANT value
+
+     CONSTANT_NOCOMMENT
+
+
+Class methods:
+--------------
+
+     class_method
+
+
+Class method extensions:
+------------------------
+
+     class_method_extension
+
+
+Instance methods:
+-----------------
+
+     instance_method
+
+
+Instance method extensions:
+---------------------------
+
+     instance_method_extension
+
+
+Attributes:
+-----------
+
+     attribute (RW):
+          attribute comment
+
+     attribute_no_comment (RW)
+    EOF
+
+    assert_equal expected, @output.string
+  end
+
+  def test_display_flow
+    flow = [RDoc::Markup::Flow::P.new('flow')]
+
+    @dd.display_flow flow
+
+    assert_equal "     flow\n\n", @output.string
+  end
+
+  def test_display_flow_empty
+    @dd.display_flow []
+
+    assert_equal "     [no description]\n", @output.string
+  end
+
+  def test_display_flow_nil
+    @dd.display_flow nil
+
+    assert_equal "     [no description]\n", @output.string
+  end
+
+  def test_display_method_info
+    @dd.display_method_info @some_method
+
+    expected = <<-EOF
+-------------------------------------------------------- SomeClass#some_method
+     some_method(arg1, arg2) {|block_param| ...}
+
+     Extension from /nonexistent
+------------------------------------------------------------------------------
+     some comment
+
+
+     (also known as some_method_alias)
+    EOF
+
+    assert_equal expected, @output.string
+  end
+
+  def test_display_method_info_singleton
+    method = {
+      'aliases' => [],
+      'block_params' => nil,
+      'comment' => nil,
+      'full_name' => 'SomeClass::some_method',
+      'is_singleton' => true,
+      'name' => 'some_method',
+      'params' => '(arg1, arg2)',
+      'visibility' => 'public',
+    }
+
+    @dd.display_method_info method
+
+    expected = <<-EOF
+------------------------------------------------------- SomeClass::some_method
+     SomeClass::some_method(arg1, arg2)
+------------------------------------------------------------------------------
+     [no description]
+    EOF
+
+    assert_equal expected, @output.string
+  end
+
+  def test_display_method_list
+    methods = [
+      {
+        "aliases" => [],
+        "block_params" => nil,
+        "comment" =>  nil,
+        "full_name" => "SomeClass#some_method",
+        "is_singleton" => false,
+        "name" => "some_method",
+        "params" => "()",
+        "visibility" => "public",
+      },
+      {
+        "aliases" => [],
+        "block_params" => nil,
+        "comment" => nil,
+        "full_name" => "SomeClass#some_other_method",
+        "is_singleton" => false,
+        "name" => "some_other_method",
+        "params" => "()",
+        "visibility" => "public",
+      },
+    ]
+
+    @dd.display_method_list methods
+
+    expected = <<-EOF
+     More than one method matched your request.  You can refine your search by
+     asking for information on one of:
+
+     SomeClass#some_method, SomeClass#some_other_method
+    EOF
+
+    assert_equal expected, @output.string
+  end
+
+  def test_display_params
+    @dd.display_params @some_method
+
+    expected = <<-EOF
+     some_method(arg1, arg2) {|block_param| ...}
+
+     Extension from /nonexistent
+    EOF
+
+    assert_equal expected, @output.string
+  end
+
+  def test_display_params_multiple
+    @some_method['params'] = <<-EOF
+some_method(index)
+some_method(start, length)
+    EOF
+
+    @dd.display_params @some_method
+
+    expected = <<-EOF
+     some_method(index)
+     some_method(start, length)
+
+     Extension from /nonexistent
+    EOF
+
+    assert_equal expected, @output.string
+  end
+
+  def test_display_params_singleton
+    @some_method['is_singleton'] = true
+    @some_method['full_name'] = 'SomeClass::some_method'
+
+    @dd.display_params @some_method
+
+    expected = <<-EOF
+     SomeClass::some_method(arg1, arg2) {|block_param| ...}
+
+     Extension from /nonexistent
+    EOF
+
+    assert_equal expected, @output.string
+  end
+
+  def test_list_known_classes
+    klasses = %w[SomeClass SomeModule]
+
+    @dd.list_known_classes klasses
+
+    expected = <<-EOF
+---------------------------------------------------- Known classes and modules
+
+     SomeClass, SomeModule
+    EOF
+
+    assert_equal expected, @output.string
+  end
+
+  def test_list_known_classes_empty
+    @dd.list_known_classes []
+
+    expected = <<-EOF
+No ri data found
+
+If you've installed Ruby yourself, you need to generate documentation using:
+
+  make install-doc
+
+from the same place you ran `make` to build ruby.
+
+If you installed Ruby from a packaging system, then you may need to
+install an additional package, or ask the packager to enable ri generation.
+    EOF
+
+    assert_equal expected, @output.string
+  end
+
+end
+