rdoc 6.3.4.1 → 8.0.0

data/lib/rdoc/markup/blank_line.rb

@@ -1,28 +1,29 @@
 # frozen_string_literal: true
-##
-# An empty line.  This class is a singleton.
 
-class RDoc::Markup::BlankLine
-
-  @instance = new
-
-  ##
-  # RDoc::Markup::BlankLine is a singleton
-
-  def self.new
-    @instance
-  end
-
-  ##
-  # Calls #accept_blank_line on +visitor+
-
-  def accept visitor
-    visitor.accept_blank_line self
-  end
-
-  def pretty_print q # :nodoc:
-    q.text 'blankline'
+module RDoc
+  class Markup
+    # An empty line
+    class BlankLine < Element
+      @instance = new
+
+      # RDoc::Markup::BlankLine is a singleton
+      #: () -> BlankLine
+      def self.new
+        @instance
+      end
+
+      # Calls #accept_blank_line on +visitor+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_blank_line(self)
+      end
+
+      # @override
+      #: (PP) -> void
+      def pretty_print(q) # :nodoc:
+        q.text("blankline")
+      end
+    end
   end
-
 end
-

data/lib/rdoc/markup/block_quote.rb

@@ -7,9 +7,8 @@ class RDoc::Markup::BlockQuote < RDoc::Markup::Raw
   ##
   # Calls #accept_block_quote on +visitor+
 
-  def accept visitor
+  def accept(visitor)
     visitor.accept_block_quote self
   end
 
 end
-

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
 
@@ -37,7 +37,7 @@ class RDoc::Markup::Document
   ##
   # Appends +part+ to the document
 
-  def << part
+  def <<(part)
     case part
     when RDoc::Markup::Document then
       unless part.empty? then
@@ -53,7 +53,7 @@ class RDoc::Markup::Document
     end
   end
 
-  def == other # :nodoc:
+  def ==(other) # :nodoc:
     self.class == other.class and
       @file == other.file and
       @parts == other.parts
@@ -62,7 +62,7 @@ class RDoc::Markup::Document
   ##
   # Runs this document and all its #items through +visitor+
 
-  def accept visitor
+  def accept(visitor)
     visitor.start_accepting
 
     visitor.accept_document self
@@ -73,14 +73,14 @@ class RDoc::Markup::Document
   ##
   # Concatenates the given +parts+ onto the document
 
-  def concat parts
+  def concat(parts)
     self.parts.concat parts
   end
 
   ##
   # Enumerator for the parts of this document
 
-  def each &block
+  def each(&block)
     @parts.each(&block)
   end
 
@@ -94,7 +94,7 @@ class RDoc::Markup::Document
   ##
   # The file this Document was created from.
 
-  def file= location
+  def file=(location)
     @file = case location
             when RDoc::TopLevel then
               location.relative_name
@@ -111,7 +111,7 @@ class RDoc::Markup::Document
   #
   # The information in +other+ is preferred over the receiver
 
-  def merge other
+  def merge(other)
     if empty? then
       @parts = other.parts
       return self
@@ -135,7 +135,7 @@ class RDoc::Markup::Document
     RDoc::Markup::Document === @parts.first
   end
 
-  def pretty_print q # :nodoc:
+  def pretty_print(q) # :nodoc:
     start = @file ? "[doc (#{@file}): " : '[doc: '
 
     q.group 2, start, ']' do
@@ -148,7 +148,7 @@ class RDoc::Markup::Document
   ##
   # Appends +parts+ to the document
 
-  def push *parts
+  def push(*parts)
     self.parts.concat parts
   end
 
@@ -162,4 +162,3 @@ class RDoc::Markup::Document
   end
 
 end
-

data/lib/rdoc/markup/element.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RDoc
+  class Markup
+    # Base class defining the interface for all markup elements found in documentation
+    # @abstract
+    class Element
+      # @abstract
+      #: (untyped) -> void
+      def accept(visitor)
+        raise NotImplementedError, "#{self.class} must implement the accept method"
+      end
+
+      # @abstract
+      #: (PP) -> void
+      def pretty_print(q)
+        raise NotImplementedError, "#{self.class} must implement the pretty_print method"
+      end
+    end
+  end
+end

data/lib/rdoc/markup/formatter.rb

