rdoc 6.3.4.1 → 8.0.0

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
@@ -33,11 +33,11 @@ class RDoc::Markup::ListItem
   ##
   # Appends +part+ to the ListItem
 
-  def << part
+  def <<(part)
     @parts << part
   end
 
-  def == other # :nodoc:
+  def ==(other) # :nodoc:
     self.class == other.class and
       @label == other.label and
       @parts == other.parts
@@ -46,7 +46,7 @@ class RDoc::Markup::ListItem
   ##
   # Runs this list item and all its #parts through +visitor+
 
-  def accept visitor
+  def accept(visitor)
     visitor.accept_list_item_start self
 
     @parts.each do |part|
@@ -70,7 +70,7 @@ class RDoc::Markup::ListItem
     @parts.length
   end
 
-  def pretty_print q # :nodoc:
+  def pretty_print(q) # :nodoc:
     q.group 2, '[item: ', ']' do
       case @label
       when Array then
@@ -92,9 +92,8 @@ class RDoc::Markup::ListItem
   ##
   # Adds +parts+ to the ListItem
 
-  def push *parts
+  def push(*parts)
     @parts.concat parts
   end
 
 end
-

data/lib/rdoc/markup/paragraph.rb

@@ -7,7 +7,7 @@ class RDoc::Markup::Paragraph < RDoc::Markup::Raw
   ##
   # Calls #accept_paragraph on +visitor+
 
-  def accept visitor
+  def accept(visitor)
     visitor.accept_paragraph self
   end
 
@@ -15,7 +15,7 @@ class RDoc::Markup::Paragraph < RDoc::Markup::Raw
   # Joins the raw paragraph text and converts inline HardBreaks to the
   # +hard_break+ text.
 
-  def text hard_break = ''
+  def text(hard_break = '')
     @parts.map do |part|
       if RDoc::Markup::HardBreak === part then
         hard_break
@@ -26,4 +26,3 @@ class RDoc::Markup::Paragraph < RDoc::Markup::Raw
   end
 
 end
-

data/lib/rdoc/markup/parser.rb

@@ -11,7 +11,7 @@ require 'strscan'
 # The parser only handles the block-level constructs Paragraph, List,
 # ListItem, Heading, Verbatim, BlankLine, Rule and BlockQuote.
 # Inline markup such as <tt>\+blah\+</tt> is handled separately by
-# RDoc::Markup::AttributeManager.
+# RDoc::Markup::InlineParser.
 #
 # 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.
@@ -57,7 +57,7 @@ class RDoc::Markup::Parser
   #
   # Use RDoc::Markup#parse instead of this method.
 
-  def self.parse str
+  def self.parse(str)
     parser = new
     parser.tokenize str
     doc = RDoc::Markup::Document.new
@@ -67,7 +67,7 @@ class RDoc::Markup::Parser
   ##
   # Returns a token stream for +str+, for testing
 
-  def self.tokenize str
+  def self.tokenize(str)
     parser = new
     parser.tokenize str
     parser.tokens
@@ -87,7 +87,7 @@ class RDoc::Markup::Parser
   ##
   # Builds a Heading of +level+
 
-  def build_heading level
+  def build_heading(level)
     type, text, = get
 
     text = case type
@@ -105,7 +105,7 @@ class RDoc::Markup::Parser
   ##
   # Builds a List flush to +margin+
 
-  def build_list margin
+  def build_list(margin)
     p :list_start => margin if @debug
 
     list = RDoc::Markup::List.new
@@ -205,7 +205,7 @@ class RDoc::Markup::Parser
   ##
   # Builds a Paragraph that is flush to +margin+
 
-  def build_paragraph margin
+  def build_paragraph(margin)
     p :paragraph_start => margin if @debug
 
     paragraph = RDoc::Markup::Paragraph.new
