rdoc 7.1.0 → 7.2.0

data/lib/rdoc/markdown.rb

@@ -688,6 +688,20 @@ class RDoc::Markdown
     end
   end
 
+  # Escape character that has special meaning in RDoc format.
+  # To allow rdoc-styled link used in markdown format for now, bracket and brace are not escaped.
+
+  def rdoc_escape(text)
+    text.gsub(/[*+<\\_]/) {|s| "\\#{s}" }
+  end
+
+  # Escape link url that contains brackets.
+  # Brackets needs escape because link url will be surrounded by `[]` in RDoc format.
+
+  def rdoc_link_url_escape(text)
+    text.gsub(/[\[\]\\]/) {|s| "\\#{s}" }
+  end
+
   ##
   # :category: Extensions
   #
@@ -9731,7 +9745,7 @@ class RDoc::Markdown
     return _tmp
   end
 
-  # Str = @StartList:a < @NormalChar+ > { a = text } (StrChunk:c { a << c })* { a }
+  # Str = @StartList:a < @NormalChar+ > { a = text } (StrChunk:c { a << c })* { rdoc_escape(a) }
   def _Str
 
     _save = self.pos
@@ -9792,7 +9806,7 @@ class RDoc::Markdown
         self.pos = _save
         break
       end
-      @result = begin;  a ; end
+      @result = begin;  rdoc_escape(a) ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -9894,7 +9908,7 @@ class RDoc::Markdown
     return _tmp
   end
 
-  # EscapedChar = "\\" !@Newline < /[:\\`|*_{}\[\]()#+.!><-]/ > { text }
+  # EscapedChar = "\\" !@Newline < /[:\\`|*_{}\[\]()#+.!><-]/ > { rdoc_escape(text) }
   def _EscapedChar
 
     _save = self.pos
@@ -9921,7 +9935,7 @@ class RDoc::Markdown
         self.pos = _save
         break
       end
-      @result = begin;  text ; end
+      @result = begin;  rdoc_escape(text) ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -10122,7 +10136,7 @@ class RDoc::Markdown
     return _tmp
   end
 
-  # Symbol = < @SpecialChar > { text }
+  # Symbol = < @SpecialChar > { rdoc_escape(text) }
   def _Symbol
 
     _save = self.pos
@@ -10136,7 +10150,7 @@ class RDoc::Markdown
         self.pos = _save
         break
       end
-      @result = begin;  text ; end
+      @result = begin;  rdoc_escape(text) ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -11189,7 +11203,7 @@ class RDoc::Markdown
     return _tmp
   end
 
-  # ExplicitLink = ExplicitLinkWithLabel:a { "{#{a[:label]}}[#{a[:link]}]" }
+  # ExplicitLink = ExplicitLinkWithLabel:a { "{#{a[:label]}}[#{rdoc_link_url_escape(a[:link])}]" }
   def _ExplicitLink
 
     _save = self.pos
@@ -11200,7 +11214,7 @@ class RDoc::Markdown
         self.pos = _save
         break
       end
-      @result = begin;  "{#{a[:label]}}[#{a[:link]}]" ; end
+      @result = begin;  "{#{a[:label]}}[#{rdoc_link_url_escape(a[:link])}]" ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -14615,7 +14629,7 @@ class RDoc::Markdown
     return _tmp
   end
 
-  # HexEntity = /&#x/i < /[0-9a-fA-F]+/ > ";" { [text.to_i(16)].pack 'U' }
+  # HexEntity = /&#x/i < /[0-9a-fA-F]+/ > ";" { rdoc_escape([text.to_i(16)].pack('U')) }
   def _HexEntity
 
     _save = self.pos
@@ -14639,7 +14653,7 @@ class RDoc::Markdown
         self.pos = _save
         break
       end
-      @result = begin;  [text.to_i(16)].pack 'U' ; end
+      @result = begin;  rdoc_escape([text.to_i(16)].pack('U')) ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -14651,7 +14665,7 @@ class RDoc::Markdown
     return _tmp
   end
 
-  # DecEntity = "&#" < /[0-9]+/ > ";" { [text.to_i].pack 'U' }
+  # DecEntity = "&#" < /[0-9]+/ > ";" { rdoc_escape([text.to_i].pack('U')) }
   def _DecEntity
 
     _save = self.pos
