FM / rdoc

/opt/cpanel/ea-ruby27/root/usr/share/ruby/ruby-2.7.8/rdoc/

/opt/cpanel/ea-ruby27/root/usr/share/ruby/ruby-2.7.8/rdoc

Name	Size	Mode	Actions
context/	-	0755	rm
generator/	-	0755	rm
i18n/	-	0755	rm
markdown/	-	0755	rm
markup/	-	0755	rm
parser/	-	0755	rm
rd/	-	0755	rm
ri/	-	0755	rm
stats/	-	0755	rm
alias.rb	2173	0644	edit dl rm
anon_class.rb	172	0644	edit dl rm
any_method.rb	7206	0644	edit dl rm
attr.rb	3849	0644	edit dl rm
class_module.rb	20292	0644	edit dl rm
code_object.rb	9483	0644	edit dl rm
code_objects.rb	151	0644	edit dl rm
comment.rb	5874	0644	edit dl rm
constant.rb	3677	0644	edit dl rm
context.rb	30816	0644	edit dl rm
cross_reference.rb	6678	0644	edit dl rm
encoding.rb	3838	0644	edit dl rm
erbio.rb	934	0644	edit dl rm
erb_partial.rb	400	0644	edit dl rm
extend.rb	170	0644	edit dl rm
generator.rb	1837	0644	edit dl rm
ghost_method.rb	144	0644	edit dl rm
i18n.rb	170	0644	edit dl rm
include.rb	172	0644	edit dl rm
known_classes.rb	2685	0644	edit dl rm
markdown.rb	386117	0644	edit dl rm
markup.rb	28755	0644	edit dl rm
meta_method.rb	129	0644	edit dl rm
method_attr.rb	9251	0644	edit dl rm
mixin.rb	2818	0644	edit dl rm
normal_class.rb	2183	0644	edit dl rm
normal_module.rb	1467	0644	edit dl rm
options.rb	31601	0644	edit dl rm
parser.rb	7219	0644	edit dl rm
rd.rb	3653	0644	edit dl rm
rdoc.rb	13866	0644	edit dl rm
require.rb	965	0644	edit dl rm
ri.rb	345	0644	edit dl rm
rubygems_hook.rb	5265	0644	edit dl rm
servlet.rb	12401	0644	edit dl rm
single_class.rb	408	0644	edit dl rm
stats.rb	10729	0644	edit dl rm
store.rb	22976	0644	edit dl rm
task.rb	7856	0644	edit dl rm
text.rb	7577	0644	edit dl rm
token_stream.rb	3232	0644	edit dl rm
tom_doc.rb	6614	0644	edit dl rm
top_level.rb	5677	0644	edit dl rm
version.rb	77	0644	edit dl rm

Edit: /opt/cpanel/ea-ruby27/root/usr/share/ruby/ruby-2.7.8/rdoc/text.rb (7577B)

# frozen_string_literal: true

##
# For RDoc::Text#to_html

require 'strscan'

##
# Methods for manipulating comment text

module RDoc::Text

attr_accessor :language

##
  # Maps markup formats to classes that can parse them.  If the format is
  # unknown, "rdoc" format is used.

MARKUP_FORMAT = {
    'markdown' => RDoc::Markdown,
    'rdoc'     => RDoc::Markup,
    'rd'       => RDoc::RD,
    'tomdoc'   => RDoc::TomDoc,
  }

MARKUP_FORMAT.default = RDoc::Markup

##
  # Maps an encoding to a Hash of characters properly transcoded for that
  # encoding.
  #
  # See also encode_fallback.

TO_HTML_CHARACTERS = Hash.new do |h, encoding|
    h[encoding] = {
      :close_dquote => encode_fallback('”', encoding, '"'),
      :close_squote => encode_fallback('’', encoding, '\''),
      :copyright    => encode_fallback('©', encoding, '(c)'),
      :ellipsis     => encode_fallback('…', encoding, '...'),
      :em_dash      => encode_fallback('—', encoding, '---'),
      :en_dash      => encode_fallback('–', encoding, '--'),
      :open_dquote  => encode_fallback('“', encoding, '"'),
      :open_squote  => encode_fallback('‘', encoding, '\''),
      :trademark    => encode_fallback('®', encoding, '(r)'),
    }
  end

##
  # Transcodes +character+ to +encoding+ with a +fallback+ character.

def self.encode_fallback character, encoding, fallback
    character.encode(encoding, :fallback => { character => fallback },
                     :undef => :replace, :replace => fallback)
  end

##
  # Expands tab characters in +text+ to eight spaces

def expand_tabs text
    expanded = []

text.each_line do |line|
      nil while line.gsub!(/(?:\G|\r)((?:.{8})*?)([^\t\r\n]{0,7})\t/) do
        r = "#{$1}#{$2}#{' ' * (8 - $2.size)}"
        r = RDoc::Encoding.change_encoding r, text.encoding
        r
      end

expanded << line
    end

expanded.join
  end

##
  # Flush +text+ left based on the shortest line

def flush_left text
    indent = 9999

text.each_line do |line|
      line_indent = line =~ /\S/ || 9999
      indent = line_indent if indent > line_indent
    end

empty = ''
    empty = RDoc::Encoding.change_encoding empty, text.encoding

