File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby40/share/gems/gems/rdoc-7.0.4/lib/rdoc

opt / alt / ruby40 / share / gems / gems / rdoc-7.0.4 / lib / rdoc /

?? ..
?? code_object
?? code_object.rb(8.76 KB)
?? code_objects.rb(162 B)
?? comment.rb(11.92 KB)
?? cross_reference.rb(7.12 KB)
?? encoding.rb(3.38 KB)
?? erb_partial.rb(401 B)
?? erbio.rb(855 B)
?? generator
?? generator.rb(1.87 KB)
?? i18n
?? i18n.rb(180 B)
?? known_classes.rb(2.69 KB)
?? markdown
?? markdown.kpeg(37.01 KB)
?? markdown.rb(386.33 KB)
?? markup
?? markup.rb(7.91 KB)
?? options.rb(36.91 KB)
?? parser
?? parser.rb(7.56 KB)
?? rd
?? rd.rb(3.58 KB)
?? rdoc.rb(13.57 KB)
?? ri
?? ri.rb(374 B)
?? rubygems_hook.rb(7.44 KB)
?? servlet.rb(12.42 KB)
?? stats
?? stats.rb(10.51 KB)
?? store.rb(23.01 KB)
?? task.rb(8.38 KB)
?? text.rb(7.88 KB)
?? token_stream.rb(3.4 KB)
?? tom_doc.rb(6.34 KB)
?? version.rb(106 B)

Editing: comment.rb

# frozen_string_literal: true
##
# 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 RDoc::MarkupReference@Directive+for+Specifying+RDoc+Source+Format.

class RDoc::Comment

include RDoc::Text

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

attr_reader :format

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

attr_accessor :location

##
  # Line where this Comment was written

attr_accessor :line

##
  # For duck-typing when merging classes at load time

alias file location # :nodoc:

##
  # The text for this comment

attr_reader :text

##
  # Alias for text

alias to_s text

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

attr_writer   :document

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

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

##
  #--
  # TODO deep copy @document

def initialize_copy(copy) # :nodoc:
    @text = copy.text.dup
  end

def ==(other) # :nodoc:
    self.class === other and
      other.text == @text and other.location == @location
  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

def extract_call_seq
    # 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*/, '')
    end
  end

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

def empty?
    @text.empty? && (@document.nil? || @document.empty?)
  end

##
  # HACK dubious

def encode!(encoding)
    @text = String.new @text, encoding: encoding
    self
  end

##
  # Sets the format of this comment and resets any parsed document

def format=(format)
    @format = format
    @document = nil
  end

def inspect # :nodoc:
    location = @location ? @location.relative_name : '(unknown)'

"#<%s:%x %s %p>" % [self.class, object_id, location, @text]
  end

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

def normalize
    return self unless @text
    return self if @normalized # TODO eliminate duplicate normalization

@text = normalize_comment @text

@normalized = true

self
  end

# Change normalized, when creating already normalized comment.

def normalized=(value)
    @normalized = value
  end

##
  # Was this text normalized?

def normalized? # :nodoc:
    @normalized
  end

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

def parse
    return @document if @document

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

##
  # Removes private sections from this comment.  Private sections are flush to
  # the comment marker and start with <tt>--</tt> and end with <tt>++</tt>.
  # For C-style comments, a private marker may not start at the opening of the
  # comment.
  #
  #   /*
  #    *--
  #    * private
  #    *++
  #    * public
  #    */

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

##
  # 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.

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

##
  # Returns true if this comment is in TomDoc format.

def tomdoc?
    @format == 'tomdoc'
  end

MULTILINE_DIRECTIVES = %w[call-seq].freeze # :nodoc:

# There are more, but already handled by RDoc::Parser::C
  COLON_LESS_DIRECTIVES = %w[call-seq Document-method].freeze # :nodoc:

DIRECTIVE_OR_ESCAPED_DIRECTIV_REGEXP = /\A(?<colon>\\?:|:?)(?<directive>[\w-]+):(?<param>.*)/

private_constant :MULTILINE_DIRECTIVES, :COLON_LESS_DIRECTIVES, :DIRECTIVE_OR_ESCAPED_DIRECTIV_REGEXP

class << self

##
    # Create a new parsed comment from a document

def from_document(document) # :nodoc:
      comment = RDoc::Comment.new('')
      comment.document = document
      comment.location = RDoc::TopLevel.new(document.file) if document.file
      comment
    end

# Parse comment, collect directives as an attribute and return [normalized_comment_text, directives_hash]
    # This method expands include and removes everything not needed in the document text, such as
    # private section, directive line, comment characters `# /* * */` and indent spaces.
    #
    # RDoc comment consists of include, directive, multiline directive, private section and comment text.
    #
    # Include
    #   # :include: filename
    #
    # Directive
    #   # :directive-without-value:
    #   # :directive-with-value: value
    #
    # Multiline directive (only :call-seq:)
    #   # :multiline-directive:
    #   #   value1
    #   #   value2
    #
    # Private section
    #   #--
    #   # private comment
    #   #++

