rdoc 6.17.0 → 8.1.0

data/lib/rdoc/markup/to_table_of_contents.rb

@@ -1,88 +1,92 @@
 # frozen_string_literal: true
-##
-# Extracts just the RDoc::Markup::Heading elements from a
-# RDoc::Markup::Document to help build a table of contents
+module RDoc
+  class Markup
+    ##
+    # Extracts just the RDoc::Markup::Heading elements from a
+    # RDoc::Markup::Document to help build a table of contents
 
-class RDoc::Markup::ToTableOfContents < RDoc::Markup::Formatter
+    class ToTableOfContents < Markup::Formatter
 
-  @to_toc = nil
+      @to_toc = nil
 
-  ##
-  # Singleton for table-of-contents generation
+      ##
+      # Singleton for table-of-contents generation
 
-  def self.to_toc
-    @to_toc ||= new
-  end
+      def self.to_toc
+        @to_toc ||= new
+      end
 
-  ##
-  # Output accumulator
+      ##
+      # Output accumulator
 
-  attr_reader :res
+      attr_reader :res
 
-  ##
-  # Omits headings with a level less than the given level.
+      ##
+      # Omits headings with a level less than the given level.
 
-  attr_accessor :omit_headings_below
+      attr_accessor :omit_headings_below
 
-  def initialize # :nodoc:
-    super nil
+      def initialize # :nodoc:
+        super
 
-    @omit_headings_below = nil
-  end
+        @omit_headings_below = nil
+      end
 
-  ##
-  # Adds +document+ to the output, using its heading cutoff if present
+      ##
+      # Adds +document+ to the output, using its heading cutoff if present
 
-  def accept_document(document)
-    @omit_headings_below = document.omit_headings_below
+      def accept_document(document)
+        @omit_headings_below = document.omit_headings_below
 
-    super
-  end
+        super
+      end
 
-  ##
-  # Adds +heading+ to the table of contents
+      ##
+      # Adds +heading+ to the table of contents
 
-  def accept_heading(heading)
-    @res << heading unless suppressed? heading
-  end
+      def accept_heading(heading)
+        @res << heading unless suppressed? heading
+      end
 
-  ##
-  # Returns the table of contents
+      ##
+      # Returns the table of contents
 
-  def end_accepting
-    @res
-  end
+      def end_accepting
+        @res
+      end
 
-  ##
-  # Prepares the visitor for text generation
+      ##
+      # Prepares the visitor for text generation
 
-  def start_accepting
-    @omit_headings_below = nil
-    @res = []
-  end
+      def start_accepting
+        @omit_headings_below = nil
+        @res = []
+      end
 
-  ##
-  # Returns true if +heading+ is below the display threshold
+      ##
+      # Returns true if +heading+ is below the display threshold
 
-  def suppressed?(heading)
-    return false unless @omit_headings_below
+      def suppressed?(heading)
+        return false unless @omit_headings_below
 
-    heading.level > @omit_headings_below
-  end
+        heading.level > @omit_headings_below
+      end
 
-  # :stopdoc:
-  alias accept_block_quote     ignore
-  alias accept_raw             ignore
-  alias accept_rule            ignore
-  alias accept_blank_line      ignore
-  alias accept_paragraph       ignore
-  alias accept_verbatim        ignore
-  alias accept_list_end        ignore
-  alias accept_list_item_start ignore
-  alias accept_list_item_end   ignore
-  alias accept_list_end_bullet ignore
-  alias accept_list_start      ignore
-  alias accept_table           ignore
-  # :startdoc:
+      # :stopdoc:
+      alias accept_block_quote     ignore
+      alias accept_raw             ignore
+      alias accept_rule            ignore
+      alias accept_blank_line      ignore
+      alias accept_paragraph       ignore
+      alias accept_verbatim        ignore
+      alias accept_list_end        ignore
+      alias accept_list_item_start ignore
+      alias accept_list_item_end   ignore
+      alias accept_list_end_bullet ignore
+      alias accept_list_start      ignore
+      alias accept_table           ignore
+      # :startdoc:
 
+    end
+  end
 end

data/lib/rdoc/markup/to_test.rb

@@ -1,69 +1,81 @@
 # frozen_string_literal: true
-##
-# This Markup outputter is used for testing purposes.
+module RDoc
+  class Markup
+    ##
+    # This Markup outputter is used for testing purposes.
 
-class RDoc::Markup::ToTest < RDoc::Markup::Formatter
+    class ToTest < Markup::Formatter
 
-  # :stopdoc:
+      # :stopdoc:
 
-  ##
-  # :section: Visitor
+      ##
+      # :section: Visitor
 
-  def start_accepting
-    @res = []
-    @list = []
-  end
+      def start_accepting
+        @res = []
+        @list = []
+      end
 
-  def end_accepting
-    @res
-  end
+      def end_accepting
+        @res
+      end
 
-  def accept_paragraph(paragraph)
-    @res << convert_flow(@am.flow(paragraph.text))
-  end
+      def handle_PLAIN_TEXT(text)
+        @res << text
+      end
 