text.gsub(/^ {0,#{indent}}/, empty)
  end

##
  # Convert a string in markup format into HTML.
  #
  # Requires the including class to implement #formatter

def markup text
    if @store.rdoc.options
      locale = @store.rdoc.options.locale
    else
      locale = nil
    end
    if locale
      i18n_text = RDoc::I18n::Text.new(text)
      text = i18n_text.translate(locale)
    end
    parse(text).accept formatter
  end

##
  # Strips hashes, expands tabs then flushes +text+ to the left

def normalize_comment text
    return text if text.empty?

case language
    when :ruby
      text = strip_hashes text
    when :c
      text = strip_stars text
    end
    text = expand_tabs    text
    text = flush_left     text
    text = strip_newlines text
    text
  end

##
  # Normalizes +text+ then builds a RDoc::Markup::Document from it

def parse text, format = 'rdoc'
    return text if RDoc::Markup::Document === text
    return text.parse if RDoc::Comment === text

text = normalize_comment text # TODO remove, should not be necessary

return RDoc::Markup::Document.new if text =~ /\A\n*\z/

MARKUP_FORMAT[format].parse text
  end

##
  # The first +limit+ characters of +text+ as HTML

def snippet text, limit = 100
    document = parse text

RDoc::Markup::ToHtmlSnippet.new(options, limit).convert document
  end

##
  # Strips leading # characters from +text+

def strip_hashes text
    return text if text =~ /^(?>\s*)[^\#]/

empty = ''
    empty = RDoc::Encoding.change_encoding empty, text.encoding

text.gsub(/^\s*(#+)/) { $1.tr '#', ' ' }.gsub(/^\s+$/, empty)
  end

##
  # Strips leading and trailing \n characters from +text+

def strip_newlines text
    text.gsub(/\A\n*(.*?)\n*\z/m) do $1 end # block preserves String encoding
  end

##
  # Strips /* */ style comments

def strip_stars text
    return text unless text =~ %r%/\*.*\*/%m

encoding = text.encoding

text = text.gsub %r%Document-method:\s+[\w:.#=!?|^&<>~+\-/*\%@`\[\]]+%, ''

space = ' '
    space = RDoc::Encoding.change_encoding space, encoding if encoding

text.sub!  %r%/\*+%       do space * $&.length end
    text.sub!  %r%\*+/%       do space * $&.length end
    text.gsub! %r%^[ \t]*\*%m do space * $&.length end

empty = ''
    empty = RDoc::Encoding.change_encoding empty, encoding if encoding
    text.gsub(/^\s+$/, empty)
  end

##
  # Converts ampersand, dashes, ellipsis, quotes, copyright and registered
  # trademark symbols in +text+ to properly encoded characters.

def to_html text
    html = (''.encode text.encoding).dup

encoded = RDoc::Text::TO_HTML_CHARACTERS[text.encoding]

s = StringScanner.new text
    insquotes = false
    indquotes = false
    after_word = nil

until s.eos? do
      case
      when s.scan(/<(tt|code)>.*?<\/\1>/) then # skip contents of tt
        html << s.matched.gsub('\\\\', '\\')
      when s.scan(/<(tt|code)>.*?/) then
        warn "mismatched <#{s[1]}> tag" # TODO signal file/line
        html << s.matched
      when s.scan(/<[^>]+\/?s*>/) then # skip HTML tags
        html << s.matched
      when s.scan(/\$\S)/) then # unhandled suppressed crossref
        html << s[1]
        after_word = nil
      when s.scan(/\.\.\.(\.?)/) then
        html << s[1] << encoded[:ellipsis]
        after_word = nil
      when s.scan(/\(c$/) then
        html << encoded[:copyright]
        after_word = nil
      when s.scan(/$r$/) then
        html << encoded[:trademark]
        after_word = nil
      when s.scan(/---/) then
        html << encoded[:em_dash]
        after_word = nil
      when s.scan(/--/) then
        html << encoded[:en_dash]
        after_word = nil
      when s.scan(/&quot;|"/) then
        html << encoded[indquotes ? :close_dquote : :open_dquote]
        indquotes = !indquotes
        after_word = nil
      when s.scan(/``/) then # backtick double quote
        html << encoded[:open_dquote]
        after_word = nil
      when s.scan(/''/) then # tick double quote
        html << encoded[:close_dquote]
        after_word = nil
      when s.scan(/'/) then # single quote
        if insquotes
          html << encoded[:close_squote]
          insquotes = false
        elsif after_word
          # Mary's dog, my parents' house: do not start paired quotes
          html << encoded[:close_squote]
        else
          html << encoded[:open_squote]
          insquotes = true
        end

after_word = nil
      else # advance to the next potentially significant character
        match = s.scan(/.+?(?=[<\\.("'`&-])/) #"

if match then
          html << match
          after_word = match =~ /\w$/
        else
          html << s.rest
          break
        end
      end
    end

html
  end

##
  # Wraps +txt+ to +line_len+

def wrap(txt, line_len = 76)
    res = []
    sp = 0
    ep = txt.length

while sp < ep
      # scan back for a space
      p = sp + line_len - 1
      if p >= ep
        p = ep
      else
        while p > sp and txt[p] != ?\s
          p -= 1
        end
        if p <= sp
          p = sp + line_len
          while p < ep and txt[p] != ?\s
            p += 1
          end
        end
      end
      res << txt[sp...p] << "\n"
      sp = p
      sp += 1 while sp < ep and txt[sp] == ?\s
    end

res.join.strip
  end

end

cmd: