rdoc 3.12.2 → 4.0.0.preview2

data/lib/rdoc/markup/raw.rb

@@ -13,7 +13,7 @@ class RDoc::Markup::Raw
 
   def initialize *parts
     @parts = []
-    @parts.push(*parts)
+    @parts.concat parts
   end
 
   ##
@@ -38,11 +38,11 @@ class RDoc::Markup::Raw
   # Appends +other+'s parts
 
   def merge other
-    @parts.push(*other.parts)
+    @parts.concat other.parts
   end
 
   def pretty_print q # :nodoc:
-    self.class.name =~ /.*::(\w{1,4})$/i
+    self.class.name =~ /.*::(\w{1,4})/i
 
     q.group 2, "[#{$1.downcase}: ", ']' do
       q.seplist @parts do |part|
@@ -55,7 +55,7 @@ class RDoc::Markup::Raw
   # Appends +texts+ onto this Paragraph
 
   def push *texts
-    self.parts.push(*texts)
+    self.parts.concat texts
   end
 
   ##

data/lib/rdoc/markup/special.rb

@@ -28,12 +28,12 @@ class RDoc::Markup::Special
   end
 
   def inspect # :nodoc:
-    "#<RDoc::Markup::Special:0x%x @type=%p, name=%p @text=%p>" % [
-      object_id, @type, RDoc::Markup::Attribute.as_string(type), text.dump]
+    "#<RDoc::Markup::Special:0x%x @type=%p, @text=%p>" % [
+      object_id, @type, text.dump]
   end
 
   def to_s # :nodoc:
-    "Special: type=#{type}, name=#{RDoc::Markup::Attribute.as_string type}, text=#{text.dump}"
+    "Special: type=#{type} text=#{text.dump}"
   end
 
 end

data/lib/rdoc/markup/to_ansi.rb

@@ -56,7 +56,13 @@ class RDoc::Markup::ToAnsi < RDoc::Markup::ToRdoc
              when :BULLET then
                '*'
              when :NOTE, :LABEL then
-               attributes(list_item.label).strip + ":\n"
+               labels = Array(list_item.label).map do |label|
+                 attributes(label).strip
+               end.join "\n"
+
+               labels << ":\n" unless labels.empty?
+
+               labels
              else
                @list_index.last.to_s + '.'
              end

data/lib/rdoc/markup/to_html.rb

@@ -65,7 +65,7 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
   ##
   # Creates a new formatter that will output HTML
 
-  def initialize markup = nil
+  def initialize options, markup = nil
     super
 
     @code_object = nil
@@ -73,16 +73,23 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     @in_list_entry = nil
     @list = nil
     @th = nil
+    @hard_break = "<br>\n"
 
     # external links
