rdoc 2.4.3 → 2.5

data/lib/rdoc/markup/to_html_crossref.rb

@@ -7,15 +7,21 @@ require 'rdoc/markup/to_html'
 class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
 
   ##
-  # Regular expressions to match class and method references.
+  # Regular expression to match class references
   #
   # 1) There can be a '\' in front of text to suppress any cross-references
   # 2) There can be a '::' in front of class names to reference from the
   #    top-level namespace.
-  # 3) The method can be followed by parenthesis which may
+  # 3) The method can be followed by parenthesis
 
   CLASS_REGEXP_STR = '\\\\?((?:\:{2})?[A-Z]\w*(?:\:\:\w+)*)'
-  METHOD_REGEXP_STR = '(\w+[!?=]?)(?:\([\.\w+\*\/\+\-\=\<\>]*\))?'
+
+  ##
+  # Regular expression to match method references.
+  #
+  # See CLASS_REGEXP_STR
+
+  METHOD_REGEXP_STR = '(\w+[!?=]?)(?:\([\w.+*/=<>-]*\))?'
 
   ##
   # Regular expressions matching text that should potentially have
@@ -50,7 +56,7 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
                       # The key thing is that there must be at least
                       # one special character (period, slash, or
                       # underscore).
-                      | [\/\w]+[_\/\.][\w\/\.]+
+                      | (?:\.\.\/)*[-\/\w]+[_\/\.][-\w\/\.]+
 
                       # Things that have markup suppressed
                       | \\[^\s]

data/lib/rdoc/markup/to_rdoc.rb

