@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/rdoc/markup/pre_process.rb

@@ -1,318 +0,0 @@
-# frozen_string_literal: true
-##
-# Handle common directives that can occur in a block of text:
-#
-#   \:include: filename
-#
-# Directives can be escaped by preceding them with a backslash.
-#
-# RDoc plugin authors can register additional directives to be handled by
-# using RDoc::Markup::PreProcess::register.
-#
-# Any directive that is not built-in to RDoc (including those registered via
-# plugins) will be stored in the metadata hash on the CodeObject the comment
-# is attached to.  See RDoc::Markup@Directives for the list of built-in
-# directives.
-
-class RDoc::Markup::PreProcess
-
-  ##
-  # An RDoc::Options instance that will be filled in with overrides from
-  # directives
-
-  attr_accessor :options
-
-  ##
-  # Adds a post-process handler for directives.  The handler will be called
-  # with the result RDoc::Comment (or text String) and the code object for the
-  # comment (if any).
-
-  def self.post_process(&block)
-    @post_processors << block
-  end
-
-  ##
-  # Registered post-processors
-
-  def self.post_processors
-    @post_processors
-  end
-
-  ##
-  # Registers +directive+ as one handled by RDoc.  If a block is given the
-  # directive will be replaced by the result of the block, otherwise the
-  # directive will be removed from the processed text.
-  #
-  # The block will be called with the directive name and the directive
-  # parameter:
-  #
-  #   RDoc::Markup::PreProcess.register 'my-directive' do |directive, param|
-  #     # replace text, etc.
-  #   end
-
-  def self.register(directive, &block)
-    @registered[directive] = block
-  end
-
-  ##
-  # Registered directives
-
-  def self.registered
-    @registered
-  end
-
-  ##
-  # Clears all registered directives and post-processors
-
-  def self.reset
-    @post_processors = []
-    @registered = {}
-  end
-
-  reset
-
-  ##
-  # Creates a new pre-processor for +input_file_name+ that will look for
-  # included files in +include_path+
-
-  def initialize(input_file_name, include_path)
-    @input_file_name = input_file_name
-    @include_path = include_path
-    @options = nil
-  end
-
-  ##
-  # Look for directives in the given +text+.
-  #
-  # Options that we don't handle are yielded.  If the block returns false the
-  # directive is restored to the text.  If the block returns nil or no block
-  # was given the directive is handled according to the registered directives.
-  # If a String was returned the directive is replaced with the string.
-  #
-  # If no matching directive was registered the directive is restored to the
-  # text.
-  #
-  # If +code_object+ is given and the directive is unknown then the
-  # directive's parameter is set as metadata on the +code_object+.  See
-  # RDoc::CodeObject#metadata for details.
-
-  def handle(text, code_object = nil, &block)
-    first_line = 1
-    if RDoc::Comment === text then
-      comment = text
-      text = text.text
-      first_line = comment.line || 1
-    end
-
-    # regexp helper (square brackets for optional)
-    # $1      $2  $3        $4      $5
-    # [prefix][\]:directive:[spaces][param]newline
-    text = text.lines.map.with_index(first_line) do |line, num|
-      next line unless line =~ /\A([ \t]*(?:#|\/?\*)?[ \t]*)(\\?):([\w-]+):([ \t]*)(.+)?(\r?\n|$)/
-      # skip something like ':toto::'
-      next $& if $4.empty? and $5 and $5[0, 1] == ':'
-
-      # skip if escaped
-      next "#$1:#$3:#$4#$5\n" unless $2.empty?
-
-      # This is not in handle_directive because I didn't want to pass another
-      # argument into it
-      if comment and $3 == 'markup' then
-        next "#{$1.strip}\n" unless $5
-        comment.format = $5.downcase
-        next "#{$1.strip}\n"
-      end
-
-      handle_directive $1, $3, $5, code_object, text.encoding, num, &block
-    end.join
-
-    if comment then
-      comment.text = text
-    else
-      comment = text
-    end
-
-    self.class.post_processors.each do |handler|
-      handler.call comment, code_object
-    end
-
-    text
-  end
-
-  ##
-  # Performs the actions described by +directive+ and its parameter +param+.
-  #
-  # +code_object+ is used for directives that operate on a class or module.
-  # +prefix+ is used to ensure the replacement for handled directives is
-  # correct.  +encoding+ is used for the <tt>include</tt> directive.
-  #
-  # For a list of directives in RDoc see RDoc::Markup.
-  #--
-  # When 1.8.7 support is ditched prefix can be defaulted to ''
-
-  def handle_directive(prefix, directive, param, code_object = nil,
-                       encoding = nil, line = nil)
-    blankline = "#{prefix.strip}\n"
-    directive = directive.downcase
-
-    case directive
-    when 'arg', 'args' then
-      return "#{prefix}:#{directive}: #{param}\n" unless code_object && code_object.kind_of?(RDoc::AnyMethod)
-
-      code_object.params = param
-
-      blankline
-    when 'category' then
-      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
-    when 'doc' then
-      return blankline unless code_object
-      code_object.document_self = true
-      code_object.force_documentation = true
-
-      blankline
-    when 'enddoc' then
-      return blankline unless code_object
-      code_object.done_documenting = true
-
-      blankline
-    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
-      warn <<~MSG
-        The :main: directive is deprecated and will be removed in RDoc 7.
-
-        You can use these options to specify the initial page displayed instead:
-        - `--main=#{param}` via the command line
-        - `rdoc.main = "#{param}"` if you use `RDoc::Task`
-        - `main_page: #{param}` in your `.rdoc_options` file
-      MSG
-
-      blankline
-    when 'nodoc' then
-      return blankline unless code_object
-      code_object.document_self = nil # notify nodoc
-      code_object.document_children = param !~ /all/i
-
-      blankline
-    when 'notnew', 'not_new', 'not-new' then
-      return blankline unless RDoc::AnyMethod === code_object
-
-      code_object.dont_rename_initialize = true
-
-      blankline
-    when 'startdoc' then
-      return blankline unless code_object
-
-      code_object.start_doc
-      code_object.force_documentation = true
-
-      blankline
-    when 'stopdoc' then
-      return blankline unless code_object
-
-      code_object.stop_doc
-
-      blankline
-    when 'title' then
-      @options.default_title = param if @options.respond_to? :default_title=
-
-      warn <<~MSG
-        The :title: directive is deprecated and will be removed in RDoc 7.
-
-        You can use these options to specify the title displayed instead:
-        - `--title=#{param}` via the command line
-        - `rdoc.title = "#{param}"` if you use `RDoc::Task`
-        - `title: #{param}` in your `.rdoc_options` file
-      MSG
-
-      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 || ''
-
-      blankline
-    else
-      result = yield directive, param, line if block_given?
-
-      case result
-      when nil then
-        code_object.metadata[directive] = param if code_object
-
-        if RDoc::Markup::PreProcess.registered.include? directive then
-          handler = RDoc::Markup::PreProcess.registered[directive]
-          result = handler.call directive, param if handler
-        else
-          result = "#{prefix}:#{directive}: #{param}\n"
-        end
-      when false then
-        result = "#{prefix}:#{directive}: #{param}\n"
-      end
-
-      result
-    end
-  end
-
-  ##
-  # Handles the <tt>:include: _filename_</tt> directive.
-  #
-  # If the first line of the included file starts with '#', and contains
-  # an encoding information in the form 'coding:' or 'coding=', it is
-  # removed.
-  #
-  # If all lines in the included file start with a '#', this leading '#'
-  # is removed before inclusion. The included content is indented like
-  # the <tt>:include:</tt> directive.
-  #--
-  # so all content will be verbatim because of the likely space after '#'?
-  # 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)
-    full_name = find_include_file name
-
-    unless full_name then
-      warn "Couldn't find file to include '#{name}' from #{@input_file_name}"
-      return ''
-    end
-
-    content = RDoc::Encoding.read_file full_name, encoding, true
-    content = RDoc::Encoding.remove_magic_comment content
-
-    # strip magic comment
-    content = content.sub(/\A# .*coding[=:].*$/, '').lstrip
-
-    # strip leading '#'s, but only if all lines start with them
-    if content =~ /^[^#]/ then
-      content.gsub(/^/, indent)
-    else
-      content.gsub(/^#?/, indent)
-    end
-  end
-
-  ##
-  # Look for the given file in the directory containing the current file,
-  # and then in each of the directories specified in the RDOC_INCLUDE path
-
-  def find_include_file(name)
-    to_search = [File.dirname(@input_file_name)].concat @include_path
-    to_search.each do |dir|
-      full_name = File.join(dir, name)
-      stat = File.stat(full_name) rescue next
-      return full_name if stat.readable?
-    end
-    nil
-  end
-
-end

package/lib/ruby/3.4.11/rdoc/markup/raw.rb

@@ -1,69 +0,0 @@
-# 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+
-
-  def <<(text)
-    @parts << text
-  end
-
-  def ==(other) # :nodoc:
-    self.class == other.class and @parts == other.parts
-  end
-
-  ##
-  # Calls #accept_raw+ on +visitor+
-
-  def accept(visitor)
-    visitor.accept_raw self
-  end
-
-  ##
-  # Appends +other+'s parts
-
-  def merge(other)
-    @parts.concat other.parts
-  end
-
-  def pretty_print(q) # :nodoc:
-    self.class.name =~ /.*::(\w{1,4})/i
-
-    q.group 2, "[#{$1.downcase}: ", ']' do
-      q.seplist @parts do |part|
-        q.pp part
-      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

package/lib/ruby/3.4.11/rdoc/markup/regexp_handling.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-##
-# Hold details of a regexp handling sequence
-
-class RDoc::Markup::RegexpHandling
-
-  ##
-  # Regexp handling type
-
-  attr_reader   :type
-
-  ##
-  # Regexp handling text
-
-  attr_accessor :text
-
-  ##
-  # Creates a new regexp handling sequence of +type+ with +text+
-
-  def initialize(type, text)
-    @type, @text = type, text
-  end
-
-  ##
-  # Regexp handlings are equal when the have the same text and type
-
-  def ==(o)
-    self.text == o.text && self.type == o.type
-  end
-
-  def inspect # :nodoc:
-    "#<RDoc::Markup::RegexpHandling:0x%x @type=%p, @text=%p>" % [
-      object_id, @type, text.dump]
-  end
-
-  def to_s # :nodoc:
-    "RegexpHandling: type=#{type} text=#{text.dump}"
-  end
-
-end

package/lib/ruby/3.4.11/rdoc/markup/rule.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-##
-# A horizontal rule with a weight
-
-class RDoc::Markup::Rule < Struct.new :weight
-
-  ##
-  # Calls #accept_rule on +visitor+
-
-  def accept(visitor)
-    visitor.accept_rule self
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group 2, '[rule:', ']' do
-      q.pp weight
-    end
-  end
-
-end

package/lib/ruby/3.4.11/rdoc/markup/table.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-##
-# A section of table
-
-class RDoc::Markup::Table
-  # headers of each column
-  attr_accessor :header
-
-  # alignments of each column
-  attr_accessor :align
-
-  # body texts of each column
-  attr_accessor :body
-
-  # Creates new instance
-  def initialize(header, align, body)
-    @header, @align, @body = header, align, body
-  end
-
-  # :stopdoc:
-  def ==(other)
-    self.class == other.class and
-      @header == other.header and
-      @align == other.align and
-      @body == other.body
-  end
-
-  def accept(visitor)
-    visitor.accept_table @header, @body, @align
-  end
-
-  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
-  end
-end

package/lib/ruby/3.4.11/rdoc/markup/to_ansi.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-##
-# Outputs RDoc markup with vibrant ANSI color!
-
-class RDoc::Markup::ToAnsi < RDoc::Markup::ToRdoc
-
-  ##
-  # Creates a new ToAnsi visitor that is ready to output vibrant ANSI color!
-
-  def initialize(markup = nil)
-    super
-
-    @headings.clear
-    @headings[1] = ["\e[1;32m", "\e[m"] # bold
-    @headings[2] = ["\e[4;32m", "\e[m"] # underline
-    @headings[3] = ["\e[32m",   "\e[m"] # just green
-  end
-
-  ##
-  # Maps attributes to ANSI sequences
-
-  def init_tags
-    add_tag :BOLD, "\e[1m", "\e[m"
-    add_tag :TT,   "\e[7m", "\e[m"
-    add_tag :EM,   "\e[4m", "\e[m"
-  end
-
-  ##
-  # Overrides indent width to ensure output lines up correctly.
-
-  def accept_list_item_end(list_item)
-    width = case @list_type.last
-            when :BULLET then
-              2
-            when :NOTE, :LABEL then
-              if @prefix then
-                @res << @prefix.strip
-                @prefix = nil
-              end
-
-              @res << "\n" unless res.length == 1
-              2
-            else
-              bullet = @list_index.last.to_s
-              @list_index[-1] = @list_index.last.succ
-              bullet.length + 2
-            end
-
-    @indent -= width
-  end
-
-  ##
-  # Adds coloring to note and label list items
-
-  def accept_list_item_start(list_item)
-    bullet = case @list_type.last
-             when :BULLET then
-               '*'
-             when :NOTE, :LABEL then
-               labels = Array(list_item.label).map do |label|
-                 attributes(label).strip
-               end.join "\n"
-
-               labels << ":\n" unless labels.empty?
-
-               labels
-             else
-               @list_index.last.to_s + '.'
-             end
-
-    case @list_type.last
-    when :NOTE, :LABEL then
-      @indent += 2
-      @prefix = bullet + (' ' * @indent)
-    else
-      @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
-
-      width = bullet.gsub(/\e\[[\d;]*m/, '').length + 1
-
-      @indent += width
-    end
-  end
-
-  ##
-  # Starts accepting with a reset screen
-
-  def start_accepting
-    super
-
-    @res = ["\e[0m"]
-  end
-
-end

package/lib/ruby/3.4.11/rdoc/markup/to_bs.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-##
-# Outputs RDoc markup with hot backspace action!  You will probably need a
-# pager to use this output format.
-#
-# This formatter won't work on 1.8.6 because it lacks String#chars.
-
-class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
-
-  ##
-  # Returns a new ToBs that is ready for hot backspace action!
-
-  def initialize(markup = nil)
-    super
-
-    @in_b  = false
-    @in_em = false
-  end
-
-  ##
-  # Sets a flag that is picked up by #annotate to do the right thing in
-  # #convert_string
-
-  def init_tags
-    add_tag :BOLD, '+b', '-b'
-    add_tag :EM,   '+_', '-_'
-    add_tag :TT,   '', ''   # we need in_tt information maintained
-  end
-
-  ##
-  # Makes heading text bold.
-
-  def accept_heading(heading)
-    use_prefix or @res << ' ' * @indent
-    @res << @headings[heading.level][0]
-    @in_b = true
-    @res << attributes(heading.text)
-    @in_b = false
-    @res << @headings[heading.level][1]
-    @res << "\n"
-  end
-
-  ##
-  # Prepares the visitor for consuming +list_item+
-
-  def accept_list_item_start(list_item)
-    type = @list_type.last
-
-    case type
-    when :NOTE, :LABEL then
-      bullets = Array(list_item.label).map do |label|
-        attributes(label).strip
-      end.join "\n"
-
-      bullets << ":\n" unless bullets.empty?
-
-      @prefix = ' ' * @indent
-      @indent += 2
-      @prefix << bullets + (' ' * @indent)
-    else
-      bullet = type == :BULLET ? '*' :  @list_index.last.to_s + '.'
-      @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
-      width = bullet.length + 1
-      @indent += width
-    end
-  end
-
-  ##
-  # Turns on or off regexp handling for +convert_string+
-
-  def annotate(tag)
-    case tag
-    when '+b' then @in_b = true
-    when '-b' then @in_b = false
-    when '+_' then @in_em = true
-    when '-_' then @in_em = false
-    end
-    ''
-  end
-
-  ##
-  # Calls convert_string on the result of convert_regexp_handling
-
-  def convert_regexp_handling(target)
-    convert_string super
-  end
-
-  ##
-  # Adds bold or underline mixed with backspaces
-
-  def convert_string(string)
-    return string unless @in_b or @in_em
-    chars = if @in_b then
-              string.chars.map do |char| "#{char}\b#{char}" end
-            elsif @in_em then
-              string.chars.map do |char| "_\b#{char}" end
-            end
-
-    chars.join
-  end
-
-end