rdoc 7.2.0 → 8.0.0

data/lib/rdoc/markup/document.rb

@@ -26,7 +26,7 @@ class RDoc::Markup::Document
   ##
   # Creates a new Document with +parts+
 
-  def initialize *parts
+  def initialize(*parts)
     @parts = []
     @parts.concat parts
 
@@ -148,7 +148,7 @@ class RDoc::Markup::Document
   ##
   # Appends +parts+ to the document
 
-  def push *parts
+  def push(*parts)
     self.parts.concat parts
   end
 

data/lib/rdoc/markup/formatter.rb

@@ -14,13 +14,6 @@ require 'rdoc/markup/inline_parser'
 
 class RDoc::Markup::Formatter
 
-  ##
-  # Tag for inline markup containing a +bit+ for the bitmask and the +on+ and
-  # +off+ triggers.
-
-  InlineTag = Struct.new(:bit, :on, :off)
-
-
   ##
   # Converts a target url to one that is relative to a given path
 
@@ -48,10 +41,8 @@ class RDoc::Markup::Formatter
   ##
   # Creates a new Formatter
 
-  def initialize(options, markup = nil)
-    @options = options
-
-    @markup = markup || RDoc::Markup.new
+  def initialize
+    @markup = RDoc::Markup.new
 
     @from_path = '.'
   end
@@ -94,31 +85,30 @@ class RDoc::Markup::Formatter
   # 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
+    matched = []
+    @markup.regexp_handlings.each_with_index do |(pattern, name), priority|
+      text.scan(pattern) do
+        m = Regexp.last_match
         idx = m[1] ? 1 : 0
-        if m.begin(idx) < pos
-          pos = m.begin(idx)
-          matched_text = m[idx]
-          matched_name = name
-        end
+        matched << [m.begin(idx), m.end(idx), m[idx], name, priority]
       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
-        start = pos
-      end
-      break if pos == text.size
     end
+    # If the start positions are the same, prefer the earlier-registered one
+    # (lower numeric priority from each_with_index).
+    matched.sort_by! {|beg_pos, _, _, _, priority| [beg_pos, priority] }
+
+    pos = 0
+    output = []
+    matched.each do |beg_pos, end_pos, s, name|
+      next if beg_pos < pos
+
+      output << [text[pos...beg_pos], false] if beg_pos != pos
+      handled = public_send(:"handle_regexp_#{name}", s)
+      output << [handled, true]
+      pos = end_pos
+    end
+
+    output << [text[pos..], false] if pos < text.size
     output
   end
 
@@ -252,7 +242,7 @@ class RDoc::Markup::Formatter
   #
   #   alias accept_raw ignore
 
-  def ignore *node
+  def ignore(*node)
   end
 
   ##

data/lib/rdoc/markup/heading.rb

@@ -52,10 +52,7 @@ module RDoc
       #: () -> RDoc::Markup::ToHtml
       def self.to_html
         @to_html ||= begin
-          markup = Markup.new
-          markup.add_regexp_handling CrossReference::CROSSREF_REGEXP, :CROSSREF
-
-          to_html = Markup::ToHtml.new nil
+          to_html = Markup::ToHtml.new
 
           def to_html.handle_regexp_CROSSREF(text)
             text.sub(/^\\/, '')

data/lib/rdoc/markup/indented_paragraph.rb

@@ -13,7 +13,7 @@ class RDoc::Markup::IndentedParagraph < RDoc::Markup::Raw
   # Creates a new IndentedParagraph containing +parts+ indented with +indent+
   # spaces
 
-  def initialize indent, *parts
+  def initialize(indent, *parts)
     @indent = indent
 
     super(*parts)

data/lib/rdoc/markup/list.rb

@@ -37,7 +37,7 @@ class RDoc::Markup::List
   # Creates a new list of +type+ with +items+.  Valid list types are:
   # +:BULLET+, +:LABEL+, +:LALPHA+, +:NOTE+, +:NUMBER+, +:UALPHA+
 
-  def initialize type = nil, *items
+  def initialize(type = nil, *items)
     @type = type
     @items = []
     @items.concat items
@@ -94,7 +94,7 @@ class RDoc::Markup::List
   ##
   # Appends +items+ to the list
 
