rdoc 5.1.0 → 6.13.1

data/lib/rdoc/markup/paragraph.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A Paragraph of text
 
@@ -26,4 +26,3 @@ class RDoc::Markup::Paragraph < RDoc::Markup::Raw
   end
 
 end
-

data/lib/rdoc/markup/parser.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 require 'strscan'
 
 ##
@@ -9,8 +9,9 @@ require 'strscan'
 # RDoc::Markup::ToHTML.
 #
 # The parser only handles the block-level constructs Paragraph, List,
-# ListItem, Heading, Verbatim, BlankLine and Rule.  Inline markup such as
-# <tt>\+blah\+</tt> is handled separately by RDoc::Markup::AttributeManager.
+# ListItem, Heading, Verbatim, BlankLine, Rule and BlockQuote.
+# Inline markup such as <tt>\+blah\+</tt> is handled separately by
+# RDoc::Markup::AttributeManager.
 #
 # To see what markup the Parser implements read RDoc.  To see how to use
 # RDoc markup to format text in your program read RDoc::Markup.
@@ -79,10 +80,6 @@ class RDoc::Markup::Parser
     @binary_input   = nil
     @current_token  = nil
     @debug          = false
-    @input          = nil
-    @input_encoding = nil
-    @line           = 0
-    @line_pos       = 0
     @s              = nil
     @tokens         = []
   end
@@ -221,7 +218,7 @@ class RDoc::Markup::Parser
 
         break if peek_token.first == :BREAK
 
-        data << ' ' if skip :NEWLINE
+        data << ' ' if skip :NEWLINE and /#{SPACE_SEPARATED_LETTER_CLASS}\z/o.match?(data)
       else
         unget
         break
@@ -249,7 +246,7 @@ class RDoc::Markup::Parser
 
     min_indent = nil
     generate_leading_spaces = true
-    line = ''
+    line = ''.dup
 
     until @tokens.empty? do
       type, data, column, = get
@@ -257,7 +254,7 @@ class RDoc::Markup::Parser
       if type == :NEWLINE then
         line << data
         verbatim << line
-        line = ''
+        line = ''.dup
         generate_leading_spaces = true
         next
       end
@@ -290,6 +287,12 @@ class RDoc::Markup::Parser
         line << ' ' * indent
       when :BREAK, :TEXT then
         line << data
+      when :BLOCKQUOTE then
+        line << '>>>'
+        peek_type, _, peek_column = peek_token
+        if peek_type != :NEWLINE and peek_column
+          line << ' ' * (peek_column - column - 3)
+        end
       else # *LIST_TOKENS
         list_marker = case type
                       when :BULLET then data
@@ -318,13 +321,6 @@ class RDoc::Markup::Parser
     verbatim
   end
 
-  ##
-  # The character offset for the input string at the given +byte_offset+
-
-  def char_pos byte_offset
-    @input.byteslice(0, byte_offset).length
-  end
-
   ##
   # Pulls the next token from the stream.
 
@@ -381,6 +377,14 @@ class RDoc::Markup::Parser
       when :TEXT then
         unget
         parse_text parent, indent
+      when :BLOCKQUOTE then
+        nil while (type, = get; type) and type != :NEWLINE
+        _, _, column, = peek_token
+        bq = RDoc::Markup::BlockQuote.new
+        p :blockquote_start => [data, column] if @debug
+        parse bq, column
+        p :blockquote_end => indent if @debug
+        parent << bq
       when *LIST_TOKENS then
         unget
         parent << build_list(indent)
@@ -412,15 +416,57 @@ class RDoc::Markup::Parser
     token
   end
 
+  ##
+  # A simple wrapper of StringScanner that is aware of the current column and lineno
+
+  class MyStringScanner
+    # :stopdoc:
+
+    def initialize(input)
+      @line = @column = 0
+      @s = StringScanner.new input
+    end
+
+    def scan(re)
+      ret = @s.scan(re)
+      @column += ret.length if ret
+      ret
+    end
+
+    def unscan(s)
+      @s.pos -= s.bytesize
+      @column -= s.length
+    end
+
+    def pos
+      [@column, @line]
+    end
+
+    def newline!
+      @column = 0
+      @line += 1
+    end
+
+    def eos?
+      @s.eos?
+    end
+
+    def matched
+      @s.matched
+    end
+
+    def [](i)
+      @s[i]
+    end
+
+    #:startdoc:
+  end
+
   ##
   # Creates the StringScanner
 
   def setup_scanner input