-  def accept_raw(raw)
-    @res << raw.parts.join
-  end
+      def handle_REGEXP_HANDLING_TEXT(text)
+        @res << text
+      end
 
-  def accept_verbatim(verbatim)
-    @res << verbatim.text.gsub(/^(\S)/, '  \1')
-  end
+      def accept_paragraph(paragraph)
+        handle_inline(paragraph.text)
+      end
 
-  def accept_list_start(list)
-    @list << case list.type
-             when :BULLET then
-               '*'
-             when :NUMBER then
-               '1'
-             else
-               list.type
-             end
-  end
+      def accept_raw(raw)
+        @res << raw.parts.join
+      end
 
-  def accept_list_end(list)
-    @list.pop
-  end
+      def accept_verbatim(verbatim)
+        @res << verbatim.text.gsub(/^(\S)/, '  \1')
+      end
 
-  def accept_list_item_start(list_item)
-    @res << "#{' ' * (@list.size - 1)}#{@list.last}: "
-  end
+      def accept_list_start(list)
+        @list << case list.type
+                 when :BULLET
+                   '*'
+                 when :NUMBER
+                   '1'
+                 else
+                   list.type
+                 end
+      end
 
-  def accept_list_item_end(list_item)
-  end
+      def accept_list_end(list)
+        @list.pop
+      end
 
-  def accept_blank_line(blank_line)
-    @res << "\n"
-  end
+      def accept_list_item_start(list_item)
+        @res << "#{' ' * (@list.size - 1)}#{@list.last}: "
+      end
 
-  def accept_heading(heading)
-    @res << "#{'=' * heading.level} #{heading.text}"
-  end
+      def accept_list_item_end(list_item)
+      end
 
-  def accept_rule(rule)
-    @res << '-' * rule.weight
-  end
+      def accept_blank_line(blank_line)
+        @res << "\n"
+      end
 
-  # :startdoc:
+      def accept_heading(heading)
+        @res << "#{'=' * heading.level} #{heading.text}"
+      end
 
+      def accept_rule(rule)
+        @res << '-' * rule.weight
+      end
+
+      # :startdoc:
+
+    end
+  end
 end

data/lib/rdoc/markup/to_tt_only.rb

@@ -1,120 +1,111 @@
 # frozen_string_literal: true
-##
-# Extracts sections of text enclosed in plus, tt or code.  Used to discover
-# undocumented parameters.
+module RDoc
+  class Markup
+    ##
+    # Extracts sections of text enclosed in plus, tt or code.  Used to discover
+    # undocumented parameters.
 
-class RDoc::Markup::ToTtOnly < RDoc::Markup::Formatter
+    class ToTtOnly < Markup::Formatter
 
-  ##
-  # Stack of list types
+      ##
+      # Stack of list types
 
-  attr_reader :list_type
+      attr_reader :list_type
 
-  ##
-  # Output accumulator
+      ##
+      # Output accumulator
 
-  attr_reader :res
+      attr_reader :res
 
-  ##
-  # Creates a new tt-only formatter.
+      ##
+      # Adds tts from +block_quote+ to the output
 
-  def initialize(markup = nil)
-    super nil, markup
-
-    add_tag :TT, nil, nil
-  end
-
-  ##
-  # Adds tts from +block_quote+ to the output
-
-  def accept_block_quote(block_quote)
-    tt_sections block_quote.text
-  end
+      def accept_block_quote(block_quote)
+        tt_sections block_quote.text
+      end
 
-  ##
-  # Pops the list type for +list+ from #list_type
+      ##
+      # Pops the list type for +list+ from #list_type
 
-  def accept_list_end(list)
-    @list_type.pop
-  end
+      def accept_list_end(list)
+        @list_type.pop
+      end
 
-  ##
-  # Pushes the list type for +list+ onto #list_type
+      ##
+      # Pushes the list type for +list+ onto #list_type
 
-  def accept_list_start(list)
-    @list_type << list.type
-  end
+      def accept_list_start(list)
+        @list_type << list.type
+      end
 
-  ##
-  # Prepares the visitor for consuming +list_item+
+      ##
+      # Prepares the visitor for consuming +list_item+
 
-  def accept_list_item_start(list_item)
-    case @list_type.last
-    when :NOTE, :LABEL then
-      Array(list_item.label).map do |label|
-        tt_sections label
-      end.flatten
-    end
-  end
+      def accept_list_item_start(list_item)
+        case @list_type.last
+        when :NOTE, :LABEL
+          Array(list_item.label).map do |label|
+            tt_sections label
+          end.flatten
+        end
+      end
 
-  ##
-  # Adds +paragraph+ to the output
+      ##
+      # Adds +paragraph+ to the output
 
-  def accept_paragraph(paragraph)
-    tt_sections(paragraph.text)
-  end
+      def accept_paragraph(paragraph)
+        tt_sections(paragraph.text)
+      end
 
-  ##
-  # Does nothing to +markup_item+ because it doesn't have any user-built
-  # content
+      ##
+      # Does nothing to +markup_item+ because it doesn't have any user-built
+      # content
 
-  def do_nothing(markup_item)
-  end
+      def do_nothing(markup_item)
+      end
 