-    @markup.add_special(/((link:|https?:|mailto:|ftp:|irc:|www\.)\S+\w)/,
+    @markup.add_special(/(?:link:|https?:|mailto:|ftp:|irc:|www\.)\S+\w/,
                         :HYPERLINK)
 
     # internal links
     @markup.add_special(/rdoc-[a-z]+:\S+/, :RDOCLINK)
 
     # and links of the form  <text>[<url>]
-    @markup.add_special(/(((\{.*?\})|\b\S+?)\[\S+?\])/, :TIDYLINK)
+    @markup.add_special(/(?:
+                          \{.*?\} |   # multi-word label
+                          \b[^\s{}]+? # single-word label
+                         )
+
+                         \[\S+?\]     # link target
+                        /x, :TIDYLINK)
 
     init_tags
   end
@@ -91,6 +98,13 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
   #
   # These methods handle special markup added by RDoc::Markup#add_special.
 
+  ##
+  # +special+ is a <code><br></code>
+
+  def handle_special_HARD_BREAK special
+    '<br>'
+  end
+
   ##
   # +special+ is a potential link.  The following schemes are handled:
   #
@@ -176,12 +190,26 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     @res.join
   end
 
+  ##
+  # Adds +block_quote+ to the output
+
+  def accept_block_quote block_quote
+    @res << "\n<blockquote>"
+
+    block_quote.parts.each do |part|
+      part.accept self
+    end
+
+    @res << "</blockquote>\n"
+  end
+
   ##
   # Adds +paragraph+ to the output
 
-  def accept_paragraph(paragraph)
+  def accept_paragraph paragraph
     @res << "\n<p>"
-    @res << wrap(to_html(paragraph.text))
+    text = paragraph.text @hard_break
+    @res << wrap(to_html(text))
     @res << "</p>\n"
   end
 
@@ -192,14 +220,12 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     text = verbatim.text.rstrip
 
     @res << if verbatim.ruby? or parseable? text then
-              options = RDoc::RDoc.current.options if RDoc::RDoc.current
-
               begin
-                tokens = RDoc::RubyLex.tokenize text, options
+                tokens = RDoc::RubyLex.tokenize text, @options
+
+                html = RDoc::TokenStream.to_html tokens
 
-                "\n<pre class=\"ruby\">" \
-                "#{RDoc::TokenStream.to_html tokens}" \
-                "</pre>\n"
+                "\n<pre class=\"ruby\">#{html}</pre>\n"
               rescue RDoc::RubyLex::Error
                 "\n<pre>#{CGI.escapeHTML text}</pre>\n"
               end
@@ -288,7 +314,7 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
   # :section: Utilities
 
   ##
-  # CGI escapes +text+
+  # CGI-escapes +text+
 
   def convert_string(text)
     CGI.escapeHTML text
@@ -355,7 +381,9 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     when :BULLET, :LALPHA, :NUMBER, :UALPHA then
       "<li>"
     when :LABEL, :NOTE then
-      "<dt>#{to_html list_item.label}\n<dd>"
+      Array(list_item.label).map do |label|
+        "<dt>#{to_html label}\n"
+      end.join << "<dd>"
     else
       raise RDoc::Error, "Invalid list type: #{list_type.inspect}"
     end
@@ -379,7 +407,7 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
   # Returns true if Ripper is available it can create a sexp from +text+
 
   def parseable? text
-    text =~ /\b(def|class|module|require)\b|=>|\{\s?\||do \|/ and
+    text =~ /\b(def|class|module|require) |=>|\{\s?\||do \|/ and
       text !~ /<%|%>/
   end
 

data/lib/rdoc/markup/to_html_crossref.rb

@@ -28,21 +28,20 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
   # references are removed unless +show_hash+ is true.  Only method names
   # preceded by '#' or '::' are linked, unless +hyperlink_all+ is true.
 
-  def initialize(from_path, context, show_hash, hyperlink_all = false,
-                 markup = nil)
+  def initialize(options, from_path, context, markup = nil)
     raise ArgumentError, 'from_path cannot be nil' if from_path.nil?
-    super markup
 
-    crossref_re = hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
+    super options, markup
 
-    @cross_reference = RDoc::CrossReference.new context
+    @context       = context
+    @from_path     = from_path
+    @hyperlink_all = @options.hyperlink_all
+    @show_hash     = @options.show_hash
 
+    crossref_re = @hyperlink_all ? ALL_CROSSREF_REGEXP : CROSSREF_REGEXP
     @markup.add_special crossref_re, :CROSSREF
 
-    @context       = context
-    @from_path     = from_path
-    @hyperlink_all = hyperlink_all
-    @show_hash     = show_hash
+    @cross_reference = RDoc::CrossReference.new @context
   end
 
   ##
@@ -71,6 +70,8 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
   def handle_special_CROSSREF(special)
     name = special.text
 
+    return name if name =~ /@[\w-]+\.[\w-]/ # labels that look like emails
+
     unless @hyperlink_all then
       # This ensures that words entirely consisting of lowercase letters will
       # not have cross-references generated (to suppress lots of erroneous

data/lib/rdoc/markup/to_html_snippet.rb

@@ -33,8 +33,8 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
   # next word boundary after the given number of +characters+ or +paragraphs+
   # of text have been encountered.
 
-  def initialize characters = 100, paragraphs = 3, markup = nil
-    super markup
+  def initialize options, characters = 100, paragraphs = 3, markup = nil
+    super options, markup
 
     @character_limit = characters
     @paragraph_limit = paragraphs
@@ -68,7 +68,9 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
   def accept_paragraph paragraph
     para = @in_list_entry.last || "<p>"
 
-    @res << "#{para}#{wrap to_html paragraph.text}\n"
+    text = paragraph.text @hard_break
+
+    @res << "#{para}#{wrap to_html text}\n"
 
     add_paragraph
   end
@@ -126,6 +128,14 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
     special.text.sub(/\A\\/, '')
   end
 
+  ##
+  # +special+ is a <code><br></code>
+
+  def handle_special_HARD_BREAK special
+    @characters -= 4
+    '<br>'
+  end
+
   ##
   # Lists are paragraphs, but notes and labels have a separator
 
@@ -136,7 +146,13 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
     when :BULLET, :LALPHA, :NUMBER, :UALPHA then
       "<p>"
     when :LABEL, :NOTE then
-      start = "<p>#{to_html list_item.label} &mdash; "
+      labels = Array(list_item.label).map do |label|
+        to_html label
+      end.join ', '
+
+      labels << " &mdash; " unless labels.empty?
+
+      start = "<p>#{labels}"
       @characters += 1 # try to include the label
       start
     else

data/lib/rdoc/markup/to_joined_paragraph.rb

@@ -0,0 +1,68 @@
+##
+# Joins the parts of an RDoc::Markup::Paragraph into a single String.
+#
+# This allows for easier maintenance and testing of Markdown support.
+#
+# This formatter only works on Paragraph instances.  Attempting to process
+# other markup syntax items will not work.
+
+class RDoc::Markup::ToJoinedParagraph < RDoc::Markup::Formatter
+
+  def initialize # :nodoc:
+    super nil
+  end
+
+  def start_accepting
+  end
+
+  def end_accepting
+  end
+
+  def accept_paragraph paragraph
+    parts = []
+    string = false
+
+    paragraph.parts.each do |part|
+      if String === part then
+        if string then
+          string << part
+        else
+          parts << part
+          string = part
+        end
+      else
+        parts << part
+        string = false
+      end
+    end
+
+    parts = parts.map do |part|
+      if String === part then
+        part.rstrip
+      else
+        part
+      end
+    end
+
+    # TODO use Enumerable#chunk when ruby 1.8 support is dropped
+    #parts = paragraph.parts.chunk do |part|
+    #  String === part
+    #end.map do |string, chunk|
+    #  string ? chunk.join.rstrip : chunk
+    #end.flatten
+
+    paragraph.parts.replace parts
+  end
+
+  alias accept_block_quote     ignore
+  alias accept_heading         ignore
+  alias accept_list_end        ignore
+  alias accept_list_item_end   ignore
+  alias accept_list_item_start ignore
+  alias accept_list_start      ignore
+  alias accept_raw             ignore
+  alias accept_rule            ignore
+  alias accept_verbatim        ignore
+
+end
+

data/lib/rdoc/markup/to_label.rb

@@ -7,11 +7,13 @@ require 'cgi'
 
 class RDoc::Markup::ToLabel < RDoc::Markup::Formatter
 
+  attr_reader :res # :nodoc:
+
   ##
   # Creates a new formatter that will output HTML-safe labels
 
   def initialize markup = nil
-    super
+    super nil, markup
 
     @markup.add_special RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
     @markup.add_special(/(((\{.*?\})|\b\S+?)\[\S+?\])/, :TIDYLINK)
@@ -19,6 +21,8 @@ class RDoc::Markup::ToLabel < RDoc::Markup::Formatter
     add_tag :BOLD, '', ''
     add_tag :TT,   '', ''
     add_tag :EM,   '', ''
+
+    @res = []
   end
 
   ##
@@ -51,5 +55,20 @@ class RDoc::Markup::ToLabel < RDoc::Markup::Formatter
     $1
   end
 
+  alias accept_blank_line         ignore
+  alias accept_block_quote        ignore
+  alias accept_heading            ignore
+  alias accept_list_end           ignore
+  alias accept_list_item_end      ignore
+  alias accept_list_item_start    ignore
+  alias accept_list_start         ignore
+  alias accept_paragraph          ignore
+  alias accept_raw                ignore
+  alias accept_rule               ignore
+  alias accept_verbatim           ignore
+  alias end_accepting             ignore
+  alias handle_special_HARD_BREAK ignore
+  alias start_accepting           ignore
+
 end
 

data/lib/rdoc/markup/to_markdown.rb

@@ -0,0 +1,134 @@
+# :markup: markdown
+
+##
+# Outputs parsed markup as Markdown
+
+class RDoc::Markup::ToMarkdown < RDoc::Markup::ToRdoc
+
+  ##
+  # Creates a new formatter that will output Markdown format text
+
+  def initialize markup = nil
+    super
+
+    @headings[1] = ['# ',      '']
+    @headings[2] = ['## ',     '']
+    @headings[3] = ['### ',    '']
+    @headings[4] = ['#### ',   '']
+    @headings[5] = ['##### ',  '']
+    @headings[6] = ['###### ', '']
+
+    @hard_break = "  \n"
+  end
+
+  ##
+  # Maps attributes to HTML sequences
+
+  def init_tags
+    add_tag :BOLD, '**', '**'
+    add_tag :EM,   '*',  '*'
+    add_tag :TT,   '`',  '`'
+  end
+
+  ##
+  # Adds a newline to the output
+
+  def handle_special_HARD_BREAK special
+    "  \n"
+  end
+
+  ##
+  # Finishes consumption of `list`
+
+  def accept_list_end list
+    @res << "\n"
+
+    super
+  end
+
+  ##
+  # Finishes consumption of `list_item`
+
+  def accept_list_item_end list_item
+    width = case @list_type.last
+            when :BULLET then
+              4
+            when :NOTE, :LABEL then
+              use_prefix
+
+              4
+            else
+              @list_index[-1] = @list_index.last.succ
+              4
+            end
+
+    @indent -= width
+  end
+
+  ##
+  # Prepares the visitor for consuming `list_item`
+
+  def accept_list_item_start list_item
+    type = @list_type.last
+
+    case type
+    when :NOTE, :LABEL then
+      bullets = Array(list_item.label).map do |label|
+        attributes(label).strip
+      end.join "\n"
+
+      bullets << "\n:"
+
+      @prefix = ' ' * @indent
+      @indent += 4
+      @prefix << bullets + (' ' * (@indent - 1))
+    else
+      bullet = type == :BULLET ? '*' : @list_index.last.to_s + '.'
+      @prefix = (' ' * @indent) + bullet.ljust(4)
+
+      @indent += 4
+    end
+  end
+
+  ##
+  # Prepares the visitor for consuming `list`
+
+  def accept_list_start list
+    case list.type
+    when :BULLET, :LABEL, :NOTE then
+      @list_index << nil
+    when :LALPHA, :NUMBER, :UALPHA then
+      @list_index << 1
+    else
+      raise RDoc::Error, "invalid list type #{list.type}"
+    end
+
+    @list_width << 4
+    @list_type << list.type
+  end
+
+  ##
+  # Adds `rule` to the output
+
+  def accept_rule rule
+    use_prefix or @res << ' ' * @indent
+    @res << '-' * 3
+    @res << "\n"
+  end
+
+  ##
+  # Outputs `verbatim` indented 4 columns
+
+  def accept_verbatim verbatim
+    indent = ' ' * (@indent + 4)
+
+    verbatim.parts.each do |part|
+      @res << indent unless part == "\n"
+      @res << part
+    end
+
+    @res << "\n" unless @res =~ /\n\z/
+  end
+
+end
+