@@ -14675,7 +14689,7 @@ class RDoc::Markdown
         self.pos = _save
         break
       end
-      @result = begin;  [text.to_i].pack 'U' ; end
+      @result = begin;  rdoc_escape([text.to_i].pack('U')) ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -14687,7 +14701,7 @@ class RDoc::Markdown
     return _tmp
   end
 
-  # CharEntity = "&" < /[A-Za-z0-9]+/ > ";" { if entity = HTML_ENTITIES[text] then                  entity.pack 'U*'                else                  "&#{text};"                end              }
+  # CharEntity = "&" < /[A-Za-z0-9]+/ > ";" { if entity = HTML_ENTITIES[text] then                  rdoc_escape(entity.pack('U*'))                else                  "&#{text};"                end              }
   def _CharEntity
 
     _save = self.pos
@@ -14712,7 +14726,7 @@ class RDoc::Markdown
         break
       end
       @result = begin;  if entity = HTML_ENTITIES[text] then
-                 entity.pack 'U*'
+                 rdoc_escape(entity.pack('U*'))
                else
                  "&#{text};"
                end
@@ -16563,15 +16577,15 @@ class RDoc::Markdown
   Rules[:_Inlines] = rule_info("Inlines", "(!@Endline Inline:i { i } | @Endline:c !(&{ github? } Ticks3 /[^`\\n]*$/) &Inline { c })+:chunks @Endline? { chunks }")
   Rules[:_Inline] = rule_info("Inline", "(Str | @Endline | UlOrStarLine | @Space | Strong | Emph | Strike | Image | Link | NoteReference | InlineNote | Code | RawHtml | Entity | EscapedChar | Symbol)")
   Rules[:_Space] = rule_info("Space", "@Spacechar+ { \" \" }")
-  Rules[:_Str] = rule_info("Str", "@StartList:a < @NormalChar+ > { a = text } (StrChunk:c { a << c })* { a }")
+  Rules[:_Str] = rule_info("Str", "@StartList:a < @NormalChar+ > { a = text } (StrChunk:c { a << c })* { rdoc_escape(a) }")
   Rules[:_StrChunk] = rule_info("StrChunk", "< (@NormalChar | /_+/ &Alphanumeric)+ > { text }")
-  Rules[:_EscapedChar] = rule_info("EscapedChar", "\"\\\\\" !@Newline < /[:\\\\`|*_{}\\[\\]()\#+.!><-]/ > { text }")
+  Rules[:_EscapedChar] = rule_info("EscapedChar", "\"\\\\\" !@Newline < /[:\\\\`|*_{}\\[\\]()\#+.!><-]/ > { rdoc_escape(text) }")
   Rules[:_Entity] = rule_info("Entity", "(HexEntity | DecEntity | CharEntity):a { a }")
   Rules[:_Endline] = rule_info("Endline", "(@LineBreak | @TerminalEndline | @NormalEndline)")
   Rules[:_NormalEndline] = rule_info("NormalEndline", "@Sp @Newline !@BlankLine !\">\" !AtxStart !(Line /={1,}|-{1,}/ @Newline) { \"\\n\" }")
   Rules[:_TerminalEndline] = rule_info("TerminalEndline", "@Sp @Newline @Eof")
   Rules[:_LineBreak] = rule_info("LineBreak", "\"  \" @NormalEndline { RDoc::Markup::HardBreak.new }")
-  Rules[:_Symbol] = rule_info("Symbol", "< @SpecialChar > { text }")
+  Rules[:_Symbol] = rule_info("Symbol", "< @SpecialChar > { rdoc_escape(text) }")
   Rules[:_UlOrStarLine] = rule_info("UlOrStarLine", "(UlLine | StarLine):a { a }")
   Rules[:_StarLine] = rule_info("StarLine", "(< /\\*{4,}/ > { text } | < @Spacechar /\\*+/ &@Spacechar > { text })")
   Rules[:_UlLine] = rule_info("UlLine", "(< /_{4,}/ > { text } | < @Spacechar /_+/ &@Spacechar > { text })")