-  alias accept_blank_line    do_nothing # :nodoc:
-  alias accept_heading       do_nothing # :nodoc:
-  alias accept_list_item_end do_nothing # :nodoc:
-  alias accept_raw           do_nothing # :nodoc:
-  alias accept_rule          do_nothing # :nodoc:
-  alias accept_verbatim      do_nothing # :nodoc:
-
-  ##
-  # 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?
-      else
-        raise "Unknown flow element: #{item.inspect}"
+      alias accept_blank_line    do_nothing # :nodoc:
+      alias accept_heading       do_nothing # :nodoc:
+      alias accept_list_item_end do_nothing # :nodoc:
+      alias accept_raw           do_nothing # :nodoc:
+      alias accept_rule          do_nothing # :nodoc:
+      alias accept_verbatim      do_nothing # :nodoc:
+
+      ##
+      # Extracts tt sections from +text+
+
+      def tt_sections(text)
+        parsed = Markup::InlineParser.new(text).parse
+        traverse = -> node {
+          next if String === node
+          if node[:type] == :TT
+            res << nil
+            res << node[:children][0] || ''
+            res << nil
+          else
+            node[:children].each(&traverse)
+          end
+        }
+        parsed.each(&traverse)
+        res
       end
-    end
 
-    res
-  end
+      ##
+      # Returns an Array of items that were wrapped in plus, tt or code.
 
-  ##
-  # Returns an Array of items that were wrapped in plus, tt or code.
+      def end_accepting
+        @res.compact
+      end
 
-  def end_accepting
-    @res.compact
-  end
+      ##
+      # Prepares the visitor for gathering tt sections
 
-  ##
-  # Prepares the visitor for gathering tt sections
+      def start_accepting
+        @res = []
 
-  def start_accepting
-    @res = []
+        @list_type = []
+      end
 
-    @list_type = []
+    end
   end
-
 end

data/lib/rdoc/markup/verbatim.rb

@@ -1,83 +1,87 @@
 # frozen_string_literal: true
-##
-# A section of verbatim text
+module RDoc
+  class Markup
+    ##
+    # A section of verbatim text
 
-class RDoc::Markup::Verbatim < RDoc::Markup::Raw
+    class Verbatim < Markup::Raw
 
-  ##
-  # Format of this verbatim section
+      ##
+      # Format of this verbatim section
 
-  attr_accessor :format
+      attr_accessor :format
 
-  def initialize *parts # :nodoc:
-    super
+      def initialize(*parts) # :nodoc:
+        super
 
-    @format = nil
-  end
-
-  def ==(other) # :nodoc:
-    super and @format == other.format
-  end
+        @format = nil
+      end
 
-  ##
-  # Calls #accept_verbatim on +visitor+
+      def ==(other) # :nodoc:
+        super and @format == other.format
+      end
 
-  def accept(visitor)
-    visitor.accept_verbatim self
-  end
+      ##
+      # Calls #accept_verbatim on +visitor+
 
-  ##
-  # Collapses 3+ newlines into two newlines
+      def accept(visitor)
+        visitor.accept_verbatim self
+      end
 
-  def normalize
-    parts = []
+      ##
+      # Collapses 3+ newlines into two newlines
 
-    newlines = 0
+      def normalize
+        parts = []
 
-    @parts.each do |part|
-      case part
-      when /^\s*\n/ then
-        newlines += 1
-        parts << part if newlines == 1
-      else
         newlines = 0
-        parts << part
-      end
-    end
 
-    parts.pop if parts.last =~ /\A\r?\n\z/
-
-    @parts = parts
-  end
+        @parts.each do |part|
+          case part
+          when /^\s*\n/
+            newlines += 1
+            parts << part if newlines == 1
+          else
+            newlines = 0
+            parts << part
+          end
+        end
 
-  def pretty_print(q) # :nodoc:
-    self.class.name =~ /.*::(\w{1,4})/i
+        parts.pop if parts.last =~ /\A\r?\n\z/
 
-    q.group 2, "[#{$1.downcase}: ", ']' do
-      if @format then
-        q.text "format: #{@format}"
-        q.breakable
+        @parts = parts
       end
 
-      q.seplist @parts do |part|
-        q.pp part
+      def pretty_print(q) # :nodoc:
+        self.class.name =~ /.*::(\w{1,4})/i
+
+        q.group 2, "[#{$1.downcase}: ", ']' do
+          if @format
+            q.text "format: #{@format}"
+            q.breakable
+          end
+
+          q.seplist @parts do |part|
+            q.pp part
+          end
+        end
       end
-    end
-  end
 
-  ##
-  # Is this verbatim section Ruby code?
+      ##
+      # Is this verbatim section Ruby code?
 
-  def ruby?
-    @format ||= nil # TODO for older ri data, switch the tree to marshal_dump
-    @format == :ruby
-  end
+      def ruby?
+        @format ||= nil # TODO for older ri data, switch the tree to marshal_dump
+        @format == :ruby || @format == :rb
+      end
 
-  ##
-  # The text of the section
+      ##
+      # The text of the section
 
-  def text
-    @parts.join
-  end
+      def text
+        @parts.join
+      end
 
+    end
+  end
 end