@@ -10,18 +10,14 @@
 # RDoc::Markup::FormatterTestCase.  If you're writing a text-output formatter
 # use RDoc::Markup::TextFormatterTestCase which provides extra test cases.
 
-class RDoc::Markup::Formatter
-
-  ##
-  # Tag for inline markup containing a +bit+ for the bitmask and the +on+ and
-  # +off+ triggers.
+require 'rdoc/markup/inline_parser'
 
-  InlineTag = Struct.new(:bit, :on, :off)
+class RDoc::Markup::Formatter
 
   ##
   # Converts a target url to one that is relative to a given path
 
-  def self.gen_relative_url path, target
+  def self.gen_relative_url(path, target)
     from        = File.dirname path
     to, to_file = File.split target
 
@@ -45,28 +41,16 @@ class RDoc::Markup::Formatter
   ##
   # Creates a new Formatter
 
-  def initialize options, markup = nil
-    @options = options
-
-    @markup = markup || RDoc::Markup.new
-    @am     = @markup.attribute_manager
-    @am.add_regexp_handling(/<br>/, :HARD_BREAK)
+  def initialize
+    @markup = RDoc::Markup.new
 
-    @attributes = @am.attributes
-
-    @attr_tags = []
-
-    @in_tt = 0
-    @tt_bit = @attributes.bitmap_for :TT
-
-    @hard_break = ''
     @from_path = '.'
   end
 
   ##
   # Adds +document+ to the output
 
-  def accept_document document
+  def accept_document(document)
     document.parts.each do |item|
       case item
       when RDoc::Markup::Document then # HACK
@@ -85,150 +69,186 @@ class RDoc::Markup::Formatter
   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
-                                 )
+  # Allows +tag+ to be decorated with additional information.
 
-                                 \[\S+?\]     # link target
-                                /x, :TIDYLINK)
+  def annotate(tag)
+    tag
   end
 
   ##
-  # Add a new set of tags for an attribute. We allow separate start and end
-  # tags for flexibility
+  # Marks up +content+
 
-  def add_tag(name, start, stop)
-    attr = @attributes.bitmap_for name
-    @attr_tags << InlineTag.new(attr, start, stop)
+  def convert(content)
+    @markup.convert content, self
   end
 
-  ##
-  # Allows +tag+ to be decorated with additional information.
+  # Applies regexp handling to +text+ and returns an array of [text, converted?] pairs.
 
-  def annotate(tag)
-    tag
+  def apply_regexp_handling(text)
+    matched = []
+    @markup.regexp_handlings.each_with_index do |(pattern, name), priority|
+      text.scan(pattern) do
+        m = Regexp.last_match
+        idx = m[1] ? 1 : 0
+        matched << [m.begin(idx), m.end(idx), m[idx], name, priority]
+      end
+    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
 
-  ##
-  # Marks up +content+
+  # Called when processing plain text while traversing inline nodes from handle_inline.
+  # +text+ may need proper escaping.
 
-  def convert content
-    @markup.convert content, self
+  def handle_PLAIN_TEXT(text)
   end
 
-  ##
-  # Converts flow items +flow+
+  # Called when processing regexp-handling-processed text while traversing inline nodes from handle_inline.
+  # +text+ may contain markup tags.
+
+  def handle_REGEXP_HANDLING_TEXT(text)
+  end
 
-  def convert_flow(flow)
-    res = []
+  # 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.
 
-    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)
+  def handle_TEXT(text)
+    apply_regexp_handling(text).each do |part, converted|
+      if converted
+        handle_REGEXP_HANDLING_TEXT(part)
       else
-        raise "Unknown flow element: #{item.inspect}"
+        handle_PLAIN_TEXT(part)
       end
     end
+  end
+
+  # Called when processing a hard break while traversing inline nodes from handle_inline.
 
-    res.join
+  def handle_HARD_BREAK
   end
 
-  ##
-  # Converts added regexp handlings. See RDoc::Markup#add_regexp_handling
+  # Called when processing bold nodes while traversing inline nodes from handle_inline.
+  # Traverse the children nodes and dispatch to the appropriate handlers.
 
-  def convert_regexp_handling target
-    return target.text if in_tt?
+  def handle_BOLD(nodes)
+    traverse_inline_nodes(nodes)
+  end
 
-    handled = false
+  # Called when processing emphasis nodes while traversing inline nodes from handle_inline.
+  # Traverse the children nodes and dispatch to the appropriate handlers.
 