@@ -16588,7 +16602,7 @@ class RDoc::Markdown
   Rules[:_ReferenceLink] = rule_info("ReferenceLink", "(ReferenceLinkDouble | ReferenceLinkSingle)")
   Rules[:_ReferenceLinkDouble] = rule_info("ReferenceLinkDouble", "Label:content < Spnl > !\"[]\" Label:label { link_to content, label, text }")
   Rules[:_ReferenceLinkSingle] = rule_info("ReferenceLinkSingle", "Label:content < (Spnl \"[]\")? > { link_to content, content, text }")
-  Rules[:_ExplicitLink] = rule_info("ExplicitLink", "ExplicitLinkWithLabel:a { \"{\#{a[:label]}}[\#{a[:link]}]\" }")
+  Rules[:_ExplicitLink] = rule_info("ExplicitLink", "ExplicitLinkWithLabel:a { \"{\#{a[:label]}}[\#{rdoc_link_url_escape(a[:link])}]\" }")
   Rules[:_ExplicitLinkWithLabel] = rule_info("ExplicitLinkWithLabel", "Label:label \"(\" @Sp Source:link Spnl Title @Sp \")\" { { label: label, link: link } }")
   Rules[:_Source] = rule_info("Source", "(\"<\" < SourceContents > \">\" | < SourceContents >) { text }")
   Rules[:_SourceContents] = rule_info("SourceContents", "((!\"(\" !\")\" !\">\" Nonspacechar)+ | \"(\" SourceContents \")\")*")
@@ -16631,9 +16645,9 @@ class RDoc::Markdown
   Rules[:_BOM] = rule_info("BOM", "%literals.BOM")
   Rules[:_Newline] = rule_info("Newline", "%literals.Newline")
   Rules[:_Spacechar] = rule_info("Spacechar", "%literals.Spacechar")
-  Rules[:_HexEntity] = rule_info("HexEntity", "/&\#x/i < /[0-9a-fA-F]+/ > \";\" { [text.to_i(16)].pack 'U' }")
-  Rules[:_DecEntity] = rule_info("DecEntity", "\"&\#\" < /[0-9]+/ > \";\" { [text.to_i].pack 'U' }")
-  Rules[:_CharEntity] = rule_info("CharEntity", "\"&\" < /[A-Za-z0-9]+/ > \";\" { if entity = HTML_ENTITIES[text] then                  entity.pack 'U*'                else                  \"&\#{text};\"                end              }")
+  Rules[:_HexEntity] = rule_info("HexEntity", "/&\#x/i < /[0-9a-fA-F]+/ > \";\" { rdoc_escape([text.to_i(16)].pack('U')) }")
+  Rules[:_DecEntity] = rule_info("DecEntity", "\"&\#\" < /[0-9]+/ > \";\" { rdoc_escape([text.to_i].pack('U')) }")
+  Rules[:_CharEntity] = rule_info("CharEntity", "\"&\" < /[A-Za-z0-9]+/ > \";\" { if entity = HTML_ENTITIES[text] then                  rdoc_escape(entity.pack('U*'))                else                  \"&\#{text};\"                end              }")
   Rules[:_NonindentSpace] = rule_info("NonindentSpace", "/ {0,3}/")
   Rules[:_Indent] = rule_info("Indent", "/\\t|    /")
   Rules[:_IndentedLine] = rule_info("IndentedLine", "Indent Line")

data/lib/rdoc/markup/formatter.rb

@@ -10,6 +10,8 @@
 # RDoc::Markup::FormatterTestCase.  If you're writing a text-output formatter
 # use RDoc::Markup::TextFormatterTestCase which provides extra test cases.
 
+require 'rdoc/markup/inline_parser'
+
 class RDoc::Markup::Formatter
 
   ##
@@ -18,6 +20,7 @@ class RDoc::Markup::Formatter
 
   InlineTag = Struct.new(:bit, :on, :off)
 
+
   ##
   # Converts a target url to one that is relative to a given path
 
@@ -49,17 +52,7 @@ class RDoc::Markup::Formatter
     @options = options
 
     @markup = markup || RDoc::Markup.new
-    @am     = @markup.attribute_manager
-    @am.add_regexp_handling(/<br>/, :HARD_BREAK)
-
-    @attributes = @am.attributes
-
-    @attr_tags = []
-
-    @in_tt = 0
-    @tt_bit = @attributes.bitmap_for :TT
 
-    @hard_break = ''
     @from_path = '.'
   end
 