-  def push *items
+  def push(*items)
     @items.concat items
   end
 

data/lib/rdoc/markup/list_item.rb

@@ -24,7 +24,7 @@ class RDoc::Markup::ListItem
   ##
   # Creates a new ListItem with an optional +label+ containing +parts+
 
-  def initialize label = nil, *parts
+  def initialize(label = nil, *parts)
     @label = label
     @parts = []
     @parts.concat parts
@@ -92,7 +92,7 @@ class RDoc::Markup::ListItem
   ##
   # Adds +parts+ to the ListItem
 
-  def push *parts
+  def push(*parts)
     @parts.concat parts
   end
 

data/lib/rdoc/markup/pre_process.rb

@@ -209,18 +209,6 @@ class RDoc::Markup::PreProcess
     when 'include' then
       filename = param.split(' ', 2).first
       include_file filename, prefix, encoding
-    when 'main' then
-      @options.main_page = param if @options.respond_to? :main_page
-      warn <<~MSG
-        The :main: directive is deprecated and will be removed in RDoc 7.
-
-        You can use these options to specify the initial page displayed instead:
-        - `--main=#{param}` via the command line
-        - `rdoc.main = "#{param}"` if you use `RDoc::Task`
-        - `main_page: #{param}` in your `.rdoc_options` file
-      MSG
-
-      blankline
     when 'nodoc' then
       return blankline unless code_object
       code_object.document_self = nil # notify nodoc
@@ -245,19 +233,6 @@ class RDoc::Markup::PreProcess
 
       code_object.stop_doc
 
-      blankline
-    when 'title' then
-      @options.default_title = param if @options.respond_to? :default_title=
-
-      warn <<~MSG
-        The :title: directive is deprecated and will be removed in RDoc 7.
-
-        You can use these options to specify the title displayed instead:
-        - `--title=#{param}` via the command line
-        - `rdoc.title = "#{param}"` if you use `RDoc::Task`
-        - `title: #{param}` in your `.rdoc_options` file
-      MSG
-
       blankline
     when 'yield', 'yields' then
       return blankline unless code_object

data/lib/rdoc/markup/to_ansi.rb

@@ -7,7 +7,7 @@ class RDoc::Markup::ToAnsi < RDoc::Markup::ToRdoc
   ##
   # Creates a new ToAnsi visitor that is ready to output vibrant ANSI color!
 
-  def initialize(markup = nil)
+  def initialize
     super
 
     @headings.clear

data/lib/rdoc/markup/to_bs.rb

@@ -10,7 +10,7 @@ class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
   ##
   # Returns a new ToBs that is ready for hot backspace action!
 
-  def initialize(markup = nil)
+  def initialize
     super
 
     @in_b  = false

data/lib/rdoc/markup/to_html.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'cgi/escape'
 require 'cgi/util' unless defined?(CGI::EscapeExt)
+require 'prism'
 
 ##
 # Outputs RDoc markup as HTML.
@@ -40,17 +41,100 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
 
   # :section:
 
