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

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

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-##
-# A Document containing lists, headings, paragraphs, etc.
-
-class RDoc::Markup::Document
-
-  include Enumerable
-
-  ##
-  # The file this document was created from.  See also
-  # RDoc::ClassModule#add_comment
-
-  attr_reader :file
-
-  ##
-  # If a heading is below the given level it will be omitted from the
-  # table_of_contents
-
-  attr_accessor :omit_headings_below
-
-  ##
-  # The parts of the Document
-
-  attr_reader :parts
-
-  ##
-  # Creates a new Document with +parts+
-
-  def initialize *parts
-    @parts = []
-    @parts.concat parts
-
-    @file = nil
-    @omit_headings_from_table_of_contents_below = nil
-  end
-
-  ##
-  # Appends +part+ to the document
-
-  def <<(part)
-    case part
-    when RDoc::Markup::Document then
-      unless part.empty? then
-        parts.concat part.parts
-        parts << RDoc::Markup::BlankLine.new
-      end
-    when String then
-      raise ArgumentError,
-            "expected RDoc::Markup::Document and friends, got String" unless
-        part.empty?
-    else
-      parts << part
-    end
-  end
-
-  def ==(other) # :nodoc:
-    self.class == other.class and
-      @file == other.file and
-      @parts == other.parts
-  end
-
-  ##
-  # Runs this document and all its #items through +visitor+
-
-  def accept(visitor)
-    visitor.start_accepting
-
-    visitor.accept_document self
-
-    visitor.end_accepting
-  end
-
-  ##
-  # Concatenates the given +parts+ onto the document
-
-  def concat(parts)
-    self.parts.concat parts
-  end
-
-  ##
-  # Enumerator for the parts of this document
-
-  def each(&block)
-    @parts.each(&block)
-  end
-
-  ##
-  # Does this document have no parts?
-
-  def empty?
-    @parts.empty? or (@parts.length == 1 and merged? and @parts.first.empty?)
-  end
-
-  ##
-  # The file this Document was created from.
-
-  def file=(location)
-    @file = case location
-            when RDoc::TopLevel then
-              location.relative_name
-            else
-              location
-            end
-  end
-
-  ##
-  # When this is a collection of documents (#file is not set and this document
-  # contains only other documents as its direct children) #merge replaces
-  # documents in this class with documents from +other+ when the file matches
-  # and adds documents from +other+ when the files do not.
-  #
-  # The information in +other+ is preferred over the receiver
-
-  def merge(other)
-    if empty? then
-      @parts = other.parts
-      return self
-    end
-
-    other.parts.each do |other_part|
-      self.parts.delete_if do |self_part|
-        self_part.file and self_part.file == other_part.file
-      end
-
-      self.parts << other_part
-    end
-
-    self
-  end
-
-  ##
-  # Does this Document contain other Documents?
-
-  def merged?
-    RDoc::Markup::Document === @parts.first
-  end
-
-  def pretty_print(q) # :nodoc:
-    start = @file ? "[doc (#{@file}): " : '[doc: '
-
-    q.group 2, start, ']' do
-      q.seplist @parts do |part|
-        q.pp part
-      end
-    end
-  end
-
-  ##
-  # Appends +parts+ to the document
-
-  def push *parts
-    self.parts.concat parts
-  end
-
-  ##
-  # Returns an Array of headings in the document.
-  #
-  # Require 'rdoc/markup/formatter' before calling this method.
-
-  def table_of_contents
-    accept RDoc::Markup::ToTableOfContents.to_toc
-  end
-
-end

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

