* lib/rdoc/ri/formatter.rb: Indent labeled lists like note lists.

* test/rdoc/test_rdoc_ri_overstrike_formatter.rb:  Added.

* test/rdoc/test_rdoc_ri_formatter.rb:  Added tests.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@15164 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ChangeLog

@@ -1,3 +1,11 @@
+Tue Jan 22 08:59:52 2008  Eric Hodel  <drbrain@segment7.net>
+
+	* lib/rdoc/ri/formatter.rb:  Indent labeled lists like note lists.
+
+	* test/rdoc/test_rdoc_ri_overstrike_formatter.rb:  Added.
+
+	* test/rdoc/test_rdoc_ri_formatter.rb:  Added tests.
+
 Tue Jan 22 04:40:28 2008  Yukihiro Matsumoto  <matz@ruby-lang.org>
 
 	* parse.y (rb_intern3): do not call rb_enc_mbclen() if *m is

lib/rdoc/ri/formatter.rb

@@ -110,50 +110,46 @@ class RDoc::RI::Formatter
       prefixer = proc { |ignored| @indent + "*   " }
 
     when :NUMBER, :UPPERALPHA, :LOWERALPHA then
-
       start = case list.type
               when :NUMBER     then 1
               when :UPPERALPHA then 'A'
               when :LOWERALPHA then 'a'
               end
+
       prefixer = proc do |ignored|
         res = @indent + "#{start}.".ljust(4)
         start = start.succ
         res
       end
 
-    when :LABELED then
+    when :LABELED, :NOTE then
-      prefixer = proc do |li|
-        li.label
-      end
-
-    when :NOTE then
       longest = 0
+
       list.contents.each do |item|
-        if item.kind_of?(RDoc::Markup::Flow::LI) && item.label.length > longest
+        if RDoc::Markup::Flow::LI === item and item.label.length > longest then
           longest = item.label.length
         end
       end
 
-      prefixer = proc do |li|
+      longest += 1
-        @indent + li.label.ljust(longest+1)
+
-      end
+      prefixer = proc { |li| @indent + li.label.ljust(longest) }
 
     else
       raise ArgumentError, "unknown list type #{list.type}"
     end
 
     list.contents.each do |item|
-      if item.kind_of? RDoc::Markup::Flow::LI
+      if RDoc::Markup::Flow::LI === item then
-        prefix = prefixer.call(item)
+        prefix = prefixer.call item
-        display_flow_item(item, prefix)
+        display_flow_item item, prefix
       else
-        display_flow_item(item)
+        display_flow_item item
       end
     end
   end
 
-  def display_flow_item(item, prefix=@indent)
+  def display_flow_item(item, prefix = @indent)
     case item
     when RDoc::Markup::Flow::P, RDoc::Markup::Flow::LI
       wrap(conv_html(item.body), prefix)
@@ -172,7 +168,7 @@ class RDoc::RI::Formatter
       draw_line
 
     else
-      fail "Unknown flow element: #{item.class}"
+      raise RDoc::Error, "Unknown flow element: #{item.class}"
     end
   end
 
@@ -184,24 +180,25 @@ class RDoc::RI::Formatter
   end
 
   def display_heading(text, level, indent)
-    text = strip_attributes(text)
+    text = strip_attributes text
+
     case level
-    when 1
+    when 1 then
       ul = "=" * text.length
       @output.puts
       @output.puts text.upcase
       @output.puts ul
-      #        puts
 
-    when 2
+    when 2 then
       ul = "-" * text.length
       @output.puts
       @output.puts text
       @output.puts ul
-      #        puts
     else
       @output.print indent, text, "\n"
     end
+
+    @output.puts
   end
 
   def display_flow(flow)
@@ -210,19 +207,8 @@ class RDoc::RI::Formatter
     end
   end
 
-  def strip_attributes(txt)
+  def strip_attributes(text)
-    tokens = txt.split(%r{(</?(?:b|code|em|i|tt)>)})
+    text.gsub(/(<\/?(?:b|code|em|i|tt)>)/, '')
-    text = []
-    attributes = 0
-    tokens.each do |tok|
-      case tok
-      when %r{^</(\w+)>$}, %r{^<(\w+)>$}
-        ;
-      else
-        text << tok
-      end
-    end
-    text.join
   end
 
 end
