rdoc 7.2.0 → 8.1.0

data/lib/rdoc/markup/formatter.rb

@@ -12,284 +12,278 @@
 
 require 'rdoc/markup/inline_parser'
 
-class RDoc::Markup::Formatter
+module RDoc
+  class Markup
+    class Formatter
 
-  ##
-  # Tag for inline markup containing a +bit+ for the bitmask and the +on+ and
-  # +off+ triggers.
+      ##
+      # Converts a target url to one that is relative to a given path
 
-  InlineTag = Struct.new(:bit, :on, :off)
+      def self.gen_relative_url(path, target)
+        from        = File.dirname path
+        to, to_file = File.split target
 
+        from = from.split "/"
+        to   = to.split "/"
 
-  ##
-  # Converts a target url to one that is relative to a given path
+        from.delete '.'
+        to.delete '.'
 
-  def self.gen_relative_url(path, target)
-    from        = File.dirname path
-    to, to_file = File.split target
-
-    from = from.split "/"
-    to   = to.split "/"
+        while from.size > 0 and to.size > 0 and from[0] == to[0] do
+          from.shift
+          to.shift
+        end
 
-    from.delete '.'
-    to.delete '.'
+        from.fill ".."
+        from.concat to
+        from << to_file
+        File.join(*from)
+      end
 
-    while from.size > 0 and to.size > 0 and from[0] == to[0] do
-      from.shift
-      to.shift
-    end
+      ##
+      # Creates a new Formatter
 
-    from.fill ".."
-    from.concat to
-    from << to_file
-    File.join(*from)
-  end
+      def initialize
+        @markup = Markup.new
 
-  ##
-  # Creates a new Formatter
+        @from_path = '.'
+      end
 
-  def initialize(options, markup = nil)
-    @options = options
+      ##
+      # Adds +document+ to the output
+
+      def accept_document(document)
+        document.parts.each do |item|
+          case item
+          when Markup::Document # HACK
+            accept_document item
+          else
+            item.accept self
+          end
+        end
+      end
 
-    @markup = markup || RDoc::Markup.new
+      ##
+      # Adds a regexp handling for links of the form rdoc-...:
 
-    @from_path = '.'
-  end
+      def add_regexp_handling_RDOCLINK
+        @markup.add_regexp_handling(/rdoc-[a-z]+:[^\s\]]+/, :RDOCLINK)
+      end
 
-  ##
-  # Adds +document+ to the output
+      ##
+      # Allows +tag+ to be decorated with additional information.
 
-  def accept_document(document)
-    document.parts.each do |item|
-      case item
-      when RDoc::Markup::Document then # HACK
-        accept_document item
-      else
-        item.accept self
+      def annotate(tag)
+        tag
       end
-    end
-  end
 
-  ##
-  # Adds a regexp handling for links of the form rdoc-...:
+      ##
+      # Marks up +content+
 
-  def add_regexp_handling_RDOCLINK
-    @markup.add_regexp_handling(/rdoc-[a-z]+:[^\s\]]+/, :RDOCLINK)
-  end
+      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
-  end
+      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
 
-  ##
-  # Marks up +content+
+        output << [text[pos..], false] if pos < text.size
+        output
+      end
 
-  def convert(content)
-    @markup.convert content, self
-  end
+      # Called when processing plain text while traversing inline nodes from handle_inline.
+      # +text+ may need proper escaping.
 
-  # 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
+      def handle_PLAIN_TEXT(text)
       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
-    output
-  end
 
-  # Called when processing plain text while traversing inline nodes from handle_inline.
-  # +text+ may need proper escaping.
+      # Called when processing regexp-handling-processed text while traversing inline nodes from handle_inline.
+      # +text+ may contain markup tags.
 
-  def handle_PLAIN_TEXT(text)
-  end
+      def handle_REGEXP_HANDLING_TEXT(text)
+      end
 
-  # Called when processing regexp-handling-processed text while traversing inline nodes from handle_inline.
-  # +text+ may contain markup tags.
+      # 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.
 
-  def handle_REGEXP_HANDLING_TEXT(text)
-  end
+      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
 
-  # 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.
+      # Called when processing a hard break while traversing inline nodes from handle_inline.
 
-  def handle_TEXT(text)
-    apply_regexp_handling(text).each do |part, converted|
-      if converted
-        handle_REGEXP_HANDLING_TEXT(part)
-      else
-        handle_PLAIN_TEXT(part)
+      def handle_HARD_BREAK
       end
-    end
-  end
 
-  # Called when processing a hard break while traversing inline nodes from handle_inline.
+      # Called when processing bold nodes while traversing inline nodes from handle_inline.
+      # Traverse the children nodes and dispatch to the appropriate handlers.
 
-  def handle_HARD_BREAK
-  end
+      def handle_BOLD(nodes)
+        traverse_inline_nodes(nodes)
+      end
 
-  # Called when processing bold nodes while traversing inline nodes from handle_inline.
-  # Traverse the children nodes and dispatch to the appropriate handlers.
+      # Called when processing emphasis 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
+      def handle_EM(nodes)
+        traverse_inline_nodes(nodes)
+      end
 
-  # Called when processing emphasis nodes while traversing inline nodes from handle_inline.
-  # Traverse the children nodes and dispatch to the appropriate handlers.
+      # Called when processing bold word nodes while traversing inline nodes from handle_inline.
+      # +word+ may need proper escaping.
 
-  def handle_EM(nodes)
-    traverse_inline_nodes(nodes)
-  end
+      def handle_BOLD_WORD(word)
+        handle_PLAIN_TEXT(word)
+      end
 
-  # Called when processing bold word nodes while traversing inline nodes from handle_inline.
-  # +word+ may need proper escaping.
+      # Called when processing emphasis word nodes while traversing inline nodes from handle_inline.
+      # +word+ may need proper escaping.
 
-  def handle_BOLD_WORD(word)
-    handle_PLAIN_TEXT(word)
-  end
+      def handle_EM_WORD(word)
+        handle_PLAIN_TEXT(word)
+      end
 
-  # Called when processing emphasis word nodes while traversing inline nodes from handle_inline.
-  # +word+ may need proper escaping.
+      # Called when processing tt nodes while traversing inline nodes from handle_inline.
+      # +code+ may need proper escaping.
 
-  def handle_EM_WORD(word)
-    handle_PLAIN_TEXT(word)
-  end
+      def handle_TT(code)
+        handle_PLAIN_TEXT(code)
+      end
 
-  # Called when processing tt nodes while traversing inline nodes from handle_inline.
-  # +code+ may need proper escaping.
+      # Called when processing strike nodes while traversing inline nodes from handle_inline.
+      # Traverse the children nodes and dispatch to the appropriate handlers.
 
-  def handle_TT(code)
-    handle_PLAIN_TEXT(code)
-  end
+      def handle_STRIKE(nodes)
+        traverse_inline_nodes(nodes)
+      end
 
-  # Called when processing strike nodes while traversing inline nodes from handle_inline.
-  # Traverse the children nodes and dispatch to the appropriate handlers.
+      # 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 handle_STRIKE(nodes)
-    traverse_inline_nodes(nodes)
-  end
+      def handle_TIDYLINK(label_part, url)
+        traverse_inline_nodes(label_part)
+      end
 
-  # 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.
+      # Parses inline +text+, traverse the resulting nodes, and calls the appropriate handler methods.
 
-  def handle_TIDYLINK(label_part, url)
-    traverse_inline_nodes(label_part)
-  end
+      def handle_inline(text)
+        nodes = Markup::InlineParser.new(text).parse
+        traverse_inline_nodes(nodes)
+      end
 
-  # Parses inline +text+, traverse the resulting nodes, and calls the appropriate handler methods.
+      # 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
 
-  def handle_inline(text)
-    nodes = RDoc::Markup::InlineParser.new(text).parse
-    traverse_inline_nodes(nodes)
-  end
+      ##
+      # Converts a string to be fancier if desired
 
-  # 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])
+      def convert_string(string)
+        string
       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
 
-  ##
-  # 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
 
-  def ignore *node
-  end
+      ##
+      # Extracts and a scheme, url and an anchor id from +url+ and returns them.
+
+      def parse_url(url)
+        case url
+        when /^rdoc-label:([^:]*)(?::(.*))?/
+          scheme = 'link'
+          path   = "##{$1}"
+          id     = " id=\"#{$2}\"" if $2
+        when /([A-Za-z]+):(.*)/
+          scheme = $1.downcase
+          path   = $2
+        when /^#/
+        else
+          scheme = 'http'
+          path   = url
+          url    = url
+        end
 
-  ##
-  # Extracts and a scheme, url and an anchor id from +url+ and returns them.
-
-  def parse_url(url)
-    case url
-    when /^rdoc-label:([^:]*)(?::(.*))?/ then
-      scheme = 'link'
-      path   = "##{$1}"
-      id     = " id=\"#{$2}\"" if $2
-    when /([A-Za-z]+):(.*)/ then
-      scheme = $1.downcase
-      path   = $2
-    when /^#/ then
-    else
-      scheme = 'http'
-      path   = url
-      url    = url
-    end
+        if scheme == 'link'
+          url = if path[0, 1] == '#' # is this meaningful?
+                  path
+                else
+                  self.class.gen_relative_url @from_path, path
+                end
+        end
 