+  # Maps an encoding to a Hash of characters properly transcoded for that
+  # encoding.
+  #
+  # See also encode_fallback.
+
+  TO_HTML_CHARACTERS = Hash.new do |h, encoding|
+    h[encoding] = {
+      close_dquote: encode_fallback('”', encoding, '"'),
+      close_squote: encode_fallback('’', encoding, '\''),
+      copyright:    encode_fallback('©', encoding, '(c)'),
+      ellipsis:     encode_fallback('…', encoding, '...'),
+      dot_ellipsis: encode_fallback('.…', encoding, '....'),
+      em_dash:      encode_fallback('—', encoding, '---'),
+      en_dash:      encode_fallback('–', encoding, '--'),
+      open_dquote:  encode_fallback('“', encoding, '"'),
+      open_squote:  encode_fallback('‘', encoding, '\''),
+      trademark:    encode_fallback('®', encoding, '(r)'),
+    }
+  end
+
+  HTML_CHARACTER_ALIASES = {
+    '(c)' => :copyright,
+    '(C)' => :copyright,
+    '(r)' => :trademark,
+    '(R)' => :trademark,
+    '---' => :em_dash,
+    '--'  => :en_dash,
+    '....' => :dot_ellipsis,
+    '...' => :ellipsis,
+    '``' => :open_dquote,
+    "''" => :close_dquote,
+  }
+
+  # Transcodes +character+ to +encoding+ with a +fallback+ character.
+
+  def self.encode_fallback(character, encoding, fallback)
+    character.encode(
+      encoding,
+      fallback: { character => fallback },
+      undef: :replace,
+      replace: fallback
+    )
+  end
+
+  # Converts ascii quote pairs to multibyte quote characters
+  class QuoteConverter
+
+    def initialize
+      @in_dquote = false
+      @in_squote = false
+    end
+
+    def convert(quote, after_word:)
+      case quote
+      when '"'
+        type = @in_dquote ? :close_dquote : :open_dquote
+        @in_dquote = !@in_dquote
+      when "'"
+        if @in_squote
+          type = :close_squote
+          @in_squote = false
+        elsif after_word
+          # Mary's dog, my parents' house: do not start paired quotes
+          type = :close_squote
+        else
+          type = :open_squote
+          @in_squote = true
+        end
+      when '`'
+        # Opening quote of <tt>`quoted sentence'</tt>.
+        # This will conflict with code blocks <tt>`puts('hello')`</tt> in the future.
+        if !@in_squote && !after_word
+          type = :open_squote
+          @in_squote = true
+        end
+      end
+      TO_HTML_CHARACTERS[quote.encoding][type] if type
+    end
+  end
+
   ##
   # Creates a new formatter that will output HTML
 
-  def initialize(options, markup = nil)
-    super
+  def initialize(pipe: false, output_decoration: true)
+    super()
 
+    @pipe = pipe
+    @output_decoration = output_decoration
     @code_object = nil
     @from_path = ''
     @in_list_entry = nil
     @list = nil
     @th = nil
+    @quote_converter = nil
     @in_tidylink_label = false
     @hard_break = "<br>\n"
 
