# class RDoc::Comment

A comment holds the text comment for a `RDoc::CodeObject` and provides a unified way of cleaning it up and parsing it into an RDoc::Markup::Document.

Each comment may have a different markup format set by `format=`. By default ‘rdoc’ is used. The :markup: directive tells `RDoc` which format to use.

See Directive for Specifying RDoc Source Format at `RDoc::MarkupReference`.

### Attributes

document [W]

Overrides the content returned by `parse`. Use when there is no `text` source for this comment

format [R]

The format of this comment. Defaults to `RDoc::Markup`

line [RW]

Line where this `Comment` was written

location [RW]

The RDoc::TopLevel this comment was found in

text [R]

The text for this comment

to_s [R]

The text for this comment

### Public Class Methods

new (text = nil, location = nil, language = nil)
Source

    # File lib/rdoc/comment.rb, line 56
    def initialize text = nil, location = nil, language = nil
      @location = location
      @text     = text.nil? ? nil : text.dup
      @language = language

      @document   = nil
      @format     = 'rdoc'
      @normalized = false
    end

Creates a new comment with `text` that is found in the RDoc::TopLevel `location`.

### Public Instance Methods

empty? ()
Source

    # File lib/rdoc/comment.rb, line 128
    def empty?
      @text.empty?
    end

A comment is empty if its text `String` is empty.

encode! (encoding)
Source

    # File lib/rdoc/comment.rb, line 135
    def encode! encoding
      @text = String.new @text, encoding: encoding
      self
    end

HACK dubious

extract_call_seq (method)
Source

    # File lib/rdoc/comment.rb, line 95
    def extract_call_seq method
      # we must handle situations like the above followed by an unindented first
      # comment.  The difficulty is to make sure not to match lines starting
      # with ARGF at the same indent, but that are after the first description
      # paragraph.
      if /^(?<S> ((?!\n)\s)*+        (?# whitespaces except newline))
           :?call-seq:
             (?<B> \g<S>(?<N>\n|\z)  (?# trailing spaces))?
           (?<seq>
             (\g<S>(?!\w)\S.*\g<N>)*
             (?>
               (?<H> \g<S>\w+        (?# ' #   ARGF' in the example above))
               .*\g<N>)?
             (\g<S>\S.*\g<N>         (?# other non-blank line))*+
             (\g<B>+(\k<H>.*\g<N>    (?# ARGF.to_a lines))++)*+
           )
           (?m:^\s*$|\z)
          /x =~ @text
        seq = $~[:seq]

        all_start, all_stop = $~.offset(0)
        @text.slice! all_start...all_stop

        seq.gsub!(/^\s*/, '')
        method.call_seq = seq
      end

      method
    end

Look for a ‘call-seq’ in the comment to override the normal parameter handling. The :call-seq: is indented from the baseline. All lines of the same indentation level and prefix are consumed.

For example, all of the following will be used as the :call-seq:

    # :call-seq:
    #   ARGF.readlines(sep=$/)     -> array
    #   ARGF.readlines(limit)      -> array
    #   ARGF.readlines(sep, limit) -> array
    #
    #   ARGF.to_a(sep=$/)     -> array
    #   ARGF.to_a(limit)      -> array
    #   ARGF.to_a(sep, limit) -> array

format= (format)
Source

    # File lib/rdoc/comment.rb, line 143
    def format= format
      @format = format
      @document = nil
    end

Sets the format of this comment and resets any parsed document

normalize ()
Source

    # File lib/rdoc/comment.rb, line 157
    def normalize
      return self unless @text
      return self if @normalized # TODO eliminate duplicate normalization

      @text = normalize_comment @text

      @normalized = true

      self
    end

Normalizes the text. See `RDoc::Text#normalize_comment` for details

parse ()
Source

    # File lib/rdoc/comment.rb, line 179
    def parse
      return @document if @document

      @document = super @text, @format
      @document.file = @location
      @document
    end

Parses the comment into an RDoc::Markup::Document. The parsed document is cached until the text is changed.

Calls superclass method `RDoc::Text#parse`
remove_private ()
Source

    # File lib/rdoc/comment.rb, line 200
    def remove_private
      # Workaround for gsub encoding for Ruby 1.9.2 and earlier
      empty = ''
      empty = RDoc::Encoding.change_encoding empty, @text.encoding

      @text = @text.gsub(%r%^\s*([#*]?)--.*?^\s*(\1)\+\+\n?%m, empty)
      @text = @text.sub(%r%^\s*[#*]?--.*%m, '')
    end

Removes private sections from this comment. Private sections are flush to the comment marker and start with `--` and end with `++`. For C-style comments, a private marker may not start at the opening of the comment.

    /*
     *--
     * private
     *++
     * public
     */

text= (text)
Source

    # File lib/rdoc/comment.rb, line 214
    def text= text
      raise RDoc::Error, 'replacing document-only comment is not allowed' if
        @text.nil? and @document

      @document = nil
      @text = text.nil? ? nil : text.dup
    end

Replaces this comment’s text with `text` and resets the parsed document.

An error is raised if the comment contains a document but no text.

tomdoc? ()
Source

    # File lib/rdoc/comment.rb, line 225
    def tomdoc?
      @format == 'tomdoc'
    end

Returns true if this comment is in TomDoc format.