-    @attributes.each_name_of target.type do |name|
-      method_name = "handle_regexp_#{name}"
+  def handle_EM(nodes)
+    traverse_inline_nodes(nodes)
+  end
 
-      if respond_to? method_name then
-        target.text = public_send method_name, target
-        handled = true
-      end
-    end
+  # Called when processing bold word nodes while traversing inline nodes from handle_inline.
+  # +word+ may need proper escaping.
 
-    unless handled then
-      target_name = @attributes.as_string target.type
+  def handle_BOLD_WORD(word)
+    handle_PLAIN_TEXT(word)
+  end
 
-      raise RDoc::Error, "Unhandled regexp handling #{target_name}: #{target}"
-    end
+  # Called when processing emphasis word nodes while traversing inline nodes from handle_inline.
+  # +word+ may need proper escaping.
 
-    target.text
+  def handle_EM_WORD(word)
+    handle_PLAIN_TEXT(word)
   end
 
-  ##
-  # Converts a string to be fancier if desired
+  # Called when processing tt nodes while traversing inline nodes from handle_inline.
+  # +code+ may need proper escaping.
 
-  def convert_string string
-    string
+  def handle_TT(code)
+    handle_PLAIN_TEXT(code)
   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 strike nodes while traversing inline nodes from handle_inline.
+  # Traverse the children nodes and dispatch to the appropriate handlers.
 
-  def ignore *node
+  def handle_STRIKE(nodes)
+    traverse_inline_nodes(nodes)
   end
 
-  ##
-  # Are we currently inside tt tags?
+  # 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 in_tt?
-    @in_tt > 0
+  def handle_TIDYLINK(label_part, url)
+    traverse_inline_nodes(label_part)
   end
 
-  ##
-  # Turns on tags for +item+ on +res+
+  # Parses inline +text+, traverse the resulting nodes, and calls the appropriate handler methods.
 
-  def on_tags res, item
-    attr_mask = item.turn_on
-    return if attr_mask.zero?
+  def handle_inline(text)
+    nodes = RDoc::Markup::InlineParser.new(text).parse
+    traverse_inline_nodes(nodes)
+  end
 
-    @attr_tags.each do |tag|
-      if attr_mask & tag.bit != 0 then
-        res << annotate(tag.on)
-        @in_tt += 1 if tt? 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
 
   ##
-  # Turns off tags for +item+ on +res+
+  # Converts a string to be fancier if desired
 
-  def off_tags res, item
-    attr_mask = item.turn_off
-    return if attr_mask.zero?
+  def convert_string(string)
+    string
+  end
 
-    @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
+  ##
+  # 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.
 
-  def parse_url url
+  def parse_url(url)
     case url
     when /^rdoc-label:([^:]*)(?::(.*))?/ then
       scheme = 'link'
@@ -258,9 +278,8 @@ class RDoc::Markup::Formatter
   ##
   # Is +tag+ a tt tag?
 
-  def tt? tag
+  def tt?(tag)
     tag.bit == @tt_bit
   end
 
 end
-

data/lib/rdoc/markup/hard_break.rb

@@ -1,32 +1,34 @@
 # frozen_string_literal: true
-##
-# A hard-break in the middle of a paragraph.
 
-class RDoc::Markup::HardBreak
-
-  @instance = new
-
-  ##
-  # RDoc::Markup::HardBreak is a singleton
-
-  def self.new
-    @instance
-  end
-
-  ##
-  # Calls #accept_hard_break on +visitor+
-
-  def accept visitor
-    visitor.accept_hard_break self
+module RDoc
+  class Markup
+    # A hard-break in the middle of a paragraph.
+    class HardBreak < Element
+      @instance = new
+
+      # RDoc::Markup::HardBreak is a singleton
+      #: () -> HardBreak
+      def self.new
+        @instance
+      end
+
+      # Calls #accept_hard_break on +visitor+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_hard_break(self)
+      end
+
+      #: (top) -> bool
+      def ==(other) # :nodoc:
+        self.class === other
+      end
+
+      # @override
+      #: (PP) -> void
+      def pretty_print(q) # :nodoc:
+        q.text("[break]")
+      end
+    end
   end
-
-  def == other # :nodoc:
-    self.class === other
-  end
-
-  def pretty_print q # :nodoc:
-    q.text "[break]"
-  end
-
 end
-