@@ -246,16 +232,7 @@ class RDoc::RI::AttributeFormatter < RDoc::RI::Formatter
     "tt"   => CODE
   }
 
-  # TODO: struct?
+  AttrChar = Struct.new :char, :attr
-  class AttrChar
-    attr_reader :char
-    attr_reader :attr
-
-    def initialize(char, attr)
-      @char = char
-      @attr = attr
-    end
-  end
 
   class AttributeString
     attr_reader :txt
@@ -360,16 +337,14 @@ class RDoc::RI::OverstrikeFormatter < RDoc::RI::AttributeFormatter
 
   def write_attribute_text(prefix, line)
     @output.print prefix
+
     line.each do |achar|
       attr = achar.attr
-      if (attr & (ITALIC+CODE)) != 0
+      @output.print "_", BS if (attr & (ITALIC + CODE)) != 0
-        @output.print "_", BS
+      @output.print achar.char, BS if (attr & BOLD) != 0
-      end
-      if (attr & BOLD) != 0
-        @output.print achar.char, BS
-      end
       @output.print achar.char
     end
+
     @output.puts
   end
 
@@ -415,9 +390,9 @@ class RDoc::RI::AnsiFormatter < RDoc::RI::AttributeFormatter
   end
 
   HEADINGS = {
-    1 => [ "\033[1;32m", "\033[m" ] ,
+    1 => ["\033[1;32m", "\033[m"],
-    2 => ["\033[4;32m", "\033[m" ],
+    2 => ["\033[4;32m", "\033[m"],
-    3 => ["\033[32m", "\033[m" ]
+    3 => ["\033[32m",   "\033[m"],
   }
 
   def display_heading(text, level, indent)

test/rdoc/test_rdoc_ri_formatter.rb

@@ -45,17 +45,186 @@ class TestRDocRIFormatter < Test::Unit::TestCase
     assert_equal expected, @f.conv_markup(text)
   end
 
+  def test_display_flow
+    flow = [
+      RDoc::Markup::Flow::H.new(1, 'heading'),
+      RDoc::Markup::Flow::P.new('paragraph'),
+    ]
+
+    @f.display_flow flow
+
+    assert_equal "\nHEADING\n=======\n\n  paragraph\n\n", @output.string
+  end
+
+  def test_display_flow_item_h
+    item = RDoc::Markup::Flow::H.new 1, 'heading'
+
+    @f.display_flow_item item
+
+    assert_equal "\nHEADING\n=======\n\n", @output.string
+  end
+
+  def test_display_flow_item_li
+    item = RDoc::Markup::Flow::LI.new nil, 'paragraph'
+
+    @f.display_flow_item item
+
+    assert_equal "  paragraph\n\n", @output.string
+  end
+
+  def test_display_flow_item_list
+    item = RDoc::Markup::Flow::LIST.new :NUMBER
+
+    @f.display_flow_item item
+
+    assert_equal "", @output.string
+  end
+
+  def test_display_flow_item_p
+    item = RDoc::Markup::Flow::P.new 'paragraph'
+
+    @f.display_flow_item item
+
+    assert_equal "  paragraph\n\n", @output.string
+  end
+
+  def test_display_flow_item_rule
+    item = RDoc::Markup::Flow::RULE.new 1
+
+    @f.display_flow_item item
+
+    assert_equal "#{'-' * 78}\n", @output.string
+  end
+
+  def test_display_flow_item_unknown
+    e = assert_raise RDoc::Error do
+      @f.display_flow_item Object.new
+    end
+
+    assert_equal "Unknown flow element: Object", e.message
+  end
+
+  def test_display_flow_item_verb
+    item = RDoc::Markup::Flow::VERB.new 'a b c'
+
+    @f.display_flow_item item
+
+    assert_equal "  a b c\n\n", @output.string
+  end
+
+  def test_display_heading_1
+    @f.display_heading 'heading', 1, '  '
+
+    assert_equal "\nHEADING\n=======\n\n", @output.string
+  end
+
+  def test_display_heading_2
+    @f.display_heading 'heading', 2, '  '
+
+    assert_equal "\nheading\n-------\n\n", @output.string
+  end
+
+  def test_display_heading_3
+    @f.display_heading 'heading', 3, '  '
+
+    assert_equal "  heading\n\n", @output.string
+  end
+
+  def test_display_list
+    list = RDoc::Markup::Flow::LIST.new :NUMBER
+    list << RDoc::Markup::Flow::LI.new(nil, 'a b c')
+    list << RDoc::Markup::Flow::LI.new(nil, 'd e f')
+
+    @f.display_list list
+
+    assert_equal "  1.  a b c\n\n  2.  d e f\n\n", @output.string
+  end
+
   def test_display_list_bullet
-    list = util_convert('* a b c').first
+    list = RDoc::Markup::Flow::LIST.new :BULLET
+    list << RDoc::Markup::Flow::LI.new(nil, 'a b c')
 
     @f.display_list list
 
     assert_equal "  *   a b c\n\n", @output.string
   end
 
+  def test_display_heading_1
+    @f.display_heading 'heading', 1, '  '
+
+    assert_equal "\nHEADING\n=======\n\n", @output.string
+  end
+
+  def test_display_heading_2
+    @f.display_heading 'heading', 2, '  '
+
+    assert_equal "\nheading\n-------\n\n", @output.string
+  end
+
+  def test_display_heading_3
+    @f.display_heading 'heading', 3, '  '
+
+    assert_equal "  heading\n\n", @output.string
+  end
+
+  def test_display_list
+    list = RDoc::Markup::Flow::LIST.new :NUMBER
+    list << RDoc::Markup::Flow::LI.new(nil, 'a b c')
+    list << RDoc::Markup::Flow::LI.new(nil, 'd e f')
+
+    @f.display_list list
+
+    assert_equal "  1.  a b c\n\n  2.  d e f\n\n", @output.string
+  end
+
+  def test_display_list_bullet
+    list = RDoc::Markup::Flow::LIST.new :BULLET
+    list << RDoc::Markup::Flow::LI.new(nil, 'a b c')
+
+    @f.display_list list
+
+    assert_equal "  *   a b c\n\n", @output.string
+  end
+
+  def test_display_list_labeled
+    list = RDoc::Markup::Flow::LIST.new :LABELED
+    list << RDoc::Markup::Flow::LI.new('label', 'a b c')
+
+    @f.display_list list
+
+    assert_equal "  label a b c\n\n", @output.string
+  end
+
+  def test_display_list_lower_alpha
+    list = RDoc::Markup::Flow::LIST.new :LOWERALPHA
+    list << RDoc::Markup::Flow::LI.new(nil, 'a b c')
+
+    @f.display_list list
+
+    assert_equal "  a.  a b c\n\n", @output.string
+  end
+
+  def test_display_list_note
+    list = RDoc::Markup::Flow::LIST.new :NOTE
+    list << RDoc::Markup::Flow::LI.new('note:', 'a b c')
+
+    @f.display_list list
+
+    assert_equal "  note: a b c\n\n", @output.string
+  end
+
+  def test_display_list_number
+    list = RDoc::Markup::Flow::LIST.new :NUMBER
+    list << RDoc::Markup::Flow::LI.new(nil, 'a b c')
+
+    @f.display_list list
+
+    assert_equal "  1.  a b c\n\n", @output.string
+  end
+
   def test_display_list_unknown
-    list = util_convert('* a b c').first
+    list = RDoc::Markup::Flow::LIST.new :UNKNOWN
-    list.instance_variable_set :@type, :UNKNOWN
+    list << RDoc::Markup::Flow::LI.new(nil, 'a b c')
 
     e = assert_raise ArgumentError do
       @f.display_list list
@@ -64,6 +233,23 @@ class TestRDocRIFormatter < Test::Unit::TestCase
     assert_equal 'unknown list type UNKNOWN', e.message
   end
 