@@ -84,29 +77,6 @@ class RDoc::Markup::Formatter
     @markup.add_regexp_handling(/rdoc-[a-z]+:[^\s\]]+/, :RDOCLINK)
   end
 
-  ##
-  # Adds a regexp handling for links of the form {<text>}[<url>] and
-  # <word>[<url>]
-
-  def add_regexp_handling_TIDYLINK
-    @markup.add_regexp_handling(/(?:
-                                  \{[^{}]*\} | # multi-word label
-                                  \b[^\s{}]+? # single-word label
-                                 )
-
-                                 \[\S+?\]     # link target
-                                /x, :TIDYLINK)
-  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 = @attributes.bitmap_for name
-    @attr_tags << InlineTag.new(attr, start, stop)
-  end
-
   ##
   # Allows +tag+ to be decorated with additional information.
 
@@ -121,117 +91,170 @@ 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::RegexpHandling then
-        res << convert_regexp_handling(item)
+  # Applies regexp handling to +text+ and returns an array of [text, converted?] pairs.
+
+  def apply_regexp_handling(text)
+    output = []
+    start = 0
+    loop do
+      pos = text.size
+      matched_name = matched_text = nil
+      @markup.regexp_handlings.each do |pattern, name|
+        m = text.match(pattern, start)
+        next unless m
+        idx = m[1] ? 1 : 0
+        if m.begin(idx) < pos
+          pos = m.begin(idx)
+          matched_text = m[idx]
+          matched_name = name
+        end
+      end
+      output << [text[start...pos], false] if pos > start
+      if matched_name
+        handled = public_send(:"handle_regexp_#{matched_name}", matched_text)
+        output << [handled, true]
+        start = pos + matched_text.size
       else
-        raise "Unknown flow element: #{item.inspect}"
+        start = pos
       end
+      break if pos == text.size
     end
-
-    res.join
+    output
   end
 
-  ##
-  # Converts added regexp handlings. See RDoc::Markup#add_regexp_handling
+  # Called when processing plain text while traversing inline nodes from handle_inline.
+  # +text+ may need proper escaping.
 
-  def convert_regexp_handling(target)
-    return target.text if in_tt?
+  def handle_PLAIN_TEXT(text)
+  end
 
-    handled = false
+  # Called when processing regexp-handling-processed text while traversing inline nodes from handle_inline.
+  # +text+ may contain markup tags.
 
-    @attributes.each_name_of target.type do |name|
-      method_name = "handle_regexp_#{name}"
+  def handle_REGEXP_HANDLING_TEXT(text)
+  end
+
+  # Called when processing text node while traversing inline nodes from handle_inline.
+  # Apply regexp handling and dispatch to the appropriate handler: handle_REGEXP_HANDLING_TEXT or handle_PLAIN_TEXT.
 
-      if respond_to? method_name then
-        target.text = public_send method_name, target
-        handled = true
+  def handle_TEXT(text)
+    apply_regexp_handling(text).each do |part, converted|
+      if converted
+        handle_REGEXP_HANDLING_TEXT(part)
+      else
+        handle_PLAIN_TEXT(part)
       end
     end
+  end
 
-    unless handled then
-      target_name = @attributes.as_string target.type
+  # Called when processing a hard break while traversing inline nodes from handle_inline.
 
-      raise RDoc::Error, "Unhandled regexp handling #{target_name}: #{target}"
-    end
+  def handle_HARD_BREAK
+  end
 
-    target.text
+  # Called when processing bold nodes while traversing inline nodes from handle_inline.
+  # Traverse the children nodes and dispatch to the appropriate handlers.
+
+  def handle_BOLD(nodes)
+    traverse_inline_nodes(nodes)
   end
 
-  ##
-  # Converts a string to be fancier if desired
+  # Called when processing emphasis nodes while traversing inline nodes from handle_inline.
+  # Traverse the children nodes and dispatch to the appropriate handlers.
 
-  def convert_string(string)
-    string
+  def handle_EM(nodes)
+    traverse_inline_nodes(nodes)
   end
 
-  ##
-  # Use ignore in your subclass to ignore the content of a node.
-  #
-  #   ##
-  #   # We don't support raw nodes in ToNoRaw
-  #
-  #   alias accept_raw ignore
+  # Called when processing bold word nodes while traversing inline nodes from handle_inline.
+  # +word+ may need proper escaping.
 