@@ -218,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
@@ -240,7 +240,7 @@ class RDoc::Markup::Parser
   # terminated by a newline.  Blank lines always consist of a single newline
   # character, and there is never a single newline at the end of the verbatim.
 
-  def build_verbatim margin
+  def build_verbatim(margin)
     p :verbatim_begin => margin if @debug
     verbatim = RDoc::Markup::Verbatim.new
 
@@ -287,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
@@ -333,7 +339,7 @@ class RDoc::Markup::Parser
   #
   # Returns +parent+.
 
-  def parse parent, indent = 0
+  def parse(parent, indent = 0)
     p :parse_start => indent if @debug
 
     until @tokens.empty? do
@@ -372,11 +378,8 @@ class RDoc::Markup::Parser
         unget
         parse_text parent, indent
       when :BLOCKQUOTE then
-        type, _, column = get
-        if type == :NEWLINE
-          type, _, column = get
-        end
-        unget if type
+        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
@@ -400,7 +403,7 @@ class RDoc::Markup::Parser
   ##
   # Small hook that is overridden by RDoc::TomDoc
 
-  def parse_text parent, indent # :nodoc:
+  def parse_text(parent, indent) # :nodoc:
     parent << build_paragraph(indent)
   end
 
@@ -417,6 +420,8 @@ class RDoc::Markup::Parser
   # 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
@@ -453,12 +458,14 @@ class RDoc::Markup::Parser
     def [](i)
       @s[i]
     end
+
+    #:startdoc:
   end
 
   ##
   # Creates the StringScanner
 
-  def setup_scanner input
+  def setup_scanner(input)
     @s = MyStringScanner.new input
   end
 
@@ -467,7 +474,7 @@ class RDoc::Markup::Parser
   #
   # Optionally raises an error if the next token is not of the expected type.
 
-  def skip token_type, error = true
+  def skip(token_type, error = true)
     type, = get
     return unless type # end of stream
     return @current_token if token_type == type
@@ -478,7 +485,7 @@ class RDoc::Markup::Parser
   ##
   # Turns text +input+ into a stream of tokens
 
-  def tokenize input
+  def tokenize(input)
     setup_scanner input
 
     until @s.eos? do
@@ -544,7 +551,10 @@ class RDoc::Markup::Parser
                    [:NOTE, @s[1], *pos]
                  # >>> followed by end of line => :BLOCKQUOTE
                  when @s.scan(/>>> *(\w+)?$/) then
-                   [:BLOCKQUOTE, @s[1], *pos]
+                   if word = @s[1]
+                     @s.unscan(word)
+                   end
+                   [:BLOCKQUOTE, word, *pos]
                  # anything else: :TEXT
                  else
                    @s.scan(/(.*?)(  )?\r?$/)

data/lib/rdoc/markup/pre_process.rb

@@ -27,7 +27,7 @@ class RDoc::Markup::PreProcess
   # with the result RDoc::Comment (or text String) and the code object for the
   # comment (if any).
 
-  def self.post_process &block
+  def self.post_process(&block)
     @post_processors << block
   end
 
@@ -50,7 +50,7 @@ class RDoc::Markup::PreProcess
   #     # replace text, etc.
   #   end
 
-  def self.register directive, &block
+  def self.register(directive, &block)
     @registered[directive] = block
   end
 
@@ -96,7 +96,7 @@ class RDoc::Markup::PreProcess
   # directive's parameter is set as metadata on the +code_object+.  See
   # RDoc::CodeObject#metadata for details.
 
-  def handle text, code_object = nil, &block
+  def handle(text, code_object = nil, &block)
     if RDoc::Comment === text then
       comment = text
       text = text.text
@@ -105,7 +105,7 @@ class RDoc::Markup::PreProcess
     # regexp helper (square brackets for optional)
     # $1      $2  $3        $4      $5
     # [prefix][\]:directive:[spaces][param]newline
