rdoc 2.4.3 → 2.5

data/lib/rdoc/markup/rule.rb

@@ -0,0 +1,17 @@
+##
+# A horizontal rule with a weight
+
+class RDoc::Markup::Rule < Struct.new :weight
+
+  def accept visitor
+    visitor.accept_rule self
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[rule:', ']' do
+      q.pp weight
+    end
+  end
+
+end
+

data/lib/rdoc/markup/to_ansi.rb

@@ -0,0 +1,72 @@
+require 'rdoc/markup/inline'
+
+##
+# Outputs RDoc markup with vibrant ANSI color!
+
+class RDoc::Markup::ToAnsi < RDoc::Markup::ToRdoc
+
+  def initialize
+    super
+
+    @headings.clear
+    @headings[1] = ["\e[1;32m", "\e[m"]
+    @headings[2] = ["\e[4;32m", "\e[m"]
+    @headings[3] = ["\e[32m",   "\e[m"]
+  end
+
+  ##
+  # Maps attributes to ANSI sequences
+
+  def init_tags
+    add_tag :BOLD, "\e[1m", "\e[m"
+    add_tag :TT,   "\e[7m", "\e[m"
+    add_tag :EM,   "\e[4m", "\e[m"
+  end
+
+  def accept_list_item_end list_item
+    width = case @list_type.last
+            when :BULLET then
+              2
+            when :NOTE, :LABEL then
+              @res << "\n"
+              2
+            else
+              bullet = @list_index.last.to_s
+              @list_index[-1] = @list_index.last.succ
+              bullet.length + 2
+            end
+
+    @indent -= width
+  end
+
+  def accept_list_item_start list_item
+    bullet = case @list_type.last
+             when :BULLET then
+               '*'
+             when :NOTE, :LABEL then
+               attributes(list_item.label) + ":\n"
+             else
+               @list_index.last.to_s + '.'
+             end
+
+    case @list_type.last
+    when :NOTE, :LABEL then
+      @indent += 2
+      @prefix = bullet + (' ' * @indent)
+    else
+      @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
+
+      width = bullet.gsub(/\e\[[\d;]*m/, '').length + 1
+
+      @indent += width
+    end
+  end
+
+  def start_accepting
+    super
+
+    @res = ["\e[0m"]
+  end
+
+end
+

data/lib/rdoc/markup/to_bs.rb

@@ -0,0 +1,74 @@
+require 'rdoc/markup/inline'
+
+##
+# Outputs RDoc markup with hot backspace action!  You will probably need a
+# pager to use this output format.
+#
+# This formatter won't work on 1.8.6 because it lacks String#chars.
+
+class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
+
+  def initialize
+    super
+
+    @in_b  = false
+    @in_em = false
+  end
+
+  ##
+  # Sets a flag that is picked up by #annotate to do the right thing in
+  # #convert_string
+
+  def init_tags
+    add_tag :BOLD, '+b', '-b'
+    add_tag :EM,   '+_', '-_'
+  end
+
+  def accept_heading heading
+    use_prefix or @res << ' ' * @indent
+    @res << @headings[heading.level][0]
+    @in_b = true
+    @res << attributes(heading.text)
+    @in_b = false
+    @res << @headings[heading.level][1]
+    @res << "\n"
+  end
+
+  ##
+  # Turns on or off special handling for +convert_string+
+
+  def annotate tag
+    case tag
+    when '+b' then @in_b = true
+    when '-b' then @in_b = false
+    when '+_' then @in_em = true
+    when '-_' then @in_em = false
+    end
+
+    ''
+  end
+
+  ##
+  # Calls convert_string on the result of convert_special
+
+  def convert_special special
+    convert_string super
+  end
+
+  ##
+  # Adds bold or underline mixed with backspaces
+
+  def convert_string string
+    return string unless string.respond_to? :chars # your ruby is lame
+    return string unless @in_b or @in_em
+    chars = if @in_b then
+              string.chars.map do |char| "#{char}\b#{char}" end
+            elsif @in_em then
+              string.chars.map do |char| "_\b#{char}" end
+            end
+
+    chars.join
+  end
+
+end
+

data/lib/rdoc/markup/to_html.rb

@@ -1,38 +1,28 @@
 require 'rdoc/markup/formatter'
-require 'rdoc/markup/fragments'
 require 'rdoc/markup/inline'
 
 require 'cgi'
 
+##
+# Outputs RDoc markup as HTML
+
 class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
 
+  ##
+  # Maps RDoc::Markup::Parser::LIST_TOKENS types to HTML tags
+
   LIST_TYPE_TO_HTML = {
-    :BULLET =>     %w[<ul> </ul>],
-    :NUMBER =>     %w[<ol> </ol>],
-    :UPPERALPHA => %w[<ol> </ol>],
-    :LOWERALPHA => %w[<ol> </ol>],
-    :LABELED =>    %w[<dl> </dl>],
-    :NOTE    =>    %w[<table> </table>],
+    :BULLET => ['<ul>', '</ul>'],
+    :LABEL  => ['<dl>', '</dl>'],
+    :LALPHA => ['<ol style="display: lower-alpha">', '</ol>'],
+    :NOTE   => ['<table>', '</table>'],
+    :NUMBER => ['<ol>', '</ol>'],
+    :UALPHA => ['<ol style="display: upper-alpha">', '</ol>'],
   }
 
-  InlineTag = Struct.new(:bit, :on, :off)
-
-  def initialize
-    super
-
-    # @in_tt - tt nested levels count
-    # @tt_bit - cache
-    @in_tt = 0
-    @tt_bit = RDoc::Markup::Attribute.bitmap_for :TT
-
-    # external hyperlinks
-    @markup.add_special(/((link:|https?:|mailto:|ftp:|www\.)\S+\w)/, :HYPERLINK)
-
-    # and links of the form  <text>[<url>]
-    @markup.add_special(/(((\{.*?\})|\b\S+?)\[\S+?\.\S+?\])/, :TIDYLINK)
-
-    init_tags
-  end
+  attr_reader :res # :nodoc:
+  attr_reader :in_list_entry # :nodoc:
+  attr_reader :list # :nodoc:
 
   ##
   # Converts a target url to one that is relative to a given path
@@ -58,6 +48,31 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     File.join(*from)
   end
 
+  def initialize
+    super
+
+    @th = nil
+    @in_list_entry = nil
+    @list = nil
+
+    # external hyperlinks
+    @markup.add_special(/((link:|https?:|mailto:|ftp:|www\.)\S+\w)/, :HYPERLINK)
+
+    # and links of the form  <text>[<url>]
+    @markup.add_special(/(((\{.*?\})|\b\S+?)\[\S+?\.\S+?\])/, :TIDYLINK)
+
+    init_tags
+  end
+
+  ##
+  # Maps attributes to HTML tags
+
+  def init_tags
+    add_tag :BOLD, "<b>",  "</b>"
+    add_tag :TT,   "<tt>", "</tt>"
+    add_tag :EM,   "<em>", "</em>"
+  end
+
   ##
   # Generate a hyperlink for url, labeled with text. Handle the
   # special cases for img: and link: described under handle_special_HYPERLINK
@@ -115,55 +130,14 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     gen_url url, label
   end
 
-  ##
-  # are we currently inside tt tags?
-
-  def in_tt?
-    @in_tt > 0
-  end
-
-  ##
-  # is +tag+ a tt tag?
-
-  def tt?(tag)
-    tag.bit == @tt_bit
-  end
-
-  ##
-  # Set up the standard mapping of attributes to HTML tags
-
-  def init_tags
-    @attr_tags = [
-      InlineTag.new(RDoc::Markup::Attribute.bitmap_for(:BOLD), "<b>", "</b>"),
-      InlineTag.new(RDoc::Markup::Attribute.bitmap_for(:TT),   "<tt>", "</tt>"),
-      InlineTag.new(RDoc::Markup::Attribute.bitmap_for(:EM),   "<em>", "</em>"),
-    ]
-  end
-
-  ##
-  # Add a new set of HTML tags for an attribute. We allow separate start and
-  # end tags for flexibility.
-
-  def add_tag(name, start, stop)
-    @attr_tags << InlineTag.new(RDoc::Markup::Attribute.bitmap_for(name), start, stop)
-  end
-
-  ##
-  # Given an HTML tag, decorate it with class information and the like if
-  # required. This is a no-op in the base class, but is overridden in HTML
-  # output classes that implement style sheets.
-
-  def annotate(tag)
-    tag
-  end
-
   ##
   # This is a higher speed (if messier) version of wrap
 
   def wrap(txt, line_len = 76)
-    res = ""
+    res = []
     sp = 0
     ep = txt.length
+
     while sp < ep
       # scan back for a space
       p = sp + line_len - 1
@@ -184,127 +158,94 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
       sp = p
       sp += 1 while sp < ep and txt[sp] == ?\s
     end
-    res
+
+    res.join
   end
 
   ##
   # :section: Visitor
 
   def start_accepting
-    @res = ""
+    @res = []
     @in_list_entry = []
+    @list = []
   end
 
   def end_accepting
-    @res
+    @res.join
   end
 
-  def accept_paragraph(am, fragment)
+  def accept_paragraph(paragraph)
     @res << annotate("<p>") + "\n"
-    @res << wrap(convert_flow(am.flow(fragment.txt)))
+    @res << wrap(convert_flow(@am.flow(paragraph.text)))
     @res << annotate("</p>") + "\n"
   end
 
-  def accept_verbatim(am, fragment)
-    @res << annotate("<pre>") + "\n"
-    @res << CGI.escapeHTML(fragment.txt)
+  def accept_verbatim(verbatim)
+    @res << annotate("<pre>") << "\n"
+    @res << CGI.escapeHTML(verbatim.text)
     @res << annotate("</pre>") << "\n"
   end
 
-  def accept_rule(am, fragment)
-    size = fragment.param
+  def accept_rule(rule)
+    size = rule.weight
     size = 10 if size > 10
-    @res << "<hr size=\"#{size}\"></hr>"
+    @res << "<hr style=\"height: #{size}px\"></hr>"
   end
 
-  def accept_list_start(am, fragment)
-    @res << html_list_name(fragment.type, true) << "\n"
+  def accept_list_start(list)
+    @list << list.type
+    @res << html_list_name(list.type, true) << "\n"
     @in_list_entry.push false
   end
 
-  def accept_list_end(am, fragment)
+  def accept_list_end(list)
+    @list.pop
     if tag = @in_list_entry.pop
       @res << annotate(tag) << "\n"
     end
-    @res << html_list_name(fragment.type, false) << "\n"
+    @res << html_list_name(list.type, false) << "\n"
   end
 
-  def accept_list_item(am, fragment)
+  def accept_list_item_start(list_item)
     if tag = @in_list_entry.last
       @res << annotate(tag) << "\n"
     end
 
-    @res << list_item_start(am, fragment)
-
-    @res << wrap(convert_flow(am.flow(fragment.txt))) << "\n"
+    @res << list_item_start(list_item, @list.last)
+  end
 
-    @in_list_entry[-1] = list_end_for(fragment.type)
+  def accept_list_item_end(list_item)
+    @in_list_entry[-1] = list_end_for(@list.last)
   end
 
-  def accept_blank_line(am, fragment)
+  def accept_blank_line(blank_line)
     # @res << annotate("<p />") << "\n"
   end
 
-  def accept_heading(am, fragment)
-    @res << convert_heading(fragment.head_level, am.flow(fragment.txt))
+  def accept_heading(heading)
+    @res << convert_heading(heading.level, @am.flow(heading.text))
   end
 
   private
 
-  def on_tags(res, item)
-    attr_mask = item.turn_on
-    return if attr_mask.zero?
-
-    @attr_tags.each do |tag|
-      if attr_mask & tag.bit != 0
-        res << annotate(tag.on)
-        @in_tt += 1 if tt?(tag)
-      end
-    end
-  end
-
-  def off_tags(res, item)
-    attr_mask = item.turn_off
-    return if attr_mask.zero?
-
-    @attr_tags.reverse_each do |tag|
-      if attr_mask & tag.bit != 0
-        @in_tt -= 1 if tt?(tag)
-        res << annotate(tag.off)
-      end
-    end
-  end
-
-  def convert_flow(flow)
-    res = ""
-
-    flow.each do |item|
-      case item
-      when String
-        res << convert_string(item)
-      when RDoc::Markup::AttrChanger
-        off_tags(res, item)
-        on_tags(res,  item)
-      when RDoc::Markup::Special
-        res << convert_special(item)
-      else
-        raise "Unknown flow element: #{item.inspect}"
-      end
-    end
-
-    res
-  end
+  ##
+  # Converts string +item+
 
   def convert_string(item)
     in_tt? ? convert_string_simple(item) : convert_string_fancy(item)
   end
 
+  ##
+  # Escapes HTML in +item+
+
   def convert_string_simple(item)
     CGI.escapeHTML item
   end
 
   ##
-  # some of these patterns are taken from SmartyPants...
+  # Converts ampersand, dashes, elipsis, quotes, copyright and registered
+  # trademark symbols to HTML escaped Unicode.
 
   def convert_string_fancy(item)
     # convert ampersand before doing anything else
@@ -336,69 +277,62 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
       gsub(/\(r\)/, '&#174;')
   end
 
-  def convert_special(special)
-    handled = false
-    RDoc::Markup::Attribute.each_name_of(special.type) do |name|
-      method_name = "handle_special_#{name}"
-      if self.respond_to? method_name
-        special.text = send(method_name, special)
-        handled = true
-      end
-    end
-    raise "Unhandled special: #{special}" unless handled
-    special.text
-  end
+  ##
+  # Converts headings to hN elements
 
   def convert_heading(level, flow)
-    res =
-      annotate("<h#{level}>") +
-      convert_flow(flow) +
-      annotate("</h#{level}>\n")
+    [annotate("<h#{level}>"),
+     convert_flow(flow),
+     annotate("</h#{level}>\n")].join
   end
 
-  def html_list_name(list_type, is_open_tag)
-    tags = LIST_TYPE_TO_HTML[list_type] || raise("Invalid list type: #{list_type.inspect}")
-    annotate(tags[ is_open_tag ? 0 : 1])
-  end
+  ##
+  # Determins the HTML list element for +list_type+ and +open_tag+
 
-  def list_item_start(am, fragment)
-    case fragment.type
-    when :BULLET, :NUMBER then
-      annotate("<li>")
+  def html_list_name(list_type, open_tag)
+    tags = LIST_TYPE_TO_HTML[list_type] 
+    raise RDoc::Error, "Invalid list type: #{list_type.inspect}" unless tags
+    annotate tags[open_tag ? 0 : 1]
+  end
 
-    when :UPPERALPHA then
-      annotate("<li type=\"A\">")
+  ##
+  # Starts a list item
 
-    when :LOWERALPHA then
-      annotate("<li type=\"a\">")
+  def list_item_start(list_item, list_type)
+    case list_type
+    when :BULLET, :LALPHA, :NUMBER, :UALPHA then
+      annotate("<li>")
 
-    when :LABELED then
+    when :LABEL then
       annotate("<dt>") +
-        convert_flow(am.flow(fragment.param)) +
+        convert_flow(@am.flow(list_item.label)) +
         annotate("</dt>") +
         annotate("<dd>")
 
     when :NOTE then
       annotate("<tr>") +
         annotate("<td valign=\"top\">") +
-        convert_flow(am.flow(fragment.param)) +
+        convert_flow(@am.flow(list_item.label)) +
         annotate("</td>") +
         annotate("<td>")
     else
-      raise "Invalid list type"
+      raise RDoc::Error, "Invalid list type: #{list_type.inspect}"
     end
   end
 
-  def list_end_for(fragment_type)
-    case fragment_type
-    when :BULLET, :NUMBER, :UPPERALPHA, :LOWERALPHA then
+  ##
+  # Ends a list item
+
+  def list_end_for(list_type)
+    case list_type
+    when :BULLET, :LALPHA, :NUMBER, :UALPHA then
       "</li>"
-    when :LABELED then
+    when :LABEL then
       "</dd>"
     when :NOTE then
       "</td></tr>"
     else
-      raise "Invalid list type"
+      raise RDoc::Error, "Invalid list type: #{list_type.inspect}"
     end
   end