@@ -75,6 +159,11 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     # suppress crossref: \#method \::method \ClassName \method_with_underscores
     @markup.add_regexp_handling(/\\(?:[#:A-Z]|[a-z]+_[a-z0-9])/, :SUPPRESSED_CROSSREF)
 
+    @markup.add_regexp_handling(Regexp.union(HTML_CHARACTER_ALIASES.keys), :HTML_CHARACTERS)
+
+    @markup.add_regexp_handling(/\b['"`]/, :QUOTE_AFTER_WORD)
+    @markup.add_regexp_handling(/\B['"`]/, :QUOTE_NOT_AFTER_WORD)
+
     init_link_notation_regexp_handlings
   end
 
@@ -227,12 +316,28 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
 
   def handle_inline(text) # :nodoc:
     @inline_output = +''
+    @quote_converter = QuoteConverter.new
     super
     out = @inline_output
     @inline_output = nil
+    @quote_converter = nil
     out
   end
 
+  # Converts <tt>(c), (r), --, --- , ..., ...., ``, ''</tt> to HTML characters.
+  def handle_regexp_HTML_CHARACTERS(text)
+    name = HTML_CHARACTER_ALIASES[text]
+    TO_HTML_CHARACTERS[text.encoding][name] if name
+  end
+
+  def handle_regexp_QUOTE_NOT_AFTER_WORD(text)
+    @quote_converter.convert(text, after_word: false) || convert_string(text)
+  end
+
+  def handle_regexp_QUOTE_AFTER_WORD(text)
+    @quote_converter.convert(text, after_word: true) || convert_string(text)
+  end
+
   # Converts suppressed cross-reference +text+ to HTML by removing the leading backslash.
 
   def handle_regexp_SUPPRESSED_CROSSREF(text)
@@ -311,13 +416,22 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
   def accept_paragraph(paragraph)
     @res << "\n<p>"
     text = paragraph.text @hard_break
-    text = text.gsub(/(#{SPACE_SEPARATED_LETTER_CLASS})?\K\r?\n(?=(?(1)(#{SPACE_SEPARATED_LETTER_CLASS})?))/o) {
+    text = text.gsub(/(#{SPACE_SEPARATED_LETTER_CLASS})?\K(?:\r?\n)+(?=(?(1)(#{SPACE_SEPARATED_LETTER_CLASS})?))/o) {
       defined?($2) && ' '
     }
     @res << to_html(text)
     @res << "</p>\n"
   end
 
+  # Generate syntax highlighted html for ruby-like text.
+
+  def parsable_text_to_html(text)
+    tokens = RDoc::Parser::RubyColorizer.colorize(text)
+    result = RDoc::TokenStream.to_html tokens
+    result = result + "\n" unless result.end_with?("\n")
+    result
+  end
+
   ##
   # Adds +verbatim+ to the output
 
@@ -325,29 +439,19 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
     text = verbatim.text.rstrip
     format = verbatim.format
 
-    klass = nil
-
     # Apply Ruby syntax highlighting if
     # - explicitly marked as Ruby (via ruby? which accepts :ruby or :rb)
     # - no format specified but the text is parseable as Ruby
     # Otherwise, add language class when applicable and skip Ruby highlighting
-    content = if verbatim.ruby? || (format.nil? && parseable?(text))
-                begin
-                  tokens = RDoc::Parser::RipperStateLex.parse text
-                  klass  = ' class="ruby"'
-
-                  result = RDoc::TokenStream.to_html tokens
-                  result = result + "\n" unless "\n" == result[-1]
-                  result
-                rescue
-                  CGI.escapeHTML text
-                end
-              else
-                klass = " class=\"#{format}\"" if format
-                CGI.escapeHTML text
-              end
-
-    if @options.pipe then
+    if verbatim.ruby? || (format.nil? && parseable?(text))
+      content = parsable_text_to_html(text)
+      klass = ' class="ruby"'
+    else
+      content = CGI.escapeHTML text
+      klass = " class=\"#{format}\"" if format
+    end
+
+    if @pipe
       @res << "\n<pre><code>#{CGI.escapeHTML text}\n</code></pre>\n"
     else
       @res << "\n<pre#{klass}>#{content}</pre>\n"
@@ -418,17 +522,17 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
 
     # Add legacy anchor before the heading for backward compatibility.
     # This allows old links with label- prefix to still work.
-    if @options.output_decoration && !@options.pipe
+    if @output_decoration && !@pipe
       @res << "\n<span id=\"#{legacy_label}\" class=\"legacy-anchor\"></span>"
     end
 
-    @res << if @options.output_decoration
+    @res << if @output_decoration
               "\n<h#{level} id=\"#{label}\">"
             else
               "\n<h#{level}>"
             end
 
-    if @options.pipe
+    if @pipe
       @res << to_html(heading.text)
     else
       @res << "<a href=\"##{label}\">#{to_html(heading.text)}</a>"
@@ -566,39 +670,13 @@ class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
   # Returns true if text is valid ruby syntax
 
   def parseable?(text)
-    verbose, $VERBOSE = $VERBOSE, nil
-    catch(:valid) do
-      eval("BEGIN { throw :valid, true }\n#{text}")
-    end
-  rescue SyntaxError
-    false
-  ensure
-    $VERBOSE = verbose
+    Prism.parse_success?(text)
   end
 
   ##
   # Converts +item+ to HTML using RDoc::Text#to_html
 
   def to_html(item)
-    # Ideally, we should convert html characters at handle_PLAIN_TEXT or somewhere else,
-    # but we need to convert it here for now because to_html_characters converts pair of backticks to ’‘ and pair of double backticks to ”“.
-    # Known bugs: `...` in `<code>def f(...); end</code>` and `(c) in `<a href="(c)">` will be wrongly converted.
-    to_html_characters(handle_inline(item))
-  end
-end
-
-##
-# Formatter dedicated to rendering tidy link labels without mutating the
-# calling formatter's state.
-
-class RDoc::Markup::LinkLabelToHtml < RDoc::Markup::ToHtml
-  def self.render(label, options, from_path)
-    new(options, from_path).to_html(label)
-  end
-
-  def initialize(options, from_path = nil)
-    super(options)
-
-    self.from_path = from_path if from_path
+    handle_inline(item)
   end
 end