+  def test_display_list_upper_alpha
+    list = RDoc::Markup::Flow::LIST.new :UPPERALPHA
+    list << RDoc::Markup::Flow::LI.new(nil, 'a b c')
+
+    @f.display_list list
+
+    assert_equal "  A.  a b c\n\n", @output.string
+  end
+
+  def test_display_verbatim_flow_item
+    verbatim = RDoc::Markup::Flow::VERB.new "a b c\nd e f"
+
+    @f.display_verbatim_flow_item verbatim
+
+    assert_equal "  a b c\n  d e f\n\n", @output.string
+  end
+
   def test_draw_line
     @f.draw_line
 
@@ -91,6 +277,46 @@ class TestRDocRIFormatter < Test::Unit::TestCase
     assert_equal "a b c\n", @output.string
   end
 
+  def test_strip_attributes_b
+    text = @f.strip_attributes 'hello <b>world</b>'
+
+    expected = 'hello world'
+
+    assert_equal expected, text
+  end
+
+  def test_strip_attributes_code
+    text = @f.strip_attributes 'hello <code>world</code>'
+
+    expected = 'hello world'
+
+    assert_equal expected, text
+  end
+
+  def test_strip_attributes_em
+    text = @f.strip_attributes 'hello <em>world</em>'
+
+    expected = 'hello world'
+
+    assert_equal expected, text
+  end
+
+  def test_strip_attributes_i
+    text = @f.strip_attributes 'hello <i>world</i>'
+
+    expected = 'hello world'
+
+    assert_equal expected, text
+  end
+
+  def test_strip_attributes_tt
+    text = @f.strip_attributes 'hello <tt>world</tt>'
+
+    expected = 'hello world'
+
+    assert_equal expected, text
+  end
+
   def test_wrap_empty
     @f.wrap ''
     assert_equal '', @output.string
@@ -117,8 +343,5 @@ class TestRDocRIFormatter < Test::Unit::TestCase
     assert_equal "  a b c\n", @output.string
   end
 
-  def util_convert(text)
-    @markup.convert text, @flow
-  end
 end
 

test/rdoc/test_rdoc_ri_overstrike_formatter.rb

@@ -0,0 +1,61 @@
+require 'stringio'
+require 'test/unit'
+require 'rdoc/ri/formatter'
+require 'rdoc/markup/fragments'
+require 'rdoc/markup/to_flow'
+
+class TestRDocRIOverstrikeFormatter < Test::Unit::TestCase
+
+  def setup
+    @output = StringIO.new
+    @width = 78
+    @indent = '  '
+
+    @f = RDoc::RI::OverstrikeFormatter.new @output, @width, @indent
+    @markup = RDoc::Markup.new
+    @flow = RDoc::Markup::ToFlow.new
+
+    @af = RDoc::RI::AttributeFormatter
+  end
+
+  def test_write_attribute_text_bold
+    line = [RDoc::RI::AttributeFormatter::AttrChar.new('b', @af::BOLD)]
+
+    @f.write_attribute_text '  ', line
+
+    assert_equal "  b\bb\n", @output.string
+  end
+
+  def test_write_attribute_text_bold_italic
+    attr = @af::BOLD | @af::ITALIC
+    line = [RDoc::RI::AttributeFormatter::AttrChar.new('d', attr)]
+
+    @f.write_attribute_text '  ', line
+
+    assert_equal "  _\bd\bd\n", @output.string
+  end
+
+  def test_write_attribute_text_code
+    line = [RDoc::RI::AttributeFormatter::AttrChar.new('c', @af::CODE)]
+
+    @f.write_attribute_text '  ', line
+
+    assert_equal "  _\bc\n", @output.string
+  end
+
+  def test_write_attribute_text_italic
+    line = [RDoc::RI::AttributeFormatter::AttrChar.new('a', @af::ITALIC)]
+
+    @f.write_attribute_text '  ', line
+
+    assert_equal "  _\ba\n", @output.string
+  end
+
+  def test_bold_print
+    @f.bold_print 'a b c'
+
+    assert_equal "a\ba \b b\bb \b c\bc", @output.string
+  end
+
+end
+