-    text = text.gsub(/^([ \t]*(?:#|\/?\*)?[ \t]*)(\\?):(\w+):([ \t]*)(.+)?(\r?\n|$)/) do
+    text = text.gsub(/^([ \t]*(?:#|\/?\*)?[ \t]*)(\\?):([\w-]+):([ \t]*)(.+)?(\r?\n|$)/) do
       # skip something like ':toto::'
       next $& if $4.empty? and $5 and $5[0, 1] == ':'
 
@@ -119,7 +119,6 @@ class RDoc::Markup::PreProcess
         comment.format = $5.downcase
         next "#{$1.strip}\n"
       end
-
       handle_directive $1, $3, $5, code_object, text.encoding, &block
     end
 
@@ -129,11 +128,39 @@ class RDoc::Markup::PreProcess
       comment = text
     end
 
+    run_post_processes(comment, code_object)
+
+    text
+  end
+
+  # Apply directives to a code object
+
+  def run_pre_processes(comment_text, code_object, start_line_no, type)
+    comment_text, directives = parse_comment(comment_text, start_line_no, type)
+    directives.each do |directive, (param, line_no)|
+      handle_directive('', directive, param, code_object)
+    end
+    if code_object.is_a?(RDoc::AnyMethod) && (call_seq, = directives['call-seq']) && call_seq
+      code_object.call_seq = call_seq.lines.map(&:chomp).reject(&:empty?).join("\n")
+    end
+    format, = directives['markup']
+    [comment_text, format]
+  end
+
+  # Perform post preocesses to a code object
+
+  def run_post_processes(comment, code_object)
     self.class.post_processors.each do |handler|
       handler.call comment, code_object
     end
+  end
 
-    text
+  # Parse comment and return [normalized_comment_text, directives_hash]
+
+  def parse_comment(text, line_no, type)
+    RDoc::Comment.parse(text, @input_file_name, line_no, type) do |filename, prefix_indent|
+      include_file(filename, prefix_indent, text.encoding)
+    end
   end
 
   ##
@@ -147,8 +174,8 @@ 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
+  def handle_directive(prefix, directive, param, code_object = nil,
+                       encoding = nil)
     blankline = "#{prefix.strip}\n"
     directive = directive.downcase
 
@@ -163,6 +190,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
@@ -180,10 +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
-
-      blankline
     when 'nodoc' then
       return blankline unless code_object
       code_object.document_self = nil # notify nodoc
@@ -208,17 +233,13 @@ class RDoc::Markup::PreProcess
 
       code_object.stop_doc
 
-      blankline
-    when 'title' then
-      @options.default_title = param if @options.respond_to? :default_title=
-
       blankline
     when 'yield', 'yields' then
       return blankline unless code_object
       # remove parameter &block
       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
@@ -257,7 +278,7 @@ class RDoc::Markup::PreProcess
   # TODO shift left the whole file content in that case
   # TODO comment stop/start #-- and #++ in included file must be processed here
 
-  def include_file name, indent, encoding
+  def include_file(name, indent, encoding)
     full_name = find_include_file name
 
     unless full_name then

data/lib/rdoc/markup/raw.rb

@@ -1,70 +1,66 @@
 # frozen_string_literal: true
-##
-# A section of text that is added to the output document as-is
 
-class RDoc::Markup::Raw
-
-  ##
-  # The component parts of the list
-
-  attr_reader :parts
-
-  ##
-  # Creates a new Raw containing +parts+
-
-  def initialize *parts
-    @parts = []
-    @parts.concat parts
-  end
-
-  ##
-  # Appends +text+
+module RDoc
+  class Markup
+    # A section of text that is added to the output document as-is
+    class Raw
+      # The component parts of the list
+      #: Array[String]
+      attr_reader :parts
+
+      # Creates a new Raw containing +parts+
+      #: (*String) -> void
+      def initialize(*parts)
+        @parts = parts
+      end
 
-  def << text
-    @parts << text
-  end
+      # Appends +text+
+      #: (String) -> void
+      def <<(text)
+        @parts << text
+      end
 
-  def == other # :nodoc:
-    self.class == other.class and @parts == other.parts
-  end
+      #: (top) -> bool
+      def ==(other) # :nodoc:
+        self.class == other.class && @parts == other.parts
+      end
 
-  ##
-  # Calls #accept_raw+ on +visitor+
+      # Calls #accept_raw+ on +visitor+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_raw(self)
+      end
 
-  def accept visitor
-    visitor.accept_raw self
-  end
+      # Appends +other+'s parts
+      #: (Raw) -> void
+      def merge(other)
+        @parts.concat(other.parts)
+      end
 
-  ##
-  # Appends +other+'s parts
+      # @override
+      #: (PP) -> void
+      def pretty_print(q) # :nodoc:
+        self.class.name =~ /.*::(\w{1,4})/i
 
-  def merge other
-    @parts.concat other.parts
-  end
+        q.group(2, "[#{$1.downcase}: ", ']') do
+          q.seplist(@parts) do |part|
+            q.pp(part)
+          end
+        end
+      end
 
-  def pretty_print q # :nodoc:
-    self.class.name =~ /.*::(\w{1,4})/i
+      # Appends +texts+ onto this Paragraph
+      #: (*String) -> void
+      def push(*texts)
+        self.parts.concat(texts)
+      end
 
-    q.group 2, "[#{$1.downcase}: ", ']' do
-      q.seplist @parts do |part|
-        q.pp part
+      # The raw text
+      #: () -> String
+      def text
+        @parts.join(" ")
       end
     end
   end
-
-  ##
-  # Appends +texts+ onto this Paragraph
-
-  def push *texts
-    self.parts.concat texts
-  end
-
-  ##
-  # The raw text
-
-  def text
-    @parts.join ' '
-  end
-
 end
-

data/lib/rdoc/markup/rule.rb

@@ -7,15 +7,14 @@ class RDoc::Markup::Rule < Struct.new :weight
   ##
   # Calls #accept_rule on +visitor+
 
-  def accept visitor
+  def accept(visitor)
     visitor.accept_rule self
   end
 
-  def pretty_print q # :nodoc:
+  def pretty_print(q) # :nodoc:
     q.group 2, '[rule:', ']' do
       q.pp weight
     end
   end
 
 end
-

data/lib/rdoc/markup/table.rb

@@ -1,43 +1,60 @@
 # frozen_string_literal: true
-##
-# A section of table
 
-class RDoc::Markup::Table
-  attr_accessor :header, :align, :body
+module RDoc
+  class Markup
+    # A section of table
+    class Table < Element
+      # Headers of each column
+      #: Array[String]
+      attr_accessor :header
 
-  def initialize header, align, body
-    @header, @align, @body = header, align, body
-  end
+      # Alignments of each column
+      #: Array[Symbol?]
+      attr_accessor :align
 
-  def == other
-    self.class == other.class and
-      @header == other.header and
-      @align == other.align and
-      @body == other.body
-  end
+      # Body texts of each column
+      #: Array[String]
+      attr_accessor :body
 
-  def accept visitor
-    visitor.accept_table @header, @body, @align
-  end
+      #: (Array[String], Array[Symbol?], Array[String]) -> void
+      def initialize(header, align, body)
+        @header, @align, @body = header, align, body
+      end
 
-  def pretty_print q # :nodoc:
-    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
+      #: (Object) -> bool
+      def ==(other)
+        self.class == other.class && @header == other.header &&
+          @align == other.align && @body == other.body
       end
-      q.breakable
-      q.group 2, '[Body: ', ']' do
-        q.seplist @body do |body|
-          q.group 2, '[', ']' do
-            q.seplist body do |text|
+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_table(@header, @body, @align)
+      end
+
+      # @override
+      #: (untyped) -> String
+      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