@@ -0,0 +1,243 @@
+require 'rdoc/markup/inline'
+
+##
+# Outputs RDoc markup as RDoc markup! (mostly)
+
+class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
+
+  attr_accessor :indent
+  attr_reader :list_index
+  attr_reader :list_type
+  attr_reader :list_width
+  attr_reader :prefix
+  attr_reader :res
+
+  def initialize
+    super
+
+    @markup.add_special(/\\[^\s]/, :SUPPRESSED_CROSSREF)
+
+    @width = 78
+    @prefix = ''
+
+    init_tags
+
+    @headings = {}
+    @headings.default = []
+
+    @headings[1] = ['= ',      '']
+    @headings[2] = ['== ',     '']
+    @headings[3] = ['=== ',    '']
+    @headings[4] = ['==== ',   '']
+    @headings[5] = ['===== ',  '']
+    @headings[6] = ['====== ', '']
+  end
+
+  ##
+  # Maps attributes to ANSI sequences
+
+  def init_tags
+    add_tag :BOLD, "<b>", "</b>"
+    add_tag :TT,   "<tt>", "</tt>"
+    add_tag :EM,   "<em>", "</em>"
+  end
+
+  def accept_blank_line blank_line
+    @res << "\n"
+  end
+
+  def accept_heading heading
+    use_prefix or @res << ' ' * @indent
+    @res << @headings[heading.level][0]
+    @res << attributes(heading.text)
+    @res << @headings[heading.level][1]
+    @res << "\n"
+  end
+
+  def accept_list_end list
+    @list_index.pop
+    @list_type.pop
+    @list_width.pop
+  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.length + 1
+
+      @indent += width
+    end
+  end
+
+  def accept_list_start list
+    case list.type
+    when :BULLET then
+      @list_index << nil
+      @list_width << 1
+    when :LABEL, :NOTE then
+      @list_index << nil
+      @list_width << 2
+    when :LALPHA then
+      @list_index << 'a'
+      @list_width << list.items.length.to_s.length
+    when :NUMBER then
+      @list_index << 1
+      @list_width << list.items.length.to_s.length
+    when :UALPHA then
+      @list_index << 'A'
+      @list_width << list.items.length.to_s.length
+    else
+      raise RDoc::Error, "invalid list type #{list.type}"
+    end
+
+    @list_type << list.type
+  end
+
+  def accept_paragraph paragraph
+    wrap attributes(paragraph.text)
+  end
+
+  def accept_rule rule
+    use_prefix or @res << ' ' * @indent
+    @res << '-' * (@width - @indent)
+    @res << "\n"
+  end
+
+  ##
+  # Outputs +verbatim+ flush left and indented 2 columns
+
+  def accept_verbatim verbatim
+    indent = ' ' * (@indent + 2)
+
+    lines = []
+    current_line = []
+
+    # split into lines
+    verbatim.parts.each do |part|
+      current_line << part
+
+      if part == "\n" then
+        lines << current_line
+        current_line = []
+      end
+    end
+
+    lines << current_line unless current_line.empty?
+
+    # calculate margin
+    indented = lines.select { |line| line != ["\n"] }
+    margin = indented.map { |line| line.first.length }.min
+
+    # flush left
+    indented.each { |line| line[0][0...margin] = '' }
+
+    # output
+    use_prefix or @res << indent # verbatim is unlikely to have prefix
+    @res << lines.shift.join
+
+    lines.each do |line|
+      @res << indent unless line == ["\n"]
+      @res << line.join
+    end
+
+    @res << "\n"
+  end
+
+  def attributes text
+    flow = @am.flow text.dup
+    convert_flow flow
+  end
+
+  def end_accepting
+    @res.join
+  end
+
+  def handle_special_SUPPRESSED_CROSSREF special
+    special.text.sub(/\\/, '')
+  end
+
+  def start_accepting
+    @res = [""]
+    @indent = 0
+    @prefix = nil
+
+    @list_index = []
+    @list_type  = []
+    @list_width = []
+  end
+
+  def use_prefix
+    prefix = @prefix
+    @prefix = nil
+    @res << prefix if prefix
+
+    prefix
+  end
+
+  def wrap text
+    return unless text && !text.empty?
+
+    text_len = @width - @indent
+
+    text_len = 20 if text_len < 20
+
+    re = /^(.{0,#{text_len}})[ \n]/
+    next_prefix = ' ' * @indent
+
+    prefix = @prefix || next_prefix
+    @prefix = nil
+
+    @res << prefix
+
+    while text.length > text_len
+      if text =~ re then
+        @res << $1
+        text.slice!(0, $&.length)
+      else
+        @res << text.slice!(0, text_len)
+      end
+
+      @res << "\n" << next_prefix
+    end
+
+    if text.empty? then
+      @res.pop
+      @res.pop
+    else
+      @res << text
+      @res << "\n"
+    end
+  end
+
+end
+

data/lib/rdoc/markup/to_test.rb

@@ -11,42 +11,53 @@ class RDoc::Markup::ToTest < RDoc::Markup::Formatter
 
   def start_accepting
     @res = []
+    @list = []
   end
 
   def end_accepting
     @res
   end
 
-  def accept_paragraph(am, fragment)
-    @res << fragment.to_s
+  def accept_paragraph(paragraph)
+    @res << paragraph.text
   end
 
-  def accept_verbatim(am, fragment)
-    @res << fragment.to_s
+  def accept_verbatim(verbatim)
+    @res << verbatim.text
   end
 
-  def accept_list_start(am, fragment)
-    @res << fragment.to_s
+  def accept_list_start(list)
+    @list << case list.type
+             when :BULLET then
+               '*'
+             when :NUMBER then
+               '1'
+             else
+               list.type
+             end
   end
 
-  def accept_list_end(am, fragment)
-    @res << fragment.to_s
+  def accept_list_end(list)
+    @list.pop
   end
 
-  def accept_list_item(am, fragment)
-    @res << fragment.to_s
+  def accept_list_item_start(list_item)
+    @res << "#{' ' * (@list.size - 1)}#{@list.last}: "
   end
 
-  def accept_blank_line(am, fragment)
-    @res << fragment.to_s
+  def accept_list_item_end(list_item)
   end
 
-  def accept_heading(am, fragment)
-    @res << fragment.to_s
+  def accept_blank_line(blank_line)
+    @res << "\n"
   end
 
-  def accept_rule(am, fragment)
-    @res << fragment.to_s
+  def accept_heading(heading)
+    @res << "#{'=' * heading.level} #{heading.text}"
+  end
+
+  def accept_rule(rule)
+    @res << '-' * rule.weight
   end
 
 end

data/lib/rdoc/markup/verbatim.rb

@@ -0,0 +1,42 @@
+##
+# A section of verbatim text
+
+class RDoc::Markup::Verbatim < RDoc::Markup::Paragraph
+
+  def accept visitor
+    visitor.accept_verbatim self
+  end
+
+  ##
+  # Collapses 3+ newlines into two newlines
+
+  def normalize
+    parts = []
+
+    newlines = 0
+
+    @parts.each do |part|
+      case part
+      when /\n/ then
+        newlines += 1
+        parts << part if newlines <= 2
+      else
+        newlines = 0
+        parts << part
+      end
+    end
+
+    parts.slice!(-1) if parts[-2..-1] == ["\n", "\n"]
+
+    @parts = parts
+  end
+
+  ##
+  # The text of the section
+
+  def text
+    @parts.join
+  end
+
+end
+

data/lib/rdoc/normal_class.rb

@@ -5,6 +5,13 @@ require 'rdoc/class_module'
 
 class RDoc::NormalClass < RDoc::ClassModule
 
+  ##
+  # Ancestor ClassModules
+
+  def ancestors
+    includes + [superclass]
+  end
+
   def inspect # :nodoc:
     superclass = @superclass ? " < #{@superclass}" : nil
     "<%s:0x%x class %s%s includes: %p attributes: %p methods: %p aliases: %p>" % [
@@ -13,6 +20,36 @@ class RDoc::NormalClass < RDoc::ClassModule
     ]
   end
 
-end
+  def pretty_print q # :nodoc:
+    superclass = @superclass ? " < #{@superclass}" : nil
+
+    q.group 2, "[class #{full_name}#{superclass} ", "]" do
+      q.breakable
+      q.text "includes:"
+      q.breakable
+      q.seplist @includes do |inc| q.pp inc end
 
+      q.breakable
+      q.text "attributes:"
+      q.breakable
+      q.seplist @attributes do |inc| q.pp inc end
+
+      q.breakable
+      q.text "methods:"
+      q.breakable
+      q.seplist @method_list do |inc| q.pp inc end
+
+      q.breakable
+      q.text "aliases:"
+      q.breakable
+      q.seplist @aliases do |inc| q.pp inc end
+
+      q.breakable
+      q.text "comment:"
+      q.breakable
+      q.pp comment
+    end
+  end
+
+end
 

data/lib/rdoc/normal_module.rb

@@ -6,14 +6,9 @@ require 'rdoc/class_module'
 class RDoc::NormalModule < RDoc::ClassModule
 
   ##
-  # Appends +comment+ to the current comment, but separated by a rule
+  # Included NormalModules
 
-  def comment=(comment)
-    return if comment.empty?
-    comment = @comment << "\n# ---\n" << comment unless @comment.empty?
-
-    super
-  end
+  alias ancestors includes
 
   def inspect # :nodoc:
     "#<%s:0x%x module %s includes: %p attributes: %p methods: %p aliases: %p>" % [
@@ -29,6 +24,41 @@ class RDoc::NormalModule < RDoc::ClassModule
     true
   end
 
-end
+  def pretty_print q # :nodoc:
+    q.group 2, "[module #{full_name}: ", "]" do
+      q.breakable
+      q.text "includes:"
+      q.breakable
+      q.seplist @includes do |inc| q.pp inc end
+      q.breakable
+
+      q.text "attributes:"
+      q.breakable
+      q.seplist @attributes do |inc| q.pp inc end
+      q.breakable
 
+      q.text "methods:"
+      q.breakable
+      q.seplist @method_list do |inc| q.pp inc end
+      q.breakable
+
+      q.text "aliases:"
+      q.breakable
+      q.seplist @aliases do |inc| q.pp inc end
+      q.breakable
+
+      q.text "comment:"
+      q.breakable
+      q.pp comment
+    end
+  end
+
+  ##
+  # Modules don't have one, raises NoMethodError
+
+  def superclass
+    raise NoMethodError, "#{full_name} is a module"
+  end
+
+end