Class: RDoc::Comment (Ruby 2.5.7)
Description: Class : RDoc::Comment - Ruby 2.5.7

### Home Classes Methods

### In Files

- rdoc/comment.rb

### Parent

Object

### Methods

- ::new
- #empty?
- #encode!
- #extract_call_seq
- #format=
- #normalize
- #parse
- #remove_private
- #text=
- #tomdoc?

### Included Modules

- RDoc::Text

### Class/Module Index

Quicksearch

- RDoc
- RDoc::Alias
- RDoc::AnonClass
- RDoc::AnyMethod
- RDoc::Attr
- RDoc::ClassModule
- RDoc::CodeObject
- RDoc::Comment
- RDoc::Constant
- RDoc::Context
- RDoc::Context::Section
- RDoc::CrossReference
- RDoc::ERBIO
- RDoc::ERBPartial
- RDoc::Encoding
- RDoc::Error
- RDoc::Extend
- RDoc::Generator
- RDoc::Generator::Darkfish
- RDoc::Generator::JsonIndex
- RDoc::Generator::Markup
- RDoc::Generator::POT
- RDoc::Generator::POT::MessageExtractor
- RDoc::Generator::POT::PO
- RDoc::Generator::POT::POEntry
- RDoc::Generator::RI
- RDoc::GhostMethod
- RDoc::I18n
- RDoc::I18n::Locale
- RDoc::I18n::Text
- RDoc::Include
- RDoc::Markdown
- RDoc::Markdown::Literals
- RDoc::Markup
- RDoc::Markup::AttrChanger
- RDoc::Markup::AttrSpan
- RDoc::Markup::AttributeManager
- RDoc::Markup::Attributes
- RDoc::Markup::BlankLine
- RDoc::Markup::BlockQuote
- RDoc::Markup::Document
- RDoc::Markup::Formatter
- RDoc::Markup::FormatterTestCase
- RDoc::Markup::HardBreak
- RDoc::Markup::Include
- RDoc::Markup::IndentedParagraph
- RDoc::Markup::List
- RDoc::Markup::ListItem
- RDoc::Markup::Paragraph
- RDoc::Markup::Parser
- RDoc::Markup::Parser::Error
- RDoc::Markup::Parser::ParseError
- RDoc::Markup::PreProcess
- RDoc::Markup::Raw
- RDoc::Markup::Rule
- RDoc::Markup::Special
- RDoc::Markup::TextFormatterTestCase
- RDoc::Markup::ToAnsi
- RDoc::Markup::ToBs
- RDoc::Markup::ToHtml
- RDoc::Markup::ToHtmlCrossref
- RDoc::Markup::ToHtmlSnippet
- RDoc::Markup::ToJoinedParagraph
- RDoc::Markup::ToLabel
- RDoc::Markup::ToMarkdown
- RDoc::Markup::ToRdoc
- RDoc::Markup::ToTableOfContents
- RDoc::Markup::ToTest
- RDoc::Markup::ToTtOnly
- RDoc::Markup::Verbatim
- RDoc::MetaMethod
- RDoc::MethodAttr
- RDoc::Mixin
- RDoc::NormalClass
- RDoc::NormalModule
- RDoc::Options
- RDoc::Parser
- RDoc::Parser::C
- RDoc::Parser::ChangeLog
- RDoc::Parser::Markdown
- RDoc::Parser::RD
- RDoc::Parser::Ruby
- RDoc::Parser::RubyTools
- RDoc::Parser::Simple
- RDoc::Parser::Text
- RDoc::RD
- RDoc::RD::BlockParser
- RDoc::RD::Inline
- RDoc::RD::InlineParser
- RDoc::RDoc
- RDoc::RI
- RDoc::RI::Driver
- RDoc::RI::Driver::Error
- RDoc::RI::Driver::NotFoundError
- RDoc::RI::Error
- RDoc::RI::Paths
- RDoc::RI::Task
- RDoc::Require
- RDoc::RipperStateLex
- RDoc::RipperStateLex::InnerStateLex
- RDoc::RubygemsHook
- RDoc::Servlet
- RDoc::SingleClass
- RDoc::Stats
- RDoc::Stats::Normal
- RDoc::Stats::Quiet
- RDoc::Stats::Verbose
- RDoc::Store
- RDoc::Store::Error
- RDoc::Store::MissingFileError
- RDoc::Task
- RDoc::TestCase
- RDoc::Text
- RDoc::TokenStream
- RDoc::TomDoc
- RDoc::TopLevel
- RDocTask

No matching classes.

# 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 Other directives at `RDoc::Markup` for instructions on adding an alternate format.

### Attributes

document[W]

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

file[RW]

The `RDoc::TopLevel` this comment was found in

format[R]

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

location[RW]

The `RDoc::TopLevel` this comment was found in

text[R]

The text for this comment

### Public Class Methods

new(text = nil, location = nil) click to toggle source

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

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

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

### Public Instance Methods

empty?() click to toggle source

A comment is empty if its text String is empty.

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

encode!(encoding) click to toggle source

HACK dubious

                   # File rdoc/comment.rb, line 140
    def encode! encoding
      # TODO: Remove this condition after Ruby 2.2 EOL
      if RUBY_VERSION < '2.3.0'
        @text = @text.force_encoding encoding
      else
        @text = String.new @text, encoding: encoding
      end
      self
    end

extract_call_seq(method) click to toggle source

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

                   # File rdoc/comment.rb, line 84
    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 @text =~ /^\s*:?call-seq:(.*?(?:\S).*?)^\s*$/m then
        all_start, all_stop = $~.offset(0)
        seq_start, seq_stop = $~.offset(1)

        # we get the following lines that start with the leading word at the
        # same indent, even if they have blank lines before
        if $1 =~ /(^\s*\n)+^(\s*\w+)/m then
          leading = $2 # ' *    ARGF' in the example above
          re = %r%
            \A(
               (^\s*\n)+
               (^#{Regexp.escape leading}.*?\n)+
              )+
            ^\s*$
          %xm

          if @text[seq_stop..-1] =~ re then
            all_stop = seq_stop + $~.offset(0).last
            seq_stop = seq_stop + $~.offset(1).last
          end
        end

        seq = @text[seq_start..seq_stop]
        seq.gsub!(/^\s*(\S|\n)/m, '\1')
        @text.slice! all_start...all_stop

        method.call_seq = seq.chomp

      else
        regexp = /^\s*:?call-seq:(.*?)(^\s*$|\z)/m
        if regexp =~ @text then
          @text = @text.sub(regexp, '')
          seq = $1
          seq.gsub!(/^\s*/, '')
          method.call_seq = seq
        end
      end

      method
    end

format=(format) click to toggle source

Sets the format of this comment and resets any parsed document

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

normalize() click to toggle source

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

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

      @text = normalize_comment @text

      @normalized = true

      self
    end

parse() click to toggle source

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

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

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

remove_private() click to toggle source

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
     */

                   # File rdoc/comment.rb, line 210
    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

text=(text) click to toggle source

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.

                   # File rdoc/comment.rb, line 224
    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

tomdoc?() click to toggle source

Returns true if this comment is in TomDoc format.

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