rdoc 6.17.0 → 7.2.0

data/lib/rdoc/markup/to_html_snippet.rb

@@ -107,8 +107,8 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
   def accept_verbatim(verbatim)
     throw :done if @characters >= @character_limit
     input = verbatim.text.rstrip
-
-    text = truncate input
+    text = truncate(input, @character_limit - @characters)
+    @characters += input.length
     text << ' ...' unless text == input
 
     super RDoc::Markup::Verbatim.new text
@@ -128,16 +128,8 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
   ##
   # Removes escaping from the cross-references in +target+
 
-  def handle_regexp_CROSSREF(target)
-    target.text.sub(/\A\\/, '')
-  end
-
-  ##
-  # +target+ is a <code><br></code>
-
-  def handle_regexp_HARD_BREAK(target)
-    @characters -= 4
-    '<br>'
+  def handle_regexp_CROSSREF(text)
+    text.sub(/\A\\/, '')
   end
 
   ##
@@ -212,74 +204,82 @@ class RDoc::Markup::ToHtmlSnippet < RDoc::Markup::ToHtml
     end_accepting
   end
 
-  ##
-  # Converts flow items +flow+
+  def handle_PLAIN_TEXT(text) # :nodoc:
+    return if inline_limit_reached?
 
-  def convert_flow(flow)
-    throw :done if @characters >= @character_limit
+    truncated = truncate(text, @inline_character_limit)
+    @inline_character_limit -= text.size
+    emit_inline(convert_string(truncated))
+  end
 
-    res = []
-    @mask = 0
-
-    flow.each do |item|
-      case item
-      when RDoc::Markup::AttrChanger then
-        off_tags res, item
-        on_tags  res, item
-      when String then
-        text = convert_string item
-        res << truncate(text)
-      when RDoc::Markup::RegexpHandling then
-        text = convert_regexp_handling item
-        res << truncate(text)
-      else
-        raise "Unknown flow element: #{item.inspect}"
-      end
-
-      if @characters >= @character_limit then
-        off_tags res, RDoc::Markup::AttrChanger.new(0, @mask)
-        break
-      end
-    end
+  def handle_REGEXP_HANDLING_TEXT(text) # :nodoc:
+    return if inline_limit_reached?
 
-    res << ' ...' if @characters >= @character_limit
+    # We can't truncate text including html tags.
+    # Just emit as is, and count all characters including html tag part.
+    emit_inline(text)
+    @inline_character_limit -= text.size
+  end
 
-    res.join
+  def handle_BOLD(nodes)
+    super unless inline_limit_reached?
   end
 
-  ##
-  # Maintains a bitmask to allow HTML elements to be closed properly.  See
-  # RDoc::Markup::Formatter.
+  def handle_BOLD_WORD(word)
+    super unless inline_limit_reached?
+  end
 
-  def on_tags(res, item)
-    @mask ^= item.turn_on
+  def handle_EM(nodes)
+    super unless inline_limit_reached?
+  end
 
-    super
+  def handle_EM_WORD(word)
+    super unless inline_limit_reached?
   end
 
-  ##
-  # Maintains a bitmask to allow HTML elements to be closed properly.  See
-  # RDoc::Markup::Formatter.
+  def handle_TT(code)
+    super unless inline_limit_reached?
+  end
 
-  def off_tags(res, item)
-    @mask ^= item.turn_off
+  def handle_STRIKE(nodes)
+    super unless inline_limit_reached?
+  end
 
-    super
+  def handle_HARD_BREAK
+    super unless inline_limit_reached?
   end
 
-  ##
-  # Truncates +text+ at the end of the first word after the character_limit.
+  def handle_TIDYLINK(label_part, url)
+    traverse_inline_nodes(label_part) unless inline_limit_reached?
+  end
 
-  def truncate(text)
-    length = text.length
-    characters = @characters
-    @characters += length
+  def inline_limit_reached?
+    @inline_character_limit <= 0
+  end
 
-    return text if @characters < @character_limit
+  def handle_inline(text)
+    limit = @character_limit - @characters
+    return ['', 0] if limit <= 0
+    @inline_character_limit = limit
+    res = super
+    res << ' ...' if @inline_character_limit <= 0
+    @characters += limit - @inline_character_limit
+    res
+  end
+
+  def to_html(item)
+    throw :done if @characters >= @character_limit
+    to_html_characters(handle_inline(item))
+  end
+
+  ##
+  # Truncates +text+ at the end of the first word after the limit.
 