@@ -1,272 +0,0 @@
-# frozen_string_literal: true
-##
-# Base class for RDoc markup formatters
-#
-# Formatters are a visitor that converts an RDoc::Markup tree (from a comment)
-# into some kind of output.  RDoc ships with formatters for converting back to
-# rdoc, ANSI text, HTML, a Table of Contents and other formats.
-#
-# If you'd like to write your own Formatter use
-# RDoc::Markup::FormatterTestCase.  If you're writing a text-output formatter
-# use RDoc::Markup::TextFormatterTestCase which provides extra test cases.
-
-class RDoc::Markup::Formatter
-
-  ##
-  # Tag for inline markup containing a +bit+ for the bitmask and the +on+ and
-  # +off+ triggers.
-
-  InlineTag = Struct.new(:bit, :on, :off)
-
-  ##
-  # Converts a target url to one that is relative to a given path
-
-  def self.gen_relative_url(path, target)
-    from        = File.dirname path
-    to, to_file = File.split target
-
-    from = from.split "/"
-    to   = to.split "/"
-
-    from.delete '.'
-    to.delete '.'
-
-    while from.size > 0 and to.size > 0 and from[0] == to[0] do
-      from.shift
-      to.shift
-    end
-
-    from.fill ".."
-    from.concat to
-    from << to_file
-    File.join(*from)
-  end
-
-  ##
-  # Creates a new Formatter
-
-  def initialize(options, markup = nil)
-    @options = options
-
-    @markup = markup || RDoc::Markup.new
-    @am     = @markup.attribute_manager
-    @am.add_regexp_handling(/<br>/, :HARD_BREAK)
-
-    @attributes = @am.attributes
-
-    @attr_tags = []
-
-    @in_tt = 0
-    @tt_bit = @attributes.bitmap_for :TT
-
-    @hard_break = ''
-    @from_path = '.'
-  end
-
-  ##
-  # Adds +document+ to the output
-
-  def accept_document(document)
-    document.parts.each do |item|
-      case item
-      when RDoc::Markup::Document then # HACK
-        accept_document item
-      else
-        item.accept self
-      end
-    end
-  end
-
-  ##
-  # Adds a regexp handling for links of the form rdoc-...:
-
-  def add_regexp_handling_RDOCLINK
-    @markup.add_regexp_handling(/rdoc-[a-z]+:[^\s\]]+/, :RDOCLINK)
-  end
-
-  ##
-  # Adds a regexp handling for links of the form {<text>}[<url>] and
-  # <word>[<url>]
-
-  def add_regexp_handling_TIDYLINK
-    @markup.add_regexp_handling(/(?:
-                                  \{[^{}]*\} | # multi-word label
-                                  \b[^\s{}]+? # single-word label
-                                 )
-
-                                 \[\S+?\]     # link target
-                                /x, :TIDYLINK)
-  end
-
-  ##
-  # Add a new set of tags for an attribute. We allow separate start and end
-  # tags for flexibility
-
-  def add_tag(name, start, stop)
-    attr = @attributes.bitmap_for name
-    @attr_tags << InlineTag.new(attr, start, stop)
-  end
-
-  ##
-  # Allows +tag+ to be decorated with additional information.
-
-  def annotate(tag)
-    tag
-  end
-
-  ##
-  # Marks up +content+
-
-  def convert(content)
-    @markup.convert content, self
-  end
-
-  ##
-  # Converts flow items +flow+
-
-  def convert_flow(flow)
-    res = []
-
-    flow.each do |item|
-      case item
-      when String then
-        res << convert_string(item)
-      when RDoc::Markup::AttrChanger then
-        off_tags res, item
-        on_tags res, item
-      when RDoc::Markup::RegexpHandling then
-        res << convert_regexp_handling(item)
-      else
-        raise "Unknown flow element: #{item.inspect}"
-      end
-    end
-
-    res.join
-  end
-
-  ##
-  # Converts added regexp handlings. See RDoc::Markup#add_regexp_handling
-
-  def convert_regexp_handling(target)
-    return target.text if in_tt?
-
-    handled = false
-
-    @attributes.each_name_of target.type do |name|
-      method_name = "handle_regexp_#{name}"
-
-      if respond_to? method_name then
-        target.text = public_send method_name, target
-        handled = true
-      end
-    end
-
-    unless handled then
-      target_name = @attributes.as_string target.type
-
-      raise RDoc::Error, "Unhandled regexp handling #{target_name}: #{target}"
-    end
-
-    target.text
-  end
-
-  ##
-  # Converts a string to be fancier if desired
-
-  def convert_string(string)
-    string
-  end
-
-  ##
-  # Use ignore in your subclass to ignore the content of a node.
-  #
-  #   ##
-  #   # We don't support raw nodes in ToNoRaw
-  #
-  #   alias accept_raw ignore
-
-  def ignore *node
-  end
-
-  ##
-  # Are we currently inside tt tags?
-
-  def in_tt?
-    @in_tt > 0
-  end
-
-  def tt_tag?(attr_mask, reverse = false)
-    each_attr_tag(attr_mask, reverse) do |tag|
-      return true if tt? tag
-    end
-    false
-  end
-
-  ##
-  # Turns on tags for +item+ on +res+
-
-  def on_tags(res, item)
-    each_attr_tag(item.turn_on) do |tag|
-      res << annotate(tag.on)
-      @in_tt += 1 if tt? tag
-    end
-  end
-
-  ##
-  # Turns off tags for +item+ on +res+
-
-  def off_tags(res, item)
-    each_attr_tag(item.turn_off, true) do |tag|
-      @in_tt -= 1 if tt? tag
-      res << annotate(tag.off)
-    end
-  end
-
-  def each_attr_tag(attr_mask, reverse = false)
-    return if attr_mask.zero?
-
-    @attr_tags.public_send(reverse ? :reverse_each : :each) do |tag|
-      if attr_mask & tag.bit != 0 then
-        yield tag
-      end
-    end
-  end
-
-  ##
-  # Extracts and a scheme, url and an anchor id from +url+ and returns them.
-
-  def parse_url(url)
-    case url
-    when /^rdoc-label:([^:]*)(?::(.*))?/ then
-      scheme = 'link'
-      path   = "##{$1}"
-      id     = " id=\"#{$2}\"" if $2
-    when /([A-Za-z]+):(.*)/ then
-      scheme = $1.downcase
-      path   = $2
-    when /^#/ then
-    else
-      scheme = 'http'
-      path   = url
-      url    = url
-    end
-
-    if scheme == 'link' then
-      url = if path[0, 1] == '#' then # is this meaningful?
-              path
-            else
-              self.class.gen_relative_url @from_path, path
-            end
-    end
-
-    [scheme, url, id]
-  end
-
-  ##
-  # Is +tag+ a tt tag?
-
-  def tt?(tag)
-    tag.bit == @tt_bit
-  end
-
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-##
-# A hard-break in the middle of a paragraph.
-
-class RDoc::Markup::HardBreak
-
-  @instance = new
-
-  ##
-  # RDoc::Markup::HardBreak is a singleton
-
-  def self.new
-    @instance
-  end
-
-  ##
-  # Calls #accept_hard_break on +visitor+
-
-  def accept(visitor)
-    visitor.accept_hard_break self
-  end
-
-  def ==(other) # :nodoc:
-    self.class === other
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.text "[break]"
-  end
-
-end

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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-##
-# A heading with a level (1-6) and text
-
-RDoc::Markup::Heading =
-  Struct.new :level, :text do
-
-  @to_html = nil
-  @to_label = nil
-
-  ##
-  # A singleton RDoc::Markup::ToLabel formatter for headings.
-
-  def self.to_label
-    @to_label ||= RDoc::Markup::ToLabel.new
-  end
-
-  ##
-  # A singleton plain HTML formatter for headings.  Used for creating labels
-  # for the Table of Contents
-
-  def self.to_html
-    return @to_html if @to_html
-
-    markup = RDoc::Markup.new
-    markup.add_regexp_handling RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
-
-    @to_html = RDoc::Markup::ToHtml.new nil
-
-    def @to_html.handle_regexp_CROSSREF(target)
-      target.text.sub(/^\\/, '')
-    end
-
-    @to_html
-  end
-
-  ##
-  # Calls #accept_heading on +visitor+
-
-  def accept(visitor)
-    visitor.accept_heading self
-  end
-
-  ##
-  # An HTML-safe anchor reference for this header.
-
-  def aref
-    "label-#{self.class.to_label.convert text.dup}"
-  end
-
-  ##
-  # Creates a fully-qualified label which will include the label from
-  # +context+.  This helps keep ids unique in HTML.
-
-  def label(context = nil)
-    label = aref
-
-    label = [context.aref, label].compact.join '-' if
-      context and context.respond_to? :aref
-
-    label
-  end
-
-  ##
-  # HTML markup of the text of this label without the surrounding header
-  # element.
-
-  def plain_html
-    text = self.text.dup
-
-    if matched = text.match(/rdoc-image:[^:]+:(.*)/)
-      text = matched[1]
-    end
-
-    self.class.to_html.to_html(text)
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group 2, "[head: #{level} ", ']' do
-      q.pp text
-    end
-  end
-
-end

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

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-##
-# A file included at generation time.  Objects of this class are created by
-# RDoc::RD for an extension-less include.
-#
-# This implementation in incomplete.
-
-class RDoc::Markup::Include
-
-  ##
-  # The filename to be included, without extension
-
-  attr_reader :file
-
-  ##
-  # Directories to search for #file
-
-  attr_reader :include_path
-
-  ##
-  # Creates a new include that will import +file+ from +include_path+
-
-  def initialize(file, include_path)
-    @file = file
-    @include_path = include_path
-  end
-
-  def ==(other) # :nodoc:
-    self.class === other and
-      @file == other.file and @include_path == other.include_path
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group 2, '[incl ', ']' do
-      q.text file
-      q.breakable
-      q.text 'from '
-      q.pp include_path
-    end
-  end
-
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-##
-# An Indented Paragraph of text
-
-class RDoc::Markup::IndentedParagraph < RDoc::Markup::Raw
-
-  ##
-  # The indent in number of spaces
-
-  attr_reader :indent
-
-  ##
-  # Creates a new IndentedParagraph containing +parts+ indented with +indent+
-  # spaces
-
-  def initialize indent, *parts
-    @indent = indent
-
-    super(*parts)
-  end
-
-  def ==(other) # :nodoc:
-    super and indent == other.indent
-  end
-
-  ##
-  # Calls #accept_indented_paragraph on +visitor+
-
-  def accept(visitor)
-    visitor.accept_indented_paragraph self
-  end
-
-  ##
-  # Joins the raw paragraph text and converts inline HardBreaks to the
-  # +hard_break+ text followed by the indent.
-
-  def text(hard_break = nil)
-    @parts.map do |part|
-      if RDoc::Markup::HardBreak === part then
-        '%1$s%3$*2$s' % [hard_break, @indent, ' '] if hard_break
-      else
-        part
-      end
-    end.join
-  end
-
-end