rdoc 2.4.3 → 2.5

data/lib/rdoc/markup/attribute_manager.rb

@@ -1,5 +1,3 @@
-require 'rdoc/markup/inline'
-
 ##
 # Manages changes of attributes in a block of text
 
@@ -10,38 +8,69 @@ class RDoc::Markup::AttributeManager
 
   NULL = "\000".freeze
 
-  ##
+  #--
   # We work by substituting non-printing characters in to the text. For now
   # I'm assuming that I can substitute a character in the range 0..8 for a 7
   # bit character without damaging the encoded string, but this might be
   # optimistic
+  #++
 
-  A_PROTECT  = 004
-  PROTECT_ATTR  = A_PROTECT.chr
+  A_PROTECT  = 004 # :nodoc:
+
+  PROTECT_ATTR  = A_PROTECT.chr # :nodoc:
 
   ##
   # This maps delimiters that occur around words (such as *bold* or +tt+)
   # where the start and end delimiters and the same. This lets us optimize
   # the regexp
 
-  MATCHING_WORD_PAIRS = {}
+  attr_reader :matching_word_pairs
 
   ##
   # And this is used when the delimiters aren't the same. In this case the
   # hash maps a pattern to the attribute character
 
-  WORD_PAIR_MAP = {}
+  attr_reader :word_pair_map
 
   ##
   # This maps HTML tags to the corresponding attribute char
 
-  HTML_TAGS = {}
+  attr_reader :html_tags
+
+  ##
+  # A \ in front of a character that would normally be processed turns off
+  # processing. We do this by turning \< into <#{PROTECT}
+
+  attr_reader :protectable
 
   ##
   # And this maps _special_ sequences to a name. A special sequence is
   # something like a WikiWord
 
-  SPECIAL = {}
+  attr_reader :special
+
+  ##
+  # Creates a new attribute manager that understands bold, emphasized and
+  # teletype text.
+
+  def initialize
+    @html_tags = {}
+    @matching_word_pairs = {}
+    @protectable = %w[<\\]
+    @special = {}
+    @word_pair_map = {}
+
+    add_word_pair "*", "*", :BOLD
+    add_word_pair "_", "_", :EM
+    add_word_pair "+", "+", :TT
+
+    add_html "em", :EM
+    add_html "i",  :EM
+    add_html "b",  :BOLD
+    add_html "tt",   :TT
+    add_html "code", :TT
+  end
+
 
   ##
   # Return an attribute object with the given turn_on and turn_off bits set
@@ -81,19 +110,19 @@ class RDoc::Markup::AttributeManager
 
   def convert_attrs(str, attrs)
     # first do matching ones