-    remaining = @character_limit - characters
+  def truncate(text, limit)
+    return text if limit >= text.size
+    return '' if limit <= 0
 
-    text =~ /\A(.{#{remaining},}?)(\s|$)/m # TODO word-break instead of \s?
+    text =~ /\A(.{#{limit},}?)(\s|$)/m # TODO word-break instead of \s?
 
     $1
   end

data/lib/rdoc/markup/to_label.rb

@@ -18,43 +18,53 @@ class RDoc::Markup::ToLabel < RDoc::Markup::Formatter
     super nil, markup
 
     @markup.add_regexp_handling RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
-    @markup.add_regexp_handling(/(((\{.*?\})|\b\S+?)\[\S+?\])/, :TIDYLINK)
 
-    add_tag :BOLD, '', ''
-    add_tag :TT,   '', ''
-    add_tag :EM,   '', ''
+    @res = []
+  end
 
+  def handle_PLAIN_TEXT(text)
+    @res << text
+  end
+
+  def handle_REGEXP_HANDLING_TEXT(text)
+    @res << text
+  end
+
+  def handle_TT(text)
+    @res << text
+  end
+
+  def extract_plaintext(text)
     @res = []
+    handle_inline(text)
+    @res.join
   end
 
   ##
-  # Converts +text+ to an HTML-safe label
+  # Converts +text+ to an HTML-safe label using GitHub-style anchor formatting.
 
   def convert(text)
-    label = convert_flow @am.flow text
+    label = extract_plaintext(text)
 
-    CGI.escape(label).gsub('%', '-').sub(/^-/, '')
+    RDoc::Text.to_anchor(label)
   end
 
   ##
-  # Converts the CROSSREF +target+ to plain text, removing the suppression
-  # marker, if any
+  # Converts +text+ to an HTML-safe label using legacy RDoc formatting.
+  # Used for generating backward-compatible anchor aliases.
 
-  def handle_regexp_CROSSREF(target)
-    text = target.text
+  def convert_legacy(text)
+    label = extract_plaintext(text)
 
-    text.sub(/^\\/, '')
+    CGI.escape(label).gsub('%', '-').sub(/^-/, '')
   end
 
   ##
-  # Converts the TIDYLINK +target+ to just the text part
-
-  def handle_regexp_TIDYLINK(target)
-    text = target.text
-
-    return text unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/
+  # Converts the CROSSREF +target+ to plain text, removing the suppression
+  # marker, if any
 
-    $1
+  def handle_regexp_CROSSREF(text)
+    text.sub(/^\\/, '')
   end
 
   alias accept_blank_line         ignore
@@ -69,7 +79,6 @@ class RDoc::Markup::ToLabel < RDoc::Markup::Formatter
   alias accept_rule               ignore
   alias accept_verbatim           ignore
   alias end_accepting             ignore
-  alias handle_regexp_HARD_BREAK  ignore
   alias start_accepting           ignore
 
 end

data/lib/rdoc/markup/to_markdown.rb

@@ -20,27 +20,10 @@ class RDoc::Markup::ToMarkdown < RDoc::Markup::ToRdoc
     @headings[6] = ['###### ', '']
 
     add_regexp_handling_RDOCLINK
-    add_regexp_handling_TIDYLINK
 
     @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_regexp_HARD_BREAK(target)
-    "  \n"
-  end
-
   ##
   # Finishes consumption of `list`
 
@@ -94,6 +77,65 @@ class RDoc::Markup::ToMarkdown < RDoc::Markup::ToRdoc
     end
   end
 
+  def add_tag(tag, simple_tag, content)
+    if content.match?(/\A[\w\s]+\z/)
+      emit_inline("#{simple_tag}#{content}#{simple_tag}")
+    else
+      emit_inline("<#{tag}>#{content}</#{tag}>")
+    end
+  end
+
+  def handle_tag(nodes, simple_tag, tag)
+    if nodes.size == 1 && String === nodes[0]
+      content = apply_regexp_handling(nodes[0]).map do |text, converted|
+        converted ? text : convert_string(text)
+      end.join
+      add_tag(tag, simple_tag, content)
+    else
+      emit_inline("<#{tag}>")
+      traverse_inline_nodes(nodes)
+      emit_inline("</#{tag}>")
+    end
+  end
+
+  def handle_TIDYLINK(label_part, url)
+    if url =~ /^rdoc-label:foot/ then
+      emit_inline(handle_rdoc_link(url))
+    else
+      emit_inline('[')
+      traverse_inline_nodes(label_part)
+      emit_inline("](#{url})")
+    end
+  end
+
+  def handle_BOLD(nodes)
+    handle_tag(nodes, '**', 'strong')
+  end
+
+  def handle_EM(nodes)
+    handle_tag(nodes, '*', 'em')
+  end
+
+  def handle_BOLD_WORD(word)
+    add_tag('strong', '**', convert_string(word))
+  end
+
+  def handle_EM_WORD(word)
+    add_tag('em', '*', convert_string(word))
+  end
+
+  def handle_TT(text)
+    add_tag('code', '`', convert_string(text))
+  end
+
+  def handle_STRIKE(nodes)
+    handle_tag(nodes, '~~', 's')
+  end
+
+  def handle_HARD_BREAK
+    emit_inline("  \n")
+  end
+
   ##
   # Prepares the visitor for consuming `list`
 
@@ -163,29 +205,11 @@ class RDoc::Markup::ToMarkdown < RDoc::Markup::ToRdoc
     end
   end
 
-  ##
-  # Converts the RDoc markup tidylink into a Markdown.style link.
-
-  def handle_regexp_TIDYLINK(target)
-    text = target.text
-
-    return text unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/
-
-    label = $1
-    url   = $2
-
-    if url =~ /^rdoc-label:foot/ then
-      handle_rdoc_link url
-    else
-      gen_url url, label
-    end
-  end
-
   ##
   # Converts the rdoc-...: links into a Markdown.style links.
 
-  def handle_regexp_RDOCLINK(target)
-    handle_rdoc_link target.text
+  def handle_regexp_RDOCLINK(text)
+    handle_rdoc_link text
   end
 
 end

data/lib/rdoc/markup/to_rdoc.rb

@@ -57,21 +57,11 @@ class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
 
     @markup.add_regexp_handling(/\\\S/, :SUPPRESSED_CROSSREF)
     @width = 78
-    init_tags
 
     @headings = DEFAULT_HEADINGS.dup
     @hard_break = "\n"
   end
 
-  ##
-  # Maps attributes to HTML sequences
-
-  def init_tags
-    add_tag :BOLD, "<b>", "</b>"
-    add_tag :TT,   "<tt>", "</tt>"
-    add_tag :EM,   "<em>", "</em>"
-  end
-
   ##
   # Adds +blank_line+ to the output
 
@@ -253,7 +243,7 @@ class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
     header = header.map { |h| attributes h }
     body = body.map { |row| row.map { |t| attributes t } }
     widths = header.zip(*body).map do |cols|
-      cols.map { |col| calculate_text_width(col) }.max
+      cols.compact.map { |col| calculate_text_width(col) }.max
     end
     aligns = aligns.map do |a|
       case a
@@ -271,7 +261,8 @@ class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
     end.join("|").rstrip << "\n"
     @res << widths.map {|w| "-" * w }.join("|") << "\n"
     body.each do |row|
-      @res << row.zip(widths, aligns).map do |t, w, a|
+      @res << widths.zip(aligns).each_with_index.map do |(w, a), i|
+        t = row[i] || ""
         extra_width = t.size - calculate_text_width(t)
         t.__send__(a, w + extra_width)
       end.join("|").rstrip << "\n"
@@ -282,12 +273,90 @@ class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
     text.size
   end
 
+  def handle_PLAIN_TEXT(text)
+    add_text(text)
+  end
+
+  def handle_REGEXP_HANDLING_TEXT(text)
+    add_text(text)
+  end
+
+  def handle_BOLD(target)
+    on(:BOLD)
+    super
+    off(:BOLD)
+  end
+
+  def handle_EM(target)
+    on(:EM)
+    super
+    off(:EM)
+  end
+
+  def handle_BOLD_WORD(word)
+    on(:BOLD)
+    super
+    off(:BOLD)
+  end
+
+  def handle_EM_WORD(word)
+    on(:EM)
+    super
+    off(:EM)
+  end
+
+  def handle_TT(code)
+    on(:TT)
+    super
+    off(:TT)
+  end
+
+  def handle_STRIKE(target)
+    on(:STRIKE)
+    super
+    off(:STRIKE)
+  end
+
+  def handle_HARD_BREAK
+    add_text("\n")
+  end
+
+  def handle_TIDYLINK(label_part, url)
+    super
+    add_text("( #{url} )")
+  end
+
+  def handle_inline(text, initial_attributes = [])
+    @attributes = Hash.new(0)
+    initial_attributes.each { |attr| on(attr) }
+    out = @inline_output = +''
+    super(text)
+    @inline_output = nil
+    out
+  end
+
+  def on(attr)
+    @attributes[attr] += 1
+  end
+
+  def off(attr)
+    @attributes[attr] -= 1
+    @attributes.delete(attr) if @attributes[attr] == 0
+  end
+
+  def add_text(text)
+    emit_inline(text)
+  end
+
+  def emit_inline(text)
+    @inline_output << text
+  end
+
   ##
-  # Applies attribute-specific markup to +text+ using RDoc::AttributeManager
+  # Applies attribute-specific markup to +text+ using RDoc::Markup::InlineParser
 
   def attributes(text)
-    flow = @am.flow text.dup
-    convert_flow flow
+    handle_inline(text)
   end
 
   ##
@@ -300,17 +369,8 @@ class RDoc::Markup::ToRdoc < RDoc::Markup::Formatter
   ##
   # Removes preceding \\ from the suppressed crossref +target+
 
-  def handle_regexp_SUPPRESSED_CROSSREF(target)
-    text = target.text
-    text = text.sub('\\', '') unless in_tt?
-    text
-  end
-
-  ##
-  # Adds a newline to the output
-
-  def handle_regexp_HARD_BREAK(target)
-    "\n"
+  def handle_regexp_SUPPRESSED_CROSSREF(text)
+    text.sub('\\', '')
   end
 
   ##

data/lib/rdoc/markup/to_test.rb

@@ -18,8 +18,16 @@ class RDoc::Markup::ToTest < RDoc::Markup::Formatter
     @res
   end
 
+  def handle_PLAIN_TEXT(text)
+    @res << text
+  end
+
+  def handle_REGEXP_HANDLING_TEXT(text)
+    @res << text
+  end
+
   def accept_paragraph(paragraph)
-    @res << convert_flow(@am.flow(paragraph.text))
+    handle_inline(paragraph.text)
   end
 
   def accept_raw(raw)

data/lib/rdoc/markup/to_tt_only.rb

@@ -20,8 +20,6 @@ class RDoc::Markup::ToTtOnly < RDoc::Markup::Formatter
 
   def initialize(markup = nil)
     super nil, markup
-
-    add_tag :TT, nil, nil
   end
 
   ##
@@ -82,22 +80,18 @@ class RDoc::Markup::ToTtOnly < RDoc::Markup::Formatter
   # Extracts tt sections from +text+
 
   def tt_sections(text)
-    flow = @am.flow text.dup
-
-    flow.each do |item|
-      case item
-      when String then
-        @res << item if in_tt?
-      when RDoc::Markup::AttrChanger then
-        off_tags res, item
-        on_tags res, item
-      when RDoc::Markup::RegexpHandling then
-        @res << convert_regexp_handling(item) if in_tt? # TODO can this happen?
+    parsed = RDoc::Markup::InlineParser.new(text).parse
+    traverse = -> node {
+      next if String === node
+      if node[:type] == :TT
+        res << nil
+        res << node[:children][0] || ''
+        res << nil
       else
-        raise "Unknown flow element: #{item.inspect}"
+        node[:children].each(&traverse)
       end
-    end
-
+    }
+    parsed.each(&traverse)
     res
   end
 

data/lib/rdoc/markup/verbatim.rb

@@ -70,7 +70,7 @@ class RDoc::Markup::Verbatim < RDoc::Markup::Raw
 
   def ruby?
     @format ||= nil # TODO for older ri data, switch the tree to marshal_dump
-    @format == :ruby
+    @format == :ruby || @format == :rb
   end
 
   ##

data/lib/rdoc/markup.rb

@@ -16,7 +16,7 @@
 #
 # - +rdoc+:
 #   the +RDoc+ markup format;
-#   see RDoc::MarkupReference.
+#   see {RDoc Markup Reference}[rdoc-ref:doc/markup_reference/rdoc.rdoc]
 # - +markdown+:
 #   The +markdown+ markup format as described in
 #   the {Markdown Guide}[https://www.markdownguide.org];
@@ -79,7 +79,7 @@
 #
 #   class WikiHtml < RDoc::Markup::ToHtml
 #     def handle_regexp_WIKIWORD(target)
-#       "<font color=red>" + target.text + "</font>"
+#       "<font color=red>" + target + "</font>"
 #     end
 #   end
 #
@@ -102,7 +102,7 @@
 #
 # = \RDoc Markup Reference
 #
-# See RDoc::MarkupReference.
+# See {RDoc Markup Reference}[rdoc-ref:doc/markup_reference/rdoc.rdoc]
 #
 #--
 # Original Author:: Dave Thomas,  dave@pragmaticprogrammer.com
@@ -110,10 +110,10 @@
 
 class RDoc::Markup
 
-  ##
-  # An AttributeManager which handles inline markup.
+  # Array of regexp handling pattern and its name. A regexp handling
+  # sequence is something like a WikiWord
 
-  attr_reader :attribute_manager
+  attr_reader :regexp_handlings
 
   ##
   # Parses +str+ into an RDoc::Markup::Document.
@@ -148,27 +148,11 @@ https://github.com/ruby/rdoc/issues
   # structure (paragraphs, lists, and so on).  Invoke an event handler as we
   # identify significant chunks.
 
-  def initialize(attribute_manager = nil)
-    @attribute_manager = attribute_manager || RDoc::Markup::AttributeManager.new
+  def initialize
+    @regexp_handlings = []
     @output = nil
   end
 
-  ##
-  # Add to the sequences used to add formatting to an individual word (such
-  # as *bold*).  Matching entries will generate attributes that the output
-  # formatters can recognize by their +name+.
-
-  def add_word_pair(start, stop, name)
-    @attribute_manager.add_word_pair(start, stop, name)
-  end
-
-  ##
-  # Add to the sequences recognized as general markup.
-
-  def add_html(tag, name)
-    @attribute_manager.add_html(tag, name)
-  end
-
   ##
   # Add to other inline sequences.  For example, we could add WikiWords using
   # something like:
@@ -178,7 +162,7 @@ https://github.com/ruby/rdoc/issues
   # Each wiki word will be presented to the output formatter.
 
   def add_regexp_handling(pattern, name)
-    @attribute_manager.add_regexp_handling(pattern, name)
+    @regexp_handlings << [pattern, name]
   end
 
   ##
@@ -197,19 +181,14 @@ https://github.com/ruby/rdoc/issues
   end
 
   autoload :Parser,                "#{__dir__}/markup/parser"
+  autoload :InlineParser,          "#{__dir__}/markup/inline_parser"
   autoload :PreProcess,            "#{__dir__}/markup/pre_process"
 
-  # Inline markup classes
-  autoload :AttrChanger,           "#{__dir__}/markup/attr_changer"
-  autoload :AttrSpan,              "#{__dir__}/markup/attr_span"
-  autoload :Attributes,            "#{__dir__}/markup/attributes"
-  autoload :AttributeManager,      "#{__dir__}/markup/attribute_manager"
-  autoload :RegexpHandling,        "#{__dir__}/markup/regexp_handling"
-
   # RDoc::Markup AST
   autoload :BlankLine,             "#{__dir__}/markup/blank_line"
   autoload :BlockQuote,            "#{__dir__}/markup/block_quote"
   autoload :Document,              "#{__dir__}/markup/document"
+  autoload :Element,               "#{__dir__}/markup/element"
   autoload :HardBreak,             "#{__dir__}/markup/hard_break"
   autoload :Heading,               "#{__dir__}/markup/heading"
   autoload :Include,               "#{__dir__}/markup/include"