def parse(text, filename, line_no, type, &include_callback)
      case type
      when :ruby
        text = text.gsub(/^#+/, '') if text.start_with?('#')
        private_start_regexp = /^-{2,}$/
        private_end_regexp = /^\+{2}$/
        indent_regexp = /^\s*/
      when :c
        private_start_regexp = /^(\s*\*)?-{2,}$/
        private_end_regexp = /^(\s*\*)?\+{2}$/
        indent_regexp = /^\s*(\/\*+|\*)?\s*/
        text = text.gsub(/\s*\*+\/\s*\z/, '')
      when :simple
        # Unlike other types, this implementation only looks for two dashes at
        # the beginning of the line. Three or more dashes are considered to be
        # a rule and ignored.
        private_start_regexp = /^-{2}$/
        private_end_regexp = /^\+{2}$/
        indent_regexp = /^\s*/
      end

directives = {}
      lines = text.split("\n")
      in_private = false
      comment_lines = []
      until lines.empty?
        line = lines.shift
        read_lines = 1
        if in_private
          # If `++` appears in a private section that starts with `--`, private section ends.
          in_private = false if line.match?(private_end_regexp)
          line_no += read_lines
          next
        elsif line.match?(private_start_regexp)
          # If `--` appears in a line, private section starts.
          in_private = true
          line_no += read_lines
          next
        end

prefix = line[indent_regexp]
        prefix_indent = ' ' * prefix.size
        line = line.byteslice(prefix.bytesize..)

if (directive_match = DIRECTIVE_OR_ESCAPED_DIRECTIV_REGEXP.match(line))
          colon = directive_match[:colon]
          directive = directive_match[:directive]
          raw_param = directive_match[:param]
          param = raw_param.strip
        else
          colon = directive = raw_param = param = nil
        end

if !directive
          comment_lines << prefix_indent + line
        elsif colon == '\\:'
          # If directive is escaped, unescape it
          comment_lines << prefix_indent + line.sub('\\:', ':')
        elsif raw_param.start_with?(':') || (colon.empty? && !COLON_LESS_DIRECTIVES.include?(directive))
          # Something like `:toto::` is not a directive
          # Only few directives allows to start without a colon
          comment_lines << prefix_indent + line
        elsif directive == 'include'
          filename_to_include = param
          include_callback.call(filename_to_include, prefix_indent).lines.each { |l| comment_lines << l.chomp }
        elsif MULTILINE_DIRECTIVES.include?(directive)
          value_lines = take_multiline_directive_value_lines(directive, filename, line_no, lines, prefix_indent.size, indent_regexp, !param.empty?)
          read_lines += value_lines.size
          lines.shift(value_lines.size)
          unless param.empty?
            # Accept `:call-seq: first-line\n  second-line` for now
            value_lines.unshift(param)
          end
          value = value_lines.join("\n")
          directives[directive] = [value.empty? ? nil : value, line_no]
        else
          directives[directive] = [param.empty? ? nil : param, line_no]
        end
        line_no += read_lines
      end

normalized_comment = String.new(encoding: text.encoding) << normalize_comment_lines(comment_lines).join("\n")
      [normalized_comment, directives]
    end

# Remove preceding indent spaces and blank lines from the comment lines

private def normalize_comment_lines(lines)
      blank_line_regexp = /\A\s*\z/
      lines = lines.dup
      lines.shift while lines.first&.match?(blank_line_regexp)
      lines.pop while lines.last&.match?(blank_line_regexp)

min_spaces = lines.map do |l|
        l.match(/\A *(?=\S)/)&.end(0)
      end.compact.min
      if min_spaces && min_spaces > 0
        lines.map { |l| l[min_spaces..] || '' }
      else
        lines
      end
    end

# Take value lines of multiline directive

private def take_multiline_directive_value_lines(directive, filename, line_no, lines, base_indent_size, indent_regexp, has_param)
      return [] if lines.empty?

first_indent_size = lines.first.match(indent_regexp).end(0)

# Blank line or unindented line is not part of multiline-directive value
      return [] if first_indent_size <= base_indent_size

if has_param
        # :multiline-directive: line1
        #   line2
        #   line3
        #
        value_lines = lines.take_while do |l|
          l.rstrip.match(indent_regexp).end(0) > base_indent_size
        end
        min_indent = value_lines.map { |l| l.match(indent_regexp).end(0) }.min
        value_lines.map { |l| l[min_indent..] }
      else
        # Take indented lines accepting blank lines between them
        value_lines = lines.take_while do |l|
          l = l.rstrip
          indent = l[indent_regexp]
          if indent == l || indent.size >= first_indent_size
            true
          end
        end
        value_lines.map! { |l| (l[first_indent_size..] || '').chomp }

if value_lines.size != lines.size && !value_lines.last.empty?
          warn "#{filename}:#{line_no} Multiline directive :#{directive}: should end with a blank line."
        end
        value_lines.pop while value_lines.last&.empty?
        value_lines
      end
    end
  end
end

X7ROOT File Manager

Editing: comment.rb

Upload File

Create Folder