-    @line     = 0
-    @line_pos = 0
-    @input    = input.dup
-
-    @s = StringScanner.new input
+    @s = MyStringScanner.new input
   end
 
   ##
@@ -455,31 +501,30 @@ class RDoc::Markup::Parser
       @tokens << case
                  # [CR]LF => :NEWLINE
                  when @s.scan(/\r?\n/) then
-                   token = [:NEWLINE, @s.matched, *token_pos(pos)]
-                   @line_pos = char_pos @s.pos
-                   @line += 1
+                   token = [:NEWLINE, @s.matched, *pos]
+                   @s.newline!
                    token
                  # === text => :HEADER then :TEXT
                  when @s.scan(/(=+)(\s*)/) then
                    level = @s[1].length
-                   header = [:HEADER, level, *token_pos(pos)]
+                   header = [:HEADER, level, *pos]
 
                    if @s[2] =~ /^\r?\n/ then
-                     @s.pos -= @s[2].length
+                     @s.unscan(@s[2])
                      header
                    else
                      pos = @s.pos
                      @s.scan(/.*/)
                      @tokens << header
-                     [:TEXT, @s.matched.sub(/\r$/, ''), *token_pos(pos)]
+                     [:TEXT, @s.matched.sub(/\r$/, ''), *pos]
                    end
                  # --- (at least 3) and nothing else on the line => :RULE
                  when @s.scan(/(-{3,}) *\r?$/) then
-                   [:RULE, @s[1].length - 2, *token_pos(pos)]
+                   [:RULE, @s[1].length - 2, *pos]
                  # * or - followed by white space and text => :BULLET
                  when @s.scan(/([*-]) +(\S)/) then
-                   @s.pos -= @s[2].bytesize # unget \S
-                   [:BULLET, @s[1], *token_pos(pos)]
+                   @s.unscan(@s[2])
+                   [:BULLET, @s[1], *pos]
                  # A. text, a. text, 12. text => :UALPHA, :LALPHA, :NUMBER
                  when @s.scan(/([a-z]|\d+)\. +(\S)/i) then
                    # FIXME if tab(s), the column will be wrong
@@ -488,7 +533,7 @@ class RDoc::Markup::Parser
                    # before (and provide a check for that at least in debug
                    # mode)
                    list_label = @s[1]
-                   @s.pos -= @s[2].bytesize # unget \S
+                   @s.unscan(@s[2])
                    list_type =
                      case list_label
                      when /[a-z]/ then :LALPHA
@@ -497,20 +542,27 @@ class RDoc::Markup::Parser
                      else
                        raise ParseError, "BUG token #{list_label}"
                      end
-                   [list_type, list_label, *token_pos(pos)]
+                   [list_type, list_label, *pos]
                  # [text] followed by spaces or end of line => :LABEL
                  when @s.scan(/\[(.*?)\]( +|\r?$)/) then
-                   [:LABEL, @s[1], *token_pos(pos)]
+                   [:LABEL, @s[1], *pos]
                  # text:: followed by spaces or end of line => :NOTE
                  when @s.scan(/(.*?)::( +|\r?$)/) then
-                   [:NOTE, @s[1], *token_pos(pos)]
+                   [:NOTE, @s[1], *pos]
+                 # >>> followed by end of line => :BLOCKQUOTE
+                 when @s.scan(/>>> *(\w+)?$/) then
+                   if word = @s[1]
+                     @s.unscan(word)
+                   end
+                   [:BLOCKQUOTE, word, *pos]
                  # anything else: :TEXT
-                 else @s.scan(/(.*?)(  )?\r?$/)
-                   token = [:TEXT, @s[1], *token_pos(pos)]
+                 else
+                   @s.scan(/(.*?)(  )?\r?$/)
+                   token = [:TEXT, @s[1], *pos]
 
                    if @s[2] then
                      @tokens << token