-    tags = MATCHING_WORD_PAIRS.keys.join("")
+    tags = @matching_word_pairs.keys.join("")
 
     re = /(^|\W)([#{tags}])([#:\\]?[\w.\/-]+?\S?)\2(\W|$)/
 
     1 while str.gsub!(re) do
-      attr = MATCHING_WORD_PAIRS[$2]
+      attr = @matching_word_pairs[$2]
       attrs.set_attrs($`.length + $1.length + $2.length, $3.length, attr)
       $1 + NULL * $2.length + $3 + NULL * $2.length + $4
     end
 
     # then non-matching
-    unless WORD_PAIR_MAP.empty? then
-      WORD_PAIR_MAP.each do |regexp, attr|
+    unless @word_pair_map.empty? then
+      @word_pair_map.each do |regexp, attr|
         str.gsub!(regexp) {
           attrs.set_attrs($`.length + $1.length, $2.length, attr)
           NULL * $1.length + $2 + NULL * $3.length
@@ -106,10 +135,10 @@ class RDoc::Markup::AttributeManager
   # Converts HTML tags to RDoc attributes
 
   def convert_html(str, attrs)
-    tags = HTML_TAGS.keys.join '|'
+    tags = @html_tags.keys.join '|'
 
     1 while str.gsub!(/<(#{tags})>(.*?)<\/\1>/i) {
-      attr = HTML_TAGS[$1.downcase]
+      attr = @html_tags[$1.downcase]
       html_length = $1.length + 2
       seq = NULL * html_length
       attrs.set_attrs($`.length + html_length, $2.length, attr)
@@ -121,8 +150,8 @@ class RDoc::Markup::AttributeManager
   # Converts special sequences to RDoc attributes
 
   def convert_specials(str, attrs)
-    unless SPECIAL.empty?
-      SPECIAL.each do |regexp, attr|
+    unless @special.empty?
+      @special.each do |regexp, attr|
         str.scan(regexp) do
           attrs.set_attrs($`.length, $&.length,
                           attr | RDoc::Markup::Attribute::SPECIAL)
@@ -131,18 +160,12 @@ class RDoc::Markup::AttributeManager
     end
   end
 
-  ##
-  # A \ in front of a character that would normally be processed turns off
-  # processing. We do this by turning \< into <#{PROTECT}
-
-  PROTECTABLE = %w[<\\]
-
   ##
   # Escapes special sequences of text to prevent conversion to RDoc
 
   def mask_protected_sequences
-    protect_pattern = Regexp.new("\\\\([#{Regexp.escape(PROTECTABLE.join(''))}])")
-    @str.gsub!(protect_pattern, "\\1#{PROTECT_ATTR}")
+    @str.gsub!(/\\([#{Regexp.escape @protectable.join('')}])/,
+               "\\1#{PROTECT_ATTR}")
   end
 
   ##
@@ -152,22 +175,6 @@ class RDoc::Markup::AttributeManager
     @str.gsub!(/(.)#{PROTECT_ATTR}/, "\\1\000")
   end
 
-  ##
-  # Creates a new attribute manager that understands bold, emphasized and
-  # teletype text.
-
-  def initialize
-    add_word_pair("*", "*", :BOLD)
-    add_word_pair("_", "_", :EM)
-    add_word_pair("+", "+", :TT)
-
-    add_html("em", :EM)
-    add_html("i",  :EM)
-    add_html("b",  :BOLD)
-    add_html("tt",   :TT)
-    add_html("code", :TT)
-  end
-
   ##
   # Adds a markup class with +name+ for words wrapped in the +start+ and
   # +stop+ character.  To make words wrapped with "*" bold:
@@ -181,14 +188,14 @@ class RDoc::Markup::AttributeManager
     bitmap = RDoc::Markup::Attribute.bitmap_for name
 
     if start == stop then
-      MATCHING_WORD_PAIRS[start] = bitmap
+      @matching_word_pairs[start] = bitmap
     else
       pattern = /(#{Regexp.escape start})(\S+)(#{Regexp.escape stop})/
-      WORD_PAIR_MAP[pattern] = bitmap
+      @word_pair_map[pattern] = bitmap
     end
 
-    PROTECTABLE << start[0,1]
-    PROTECTABLE.uniq!
+    @protectable << start[0,1]
+    @protectable.uniq!
   end
 
   ##
@@ -198,7 +205,7 @@ class RDoc::Markup::AttributeManager
   #   am.add_html 'em', :EM
 
   def add_html(tag, name)
-    HTML_TAGS[tag.downcase] = RDoc::Markup::Attribute.bitmap_for name
+    @html_tags[tag.downcase] = RDoc::Markup::Attribute.bitmap_for name
   end
 
   ##
@@ -208,7 +215,7 @@ class RDoc::Markup::AttributeManager
   #   @am.add_special(/((https?:)\S+\w)/, :HYPERLINK)
 
   def add_special(pattern, name)
-    SPECIAL[pattern] = RDoc::Markup::Attribute.bitmap_for name
+    @special[pattern] = RDoc::Markup::Attribute.bitmap_for name
   end
 
   ##
@@ -221,9 +228,9 @@ class RDoc::Markup::AttributeManager
 
     @attrs = RDoc::Markup::AttrSpan.new @str.length
 
-    convert_attrs(@str, @attrs)
-    convert_html(@str, @attrs)
-    convert_specials(str, @attrs)
+    convert_attrs    @str, @attrs
+    convert_html     @str, @attrs
+    convert_specials @str, @attrs
 
     unmask_protected_sequences
 

data/lib/rdoc/markup/blank_line.rb

@@ -0,0 +1,19 @@
+##
+# An empty line
+
+class RDoc::Markup::BlankLine
+
+  def == other # :nodoc:
+    self.class == other.class
+  end
+
+  def accept visitor
+    visitor.accept_blank_line self
+  end
+
+  def pretty_print q # :nodoc:
+    q.text 'blankline'
+  end
+
+end
+

data/lib/rdoc/markup/document.rb

@@ -0,0 +1,72 @@
+##
+# A Document containing lists, headings, paragraphs, etc.
+
+class RDoc::Markup::Document
+
+  ##
+  # The parts of the Document
+
+  attr_reader :parts
+
+  ##
+  # Creates a new Document with +parts+
+
+  def initialize *parts
+    @parts = []
+    @parts.push(*parts)
+  end
+
+  ##
+  # Appends +part+ to the document
+
+  def << part
+    case part
+    when RDoc::Markup::Document then
+      unless part.empty? then
+        parts.push(*part.parts)
+        parts << RDoc::Markup::BlankLine.new
+      end
+    when String then
+      raise ArgumentError,
+            "expected RDoc::Markup::Document and friends, got String" unless
+        part.empty?
+    else
+      parts << part
+    end
+  end
+
+  def == other # :nodoc:
+    self.class == other.class and @parts == other.parts
+  end
+
+  def accept visitor
+    visitor.start_accepting
+
+    @parts.each do |item|
+      item.accept visitor
+    end
+
+    visitor.end_accepting
+  end
+
+  def empty?
+    @parts.empty?
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[doc: ', ']' do
+      q.seplist @parts do |part|
+        q.pp part
+      end
+    end
+  end
+
+  ##
+  # Appends +parts+ to the document
+
+  def push *parts
+    self.parts.push(*parts)
+  end
+
+end
+

data/lib/rdoc/markup/formatter.rb

@@ -7,11 +7,34 @@ require 'rdoc/markup'
 
 class RDoc::Markup::Formatter
 
+  InlineTag = Struct.new(:bit, :on, :off)
+
   ##
   # Creates a new Formatter
 
   def initialize
     @markup = RDoc::Markup.new
+    @am = @markup.attribute_manager
+    @attr_tags = []
+
+    @in_tt = 0
+    @tt_bit = RDoc::Markup::Attribute.bitmap_for :TT
+  end
+
+  ##
+  # Add a new set of tags for an attribute. We allow separate start and end
+  # tags for flexibility
+
+  def add_tag(name, start, stop)
+    attr = RDoc::Markup::Attribute.bitmap_for name
+    @attr_tags << InlineTag.new(attr, start, stop)
+  end
+
+  ##
+  # Allows +tag+ to be decorated with additional information.
+
+  def annotate(tag)
+    tag
   end
 
   ##
@@ -21,5 +44,100 @@ class RDoc::Markup::Formatter
     @markup.convert content, self
   end
 
+  ##
+  # Converts flow items +flow+
+
+  def convert_flow(flow)
+    res = []
+
+    flow.each do |item|
+      case item
+      when String then
+        res << convert_string(item)
+      when RDoc::Markup::AttrChanger then
+        off_tags res, item
+        on_tags res, item
+      when RDoc::Markup::Special then
+        res << convert_special(item)
+      else
+        raise "Unknown flow element: #{item.inspect}"
+      end
+    end
+
+    res.join
+  end
+
+  ##
+  # Converts added specials.  See RDoc::Markup#add_special
+
+  def convert_special(special)
+    handled = false
+
+    RDoc::Markup::Attribute.each_name_of special.type do |name|
+      method_name = "handle_special_#{name}"
+
+      if respond_to? method_name then
+        special.text = send method_name, special
+        handled = true
+      end
+    end
+
+    raise "Unhandled special: #{special}" unless handled
+
+    special.text
+  end
+
+  ##
+  # Converts a string to be fancier if desired
+
+  def convert_string string
+    string
+  end
+
+  ##
+  # Are we currently inside tt tags?
+
+  def in_tt?
+    @in_tt > 0
+  end
+
+  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 then
+        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 then
+        @in_tt -= 1 if tt? tag
+        res << annotate(tag.off)
+      end
+    end
+  end
+
+  ##
+  # Is +tag+ a tt tag?
+
+  def tt? tag
+    tag.bit == @tt_bit
+  end
+
 end
 
+class RDoc::Markup
+  autoload :ToAnsi,         'rdoc/markup/to_ansi'
+  autoload :ToBs,           'rdoc/markup/to_bs'
+  autoload :ToHtml,         'rdoc/markup/to_html'
+  autoload :ToHtmlCrossref, 'rdoc/markup/to_html_crossref'
+  autoload :ToRdoc,         'rdoc/markup/to_rdoc'
+end

data/lib/rdoc/markup/formatter_test_case.rb

@@ -0,0 +1,341 @@
+require 'minitest/unit'
+require 'rdoc/markup/formatter'
+
+##
+# Test case for creating new RDoc::Markup formatters.  See
+# test/test_rdoc_markup_to_*.rb for examples.
+
+class RDoc::Markup::FormatterTestCase < MiniTest::Unit::TestCase
+
+  def setup
+    super
+
+    @m = RDoc::Markup.new
+    @am = RDoc::Markup::AttributeManager.new
+    @RM = RDoc::Markup
+
+    @bullet_list = @RM::List.new(:BULLET,
+      @RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
+      @RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
+
+    @label_list = @RM::List.new(:LABEL,
+      @RM::ListItem.new('cat', @RM::Paragraph.new('cats are cool')),
+      @RM::ListItem.new('dog', @RM::Paragraph.new('dogs are cool too')))
+
+    @lalpha_list = @RM::List.new(:LALPHA,
+      @RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
+      @RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
+
+    @note_list = @RM::List.new(:NOTE,
+      @RM::ListItem.new('cat', @RM::Paragraph.new('cats are cool')),
+      @RM::ListItem.new('dog', @RM::Paragraph.new('dogs are cool too')))
+
+    @number_list = @RM::List.new(:NUMBER,
+      @RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
+      @RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
+
+    @ualpha_list = @RM::List.new(:UALPHA,
+      @RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
+      @RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
+  end
+
+  def self.add_visitor_tests
+    self.class_eval do
+      def test_start_accepting
+        @to.start_accepting
+
+        start_accepting
+      end
+
+      def test_end_accepting
+        @to.start_accepting
+        @to.res << 'hi'
+
+        end_accepting
+      end
+
+      def test_accept_blank_line
+        @to.start_accepting
+
+        @to.accept_blank_line @RM::BlankLine.new
+
+        accept_blank_line
+      end
+
+      def test_accept_heading
+        @to.start_accepting
+
+        @to.accept_heading @RM::Heading.new(5, 'Hello')
+
+        accept_heading
+      end
+
+      def test_accept_paragraph
+        @to.start_accepting
+
+        @to.accept_paragraph @RM::Paragraph.new('hi')
+
+        accept_paragraph
+      end
+
+      def test_accept_verbatim
+        @to.start_accepting
+
+        @to.accept_verbatim @RM::Verbatim.new('  ', 'hi', "\n",
+                                              '  ', 'world', "\n")
+
+        accept_verbatim
+      end
+
+      def test_accept_rule
+        @to.start_accepting
+
+        @to.accept_rule @RM::Rule.new(4)
+
+        accept_rule
+      end
+
+      def test_accept_list_item_start_bullet
+        @to.start_accepting
+
+        @to.accept_list_start @bullet_list
+
+        @to.accept_list_item_start @bullet_list.items.first
+
+        accept_list_item_start_bullet
+      end
+
+      def test_accept_list_item_start_label
+        @to.start_accepting
+
+        @to.accept_list_start @label_list
+
+        @to.accept_list_item_start @label_list.items.first
+
+        accept_list_item_start_label
+      end
+
+      def test_accept_list_item_start_lalpha
+        @to.start_accepting
+
+        @to.accept_list_start @lalpha_list
+
+        @to.accept_list_item_start @lalpha_list.items.first
+
+        accept_list_item_start_lalpha
+      end
+
+      def test_accept_list_item_start_note
+        @to.start_accepting
+
+        @to.accept_list_start @note_list
+
+        @to.accept_list_item_start @note_list.items.first
+
+        accept_list_item_start_note
+      end
+
+      def test_accept_list_item_start_number
+        @to.start_accepting
+
+        @to.accept_list_start @number_list
+
+        @to.accept_list_item_start @number_list.items.first
+
+        accept_list_item_start_number
+      end
+
+      def test_accept_list_item_start_ualpha
+        @to.start_accepting
+
+        @to.accept_list_start @ualpha_list
+
+        @to.accept_list_item_start @ualpha_list.items.first
+
+        accept_list_item_start_ualpha
+      end
+
+      def test_accept_list_item_end_bullet
+        @to.start_accepting
+
+        @to.accept_list_start @bullet_list
+
+        @to.accept_list_item_start @bullet_list.items.first
+
+        @to.accept_list_item_end @bullet_list.items.first
+
+        accept_list_item_end_bullet
+      end
+
+      def test_accept_list_item_end_label
+        @to.start_accepting
+
+        @to.accept_list_start @label_list
+
+        @to.accept_list_item_start @label_list.items.first
+
+        @to.accept_list_item_end @label_list.items.first
+
+        accept_list_item_end_label
+      end
+
+      def test_accept_list_item_end_lalpha
+        @to.start_accepting
+
+        @to.accept_list_start @lalpha_list
+
+        @to.accept_list_item_start @lalpha_list.items.first
+
+        @to.accept_list_item_end @lalpha_list.items.first
+
+        accept_list_item_end_lalpha
+      end
+
+      def test_accept_list_item_end_note
+        @to.start_accepting
+
+        @to.accept_list_start @note_list
+
+        @to.accept_list_item_start @note_list.items.first
+
+        @to.accept_list_item_end @note_list.items.first
+
+        accept_list_item_end_note
+      end
+
+      def test_accept_list_item_end_number
+        @to.start_accepting
+
+        @to.accept_list_start @number_list
+
+        @to.accept_list_item_start @number_list.items.first
+
+        @to.accept_list_item_end @number_list.items.first
+
+        accept_list_item_end_number
+      end
+
+      def test_accept_list_item_end_ualpha
+        @to.start_accepting
+
+        @to.accept_list_start @ualpha_list
+
+        @to.accept_list_item_start @ualpha_list.items.first
+
+        @to.accept_list_item_end @ualpha_list.items.first
+
+        accept_list_item_end_ualpha
+      end
+
+      def test_accept_list_start_bullet
+        @to.start_accepting
+
+        @to.accept_list_start @bullet_list
+
+        accept_list_start_bullet
+      end
+
+      def test_accept_list_start_label
+        @to.start_accepting
+
+        @to.accept_list_start @label_list
+
+        accept_list_start_label
+      end
+
+      def test_accept_list_start_lalpha
+        @to.start_accepting
+
+        @to.accept_list_start @lalpha_list
+
+        accept_list_start_lalpha
+      end
+
+      def test_accept_list_start_note
+        @to.start_accepting
+
+        @to.accept_list_start @note_list
+
+        accept_list_start_note
+      end
+
+      def test_accept_list_start_number
+        @to.start_accepting
+
+        @to.accept_list_start @number_list
+
+        accept_list_start_number
+      end
+
+      def test_accept_list_start_ualpha
+        @to.start_accepting
+
+        @to.accept_list_start @ualpha_list
+
+        accept_list_start_ualpha
+      end
+
+      def test_accept_list_end_bullet
+        @to.start_accepting
+
+        @to.accept_list_start @bullet_list
+
+        @to.accept_list_end @bullet_list
+
+        accept_list_end_bullet
+      end
+
+      def test_accept_list_end_label
+        @to.start_accepting
+
+        @to.accept_list_start @label_list
+
+        @to.accept_list_end @label_list
+
+        accept_list_end_label
+      end
+
+      def test_accept_list_end_lalpha
+        @to.start_accepting
+
+        @to.accept_list_start @lalpha_list
+
+        @to.accept_list_end @lalpha_list
+
+        accept_list_end_lalpha
+      end
+
+      def test_accept_list_end_number
+        @to.start_accepting
+
+        @to.accept_list_start @number_list
+
+        @to.accept_list_end @number_list
+
+        accept_list_end_number
+      end
+
+      def test_accept_list_end_note
+        @to.start_accepting
+
+        @to.accept_list_start @note_list
+
+        @to.accept_list_end @note_list
+
+        accept_list_end_note
+      end
+
+      def test_accept_list_end_ualpha
+        @to.start_accepting
+
+        @to.accept_list_start @ualpha_list
+
+        @to.accept_list_end @ualpha_list
+
+        accept_list_end_ualpha
+      end
+    end
+  end
+
+end
+