-  def ignore *node
+  def handle_BOLD_WORD(word)
+    handle_PLAIN_TEXT(word)
   end
 
-  ##
-  # Are we currently inside tt tags?
+  # Called when processing emphasis word nodes while traversing inline nodes from handle_inline.
+  # +word+ may need proper escaping.
 
-  def in_tt?
-    @in_tt > 0
+  def handle_EM_WORD(word)
+    handle_PLAIN_TEXT(word)
   end
 
-  def tt_tag?(attr_mask, reverse = false)
-    each_attr_tag(attr_mask, reverse) do |tag|
-      return true if tt? tag
-    end
-    false
+  # Called when processing tt nodes while traversing inline nodes from handle_inline.
+  # +code+ may need proper escaping.
+
+  def handle_TT(code)
+    handle_PLAIN_TEXT(code)
   end
 
-  ##
-  # Turns on tags for +item+ on +res+
+  # Called when processing strike nodes while traversing inline nodes from handle_inline.
+  # Traverse the children nodes and dispatch to the appropriate handlers.
 
-  def on_tags(res, item)
-    each_attr_tag(item.turn_on) do |tag|
-      res << annotate(tag.on)
-      @in_tt += 1 if tt? tag
-    end
+  def handle_STRIKE(nodes)
+    traverse_inline_nodes(nodes)
   end
 
-  ##
-  # Turns off tags for +item+ on +res+
+  # Called when processing tidylink nodes while traversing inline nodes from handle_inline.
+  # +label_part+ is an array of strings or nodes representing the link label.
+  # +url+ is the link URL.
+  # Traverse the label_part nodes and dispatch to the appropriate handlers.
 
-  def off_tags(res, item)
-    each_attr_tag(item.turn_off, true) do |tag|
-      @in_tt -= 1 if tt? tag
-      res << annotate(tag.off)
-    end
+  def handle_TIDYLINK(label_part, url)
+    traverse_inline_nodes(label_part)
   end
 
-  def each_attr_tag(attr_mask, reverse = false)
-    return if attr_mask.zero?
+  # Parses inline +text+, traverse the resulting nodes, and calls the appropriate handler methods.
+
+  def handle_inline(text)
+    nodes = RDoc::Markup::InlineParser.new(text).parse
+    traverse_inline_nodes(nodes)
+  end
 
-    @attr_tags.public_send(reverse ? :reverse_each : :each) do |tag|
-      if attr_mask & tag.bit != 0 then
-        yield tag
+  # Traverses +nodes+ and calls the appropriate handler methods
+  # Nodes formats are described in RDoc::Markup::InlineParser#parse
+
+  def traverse_inline_nodes(nodes)
+    nodes.each do |node|
+      next handle_TEXT(node) if String === node
+      case node[:type]
+      when :TIDYLINK
+        handle_TIDYLINK(node[:children], node[:url])
+      when :HARD_BREAK
+        handle_HARD_BREAK
+      when :BOLD
+        handle_BOLD(node[:children])
+      when :BOLD_WORD
+        handle_BOLD_WORD(node[:children][0] || '')
+      when :EM
+        handle_EM(node[:children])
+      when :EM_WORD
+        handle_EM_WORD(node[:children][0] || '')
+      when :TT
+        handle_TT(node[:children][0] || '')
+      when :STRIKE
+        handle_STRIKE(node[:children])
       end
     end
   end
 
+  ##
+  # Converts a string to be fancier if desired
+
+  def convert_string(string)
+    string
+  end
+
+  ##
+  # Use ignore in your subclass to ignore the content of a node.
+  #
+  #   ##
+  #   # We don't support raw nodes in ToNoRaw
+  #
+  #   alias accept_raw ignore
+
+  def ignore *node
+  end
+
   ##
   # Extracts and a scheme, url and an anchor id from +url+ and returns them.
 

data/lib/rdoc/markup/heading.rb

@@ -57,8 +57,8 @@ module RDoc
 
           to_html = Markup::ToHtml.new nil
 
-          def to_html.handle_regexp_CROSSREF(target)
-            target.text.sub(/^\\/, '')
+          def to_html.handle_regexp_CROSSREF(text)
+            text.sub(/^\\/, '')
           end
 
           to_html