-                     [:BREAK, @s[2], *token_pos(pos + @s[1].length)]
+                     [:BREAK, @s[2], pos[0] + @s[1].length, pos[1]]
                    else
                      token
                    end
@@ -520,16 +572,6 @@ class RDoc::Markup::Parser
     self
   end
 
-  ##
-  # Calculates the column (by character) and line of the current token based
-  # on +byte_offset+.
-
-  def token_pos byte_offset
-    offset = char_pos byte_offset
-
-    [offset - @line_pos, @line]
-  end
-
   ##
   # Returns the current token to the token stream
 

data/lib/rdoc/markup/pre_process.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # Handle common directives that can occur in a block of text:
 #
@@ -97,15 +97,18 @@ class RDoc::Markup::PreProcess
   # RDoc::CodeObject#metadata for details.
 
   def handle text, code_object = nil, &block
+    first_line = 1
     if RDoc::Comment === text then
       comment = text
       text = text.text
+      first_line = comment.line || 1
     end
 
     # regexp helper (square brackets for optional)
     # $1      $2  $3        $4      $5
     # [prefix][\]:directive:[spaces][param]newline
-    text.gsub!(/^([ \t]*(?:#|\/?\*)?[ \t]*)(\\?):(\w+):([ \t]*)(.+)?(\r?\n|$)/) do
+    text = text.lines.map.with_index(first_line) do |line, num|
+      next line unless line =~ /\A([ \t]*(?:#|\/?\*)?[ \t]*)(\\?):([\w-]+):([ \t]*)(.+)?(\r?\n|$)/
       # skip something like ':toto::'
       next $& if $4.empty? and $5 and $5[0, 1] == ':'
 
@@ -120,10 +123,14 @@ class RDoc::Markup::PreProcess
         next "#{$1.strip}\n"
       end
 
-      handle_directive $1, $3, $5, code_object, text.encoding, &block
-    end
+      handle_directive $1, $3, $5, code_object, text.encoding, num, &block
+    end.join
 
-    comment = text unless comment
+    if comment then
+      comment.text = text
+    else
+      comment = text
+    end
 
     self.class.post_processors.each do |handler|
       handler.call comment, code_object
@@ -144,13 +151,13 @@ class RDoc::Markup::PreProcess
   # When 1.8.7 support is ditched prefix can be defaulted to ''
 
   def handle_directive prefix, directive, param, code_object = nil,
-                       encoding = nil
+                       encoding = nil, line = nil
     blankline = "#{prefix.strip}\n"
     directive = directive.downcase
 
     case directive
     when 'arg', 'args' then
-      return "#{prefix}:#{directive}: #{param}\n" unless code_object
+      return "#{prefix}:#{directive}: #{param}\n" unless code_object && code_object.kind_of?(RDoc::AnyMethod)
 
       code_object.params = param
 
@@ -159,6 +166,8 @@ class RDoc::Markup::PreProcess
       if RDoc::Context === code_object then
         section = code_object.add_section param
         code_object.temporary_section = section
+      elsif RDoc::AnyMethod === code_object then
+        code_object.section_title = param
       end
 
       blankline # ignore category if we're not on an RDoc::Context
@@ -174,10 +183,18 @@ class RDoc::Markup::PreProcess
 
       blankline
     when 'include' then
-      filename = param.split.first
+      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
@@ -208,17 +225,26 @@ class RDoc::Markup::PreProcess
     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
       # remove parameter &block
-      code_object.params.sub!(/,?\s*&\w+/, '') if code_object.params
+      code_object.params = code_object.params.sub(/,?\s*&\w+/, '') if code_object.params
 
-      code_object.block_params = param
+      code_object.block_params = param || ''
 
       blankline
     else
-      result = yield directive, param if block_given?
+      result = yield directive, param, line if block_given?
 
       case result
       when nil then
@@ -262,6 +288,7 @@ class RDoc::Markup::PreProcess
     end
 
     content = RDoc::Encoding.read_file full_name, encoding, true
+    content = RDoc::Encoding.remove_magic_comment content
 
     # strip magic comment
     content = content.sub(/\A# .*coding[=:].*$/, '').lstrip

data/lib/rdoc/markup/raw.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A section of text that is added to the output document as-is
 
@@ -67,4 +67,3 @@ class RDoc::Markup::Raw
   end
 
 end
-

data/lib/rdoc/markup/regexp_handling.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+##
+# Hold details of a regexp handling sequence
+
+class RDoc::Markup::RegexpHandling
+
+  ##
+  # Regexp handling type
+
+  attr_reader   :type
+
+  ##
+  # Regexp handling text
+
+  attr_accessor :text
+
+  ##
+  # Creates a new regexp handling sequence of +type+ with +text+
+
+  def initialize(type, text)
+    @type, @text = type, text
+  end
+
+  ##
+  # Regexp handlings are equal when the have the same text and type
+
+  def ==(o)
+    self.text == o.text && self.type == o.type
+  end
+
+  def inspect # :nodoc:
+    "#<RDoc::Markup::RegexpHandling:0x%x @type=%p, @text=%p>" % [
+      object_id, @type, text.dump]
+  end
+
+  def to_s # :nodoc:
+    "RegexpHandling: type=#{type} text=#{text.dump}"
+  end
+
+end

data/lib/rdoc/markup/rule.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A horizontal rule with a weight
 
@@ -18,4 +18,3 @@ class RDoc::Markup::Rule < Struct.new :weight
   end
 
 end
-

data/lib/rdoc/markup/table.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+##
+# A section of table
+
+class RDoc::Markup::Table
+  # headers of each column
+  attr_accessor :header
+
+  # alignments of each column
+  attr_accessor :align
+
+  # body texts of each column
+  attr_accessor :body
+
+  # Creates new instance
+  def initialize header, align, body
+    @header, @align, @body = header, align, body
+  end
+
+  # :stopdoc:
+  def == other
+    self.class == other.class and
+      @header == other.header and
+      @align == other.align and
+      @body == other.body
+  end
+
+  def accept visitor
+    visitor.accept_table @header, @body, @align
+  end
+
+  def pretty_print q
+    q.group 2, '[Table: ', ']' do
+      q.group 2, '[Head: ', ']' do
+        q.seplist @header.zip(@align) do |text, align|
+          q.pp text
+          if align
+            q.text ":"
+            q.breakable
+            q.text align.to_s
+          end
+        end
+      end
+      q.breakable
+      q.group 2, '[Body: ', ']' do
+        q.seplist @body do |body|
+          q.group 2, '[', ']' do
+            q.seplist body do |text|
+              q.pp text
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdoc/markup/to_ansi.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # Outputs RDoc markup with vibrant ANSI color!
 
@@ -91,4 +91,3 @@ class RDoc::Markup::ToAnsi < RDoc::Markup::ToRdoc
   end
 
 end
-

data/lib/rdoc/markup/to_bs.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # Outputs RDoc markup with hot backspace action!  You will probably need a
 # pager to use this output format.
@@ -24,7 +24,7 @@ class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
   def init_tags
     add_tag :BOLD, '+b', '-b'
     add_tag :EM,   '+_', '-_'
-    add_tag :TT,   ''  , ''   # we need in_tt information maintained
+    add_tag :TT,   '', ''   # we need in_tt information maintained
   end
 
   ##
@@ -41,7 +41,32 @@ class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
   end
 
   ##
-  # Turns on or off special handling for +convert_string+
+  # Prepares the visitor for consuming +list_item+
+
+  def accept_list_item_start list_item
+    type = @list_type.last
+
+    case type
+    when :NOTE, :LABEL then
+      bullets = Array(list_item.label).map do |label|
+        attributes(label).strip
+      end.join "\n"
+
+      bullets << ":\n" unless bullets.empty?
+
+      @prefix = ' ' * @indent
+      @indent += 2
+      @prefix << bullets + (' ' * @indent)
+    else
+      bullet = type == :BULLET ? '*' :  @list_index.last.to_s + '.'
+      @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
+      width = bullet.length + 1
+      @indent += width
+    end
+  end
+
+  ##
+  # Turns on or off regexp handling for +convert_string+
 
   def annotate tag
     case tag
@@ -54,9 +79,9 @@ class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
   end
 
   ##
-  # Calls convert_string on the result of convert_special
+  # Calls convert_string on the result of convert_regexp_handling
 
-  def convert_special special
+  def convert_regexp_handling target
     convert_string super
   end