-    if scheme == 'link' then
-      url = if path[0, 1] == '#' then # is this meaningful?
-              path
-            else
-              self.class.gen_relative_url @from_path, path
-            end
-    end
+        [scheme, url, id]
+      end
 
-    [scheme, url, id]
-  end
+      ##
+      # Is +tag+ a tt tag?
 
-  ##
-  # Is +tag+ a tt tag?
+      def tt?(tag)
+        tag.bit == @tt_bit
+      end
 
-  def tt?(tag)
-    tag.bit == @tt_bit
+    end
   end
-
 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/include.rb

@@ -1,42 +1,46 @@
 # frozen_string_literal: true
-##
-# A file included at generation time.  Objects of this class are created by
-# RDoc::RD for an extension-less include.
-#
-# This implementation in incomplete.
+module RDoc
+  class Markup
+    ##
+    # A file included at generation time.  Objects of this class are created by
+    # RDoc::RD for an extension-less include.
+    #
+    # This implementation in incomplete.
 
-class RDoc::Markup::Include
+    class Include
 
-  ##
-  # The filename to be included, without extension
+      ##
+      # The filename to be included, without extension
 
-  attr_reader :file
+      attr_reader :file
 
-  ##
-  # Directories to search for #file
+      ##
+      # Directories to search for #file
 
-  attr_reader :include_path
+      attr_reader :include_path
 
-  ##
-  # Creates a new include that will import +file+ from +include_path+
+      ##
+      # Creates a new include that will import +file+ from +include_path+
 
-  def initialize(file, include_path)
-    @file = file
-    @include_path = include_path
-  end
+      def initialize(file, include_path)
+        @file = file
+        @include_path = include_path
+      end
 
-  def ==(other) # :nodoc:
-    self.class === other and
-      @file == other.file and @include_path == other.include_path
-  end
+      def ==(other) # :nodoc:
+        self.class === other and
+          @file == other.file and @include_path == other.include_path
+      end
+
+      def pretty_print(q) # :nodoc:
+        q.group 2, '[incl ', ']' do
+          q.text file
+          q.breakable
+          q.text 'from '
+          q.pp include_path
+        end
+      end
 
-  def pretty_print(q) # :nodoc:
-    q.group 2, '[incl ', ']' do
-      q.text file
-      q.breakable
-      q.text 'from '
-      q.pp include_path
     end
   end
-
 end

data/lib/rdoc/markup/indented_paragraph.rb

@@ -1,47 +1,51 @@
 # frozen_string_literal: true
-##
-# An Indented Paragraph of text
+module RDoc
+  class Markup
+    ##
+    # An Indented Paragraph of text
 
-class RDoc::Markup::IndentedParagraph < RDoc::Markup::Raw
+    class IndentedParagraph < Markup::Raw
 
-  ##
-  # The indent in number of spaces
+      ##
+      # The indent in number of spaces
 
-  attr_reader :indent
+      attr_reader :indent
 
-  ##
-  # Creates a new IndentedParagraph containing +parts+ indented with +indent+
-  # spaces
+      ##
+      # Creates a new IndentedParagraph containing +parts+ indented with +indent+
+      # spaces
 
-  def initialize indent, *parts
-    @indent = indent
+      def initialize(indent, *parts)
+        @indent = indent
 
-    super(*parts)
-  end
+        super(*parts)
+      end
 
-  def ==(other) # :nodoc:
-    super and indent == other.indent
-  end
+      def ==(other) # :nodoc:
+        super and indent == other.indent
+      end
 
-  ##
-  # Calls #accept_indented_paragraph on +visitor+
+      ##
+      # Calls #accept_indented_paragraph on +visitor+
 
-  def accept(visitor)
-    visitor.accept_indented_paragraph self
-  end
-
-  ##
-  # Joins the raw paragraph text and converts inline HardBreaks to the
-  # +hard_break+ text followed by the indent.
+      def accept(visitor)
+        visitor.accept_indented_paragraph self
+      end
 
-  def text(hard_break = nil)
-    @parts.map do |part|
-      if RDoc::Markup::HardBreak === part then
-        '%1$s%3$*2$s' % [hard_break, @indent, ' '] if hard_break
-      else
-        part
+      ##
+      # Joins the raw paragraph text and converts inline HardBreaks to the
+      # +hard_break+ text followed by the indent.
+
+      def text(hard_break = nil)
+        @parts.map do |part|
+          if Markup::HardBreak === part
+            '%1$s%3$*2$s' % [hard_break, @indent, ' '] if hard_break
+          else
+            part
+          end
+        end.join
       end
-    end.join
-  end
 
+    end
+  end
 end