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

package/lib/ruby/3.4.11/rdoc/token_stream.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-##
-# A TokenStream is a list of tokens, gathered during the parse of some entity
-# (say a method). Entities populate these streams by being registered with the
-# lexer. Any class can collect tokens by including TokenStream. From the
-# outside, you use such an object by calling the start_collecting_tokens
-# method, followed by calls to add_token and pop_token.
-
-module RDoc::TokenStream
-
-  ##
-  # Converts +token_stream+ to HTML wrapping various tokens with
-  # <tt><span></tt> elements. Some tokens types are wrapped in spans
-  # with the given class names. Other token types are not wrapped in spans.
-
-  def self.to_html(token_stream)
-    starting_title = false
-
-    token_stream.map do |t|
-      next unless t
-
-      style = case t[:kind]
-              when :on_const   then 'ruby-constant'
-              when :on_kw      then 'ruby-keyword'
-              when :on_ivar    then 'ruby-ivar'
-              when :on_cvar    then 'ruby-identifier'
-              when :on_gvar    then 'ruby-identifier'
-              when '=' != t[:text] && :on_op
-                               then 'ruby-operator'
-              when :on_tlambda then 'ruby-operator'
-              when :on_ident   then 'ruby-identifier'
-              when :on_label   then 'ruby-value'
-              when :on_backref, :on_dstring
-                               then 'ruby-node'
-              when :on_comment then 'ruby-comment'
-              when :on_embdoc  then 'ruby-comment'
-              when :on_regexp  then 'ruby-regexp'
-              when :on_tstring then 'ruby-string'
-              when :on_int, :on_float,
-                   :on_rational, :on_imaginary,
-                   :on_heredoc,
-                   :on_symbol, :on_CHAR then 'ruby-value'
-              when :on_heredoc_beg, :on_heredoc_end
-                               then 'ruby-identifier'
-              end
-
-      comment_with_nl = false
-      if :on_comment == t[:kind] or :on_embdoc == t[:kind] or :on_heredoc_end == t[:kind]
-        comment_with_nl = true if "\n" == t[:text][-1]
-        text = t[:text].rstrip
-      else
-        text = t[:text]
-      end
-
-      if :on_ident == t[:kind] && starting_title
-        starting_title = false
-        style = 'ruby-identifier ruby-title'
-      end
-
-      if :on_kw == t[:kind] and 'def' == t[:text]
-        starting_title = true
-      end
-
-      text = CGI.escapeHTML text
-
-      if style then
-        "<span class=\"#{style}\">#{text}</span>#{"\n" if comment_with_nl}"
-      else
-        text
-      end
-    end.join
-  end
-
-  ##
-  # Adds +tokens+ to the collected tokens
-
-  def add_tokens(tokens)
-    @token_stream.concat(tokens)
-  end
-
-  ##
-  # Adds one +token+ to the collected tokens
-
-  def add_token(token)
-    @token_stream.push(token)
-  end
-
-  ##
-  # Starts collecting tokens
-
-  def collect_tokens
-    @token_stream = []
-  end
-
-  alias start_collecting_tokens collect_tokens
-
-  ##
-  # Remove the last token from the collected tokens
-
-  def pop_token
-    @token_stream.pop
-  end
-
-  ##
-  # Current token stream
-
-  def token_stream
-    @token_stream
-  end
-
-  ##
-  # Returns a string representation of the token stream
-
-  def tokens_to_s
-    (token_stream or return '').compact.map { |token| token[:text] }.join ''
-  end
-
-end

package/lib/ruby/3.4.11/rdoc/tom_doc.rb

@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-# :markup: tomdoc
-
-# A parser for TomDoc based on TomDoc 1.0.0-rc1 (02adef9b5a)
-#
-# The TomDoc specification can be found at http://tomdoc.org.
-#
-# To choose TomDoc as your only default format see RDoc::Options@Saved+Options
-# for instructions on setting up a <code>.rdoc_options</code> file to store
-# your project default.
-#
-# There are a few differences between this parser and the specification.  A
-# best-effort was made to follow the specification as closely as possible but
-# some choices to deviate were made.
-#
-# A future version of RDoc will warn when a MUST or MUST NOT is violated and
-# may warn when a SHOULD or SHOULD NOT is violated.  RDoc will always try
-# to emit documentation even if given invalid TomDoc.
-#
-# Here are some implementation choices this parser currently makes:
-#
-# This parser allows rdoc-style inline markup but you should not depended on
-# it.
-#
-# This parser allows a space between the comment and the method body.
-#
-# This parser does not require the default value to be described for an
-# optional argument.
-#
-# This parser does not examine the order of sections.  An Examples section may
-# precede the Arguments section.
-#
-# This class is documented in TomDoc format.  Since this is a subclass of the
-# RDoc markup parser there isn't much to see here, unfortunately.
-
-class RDoc::TomDoc < RDoc::Markup::Parser
-
-  # Internal: Token accessor
-
-  attr_reader :tokens
-
-  # Internal: Adds a post-processor which sets the RDoc section based on the
-  # comment's status.
-  #
-  # Returns nothing.
-
-  def self.add_post_processor # :nodoc:
-    RDoc::Markup::PreProcess.post_process do |comment, code_object|
-      next unless code_object and
-                  RDoc::Comment === comment and comment.format == 'tomdoc'
-
-      comment.text.gsub!(/(\A\s*# )(Public|Internal|Deprecated):\s+/) do
-        section = code_object.add_section $2
-        code_object.temporary_section = section
-
-        $1
-      end
-    end
-  end
-
-  add_post_processor
-
-  # Public: Parses TomDoc from text
-  #
-  # text - A String containing TomDoc-format text.
-  #
-  # Examples
-  #
-  #   RDoc::TomDoc.parse <<-TOMDOC
-  #   This method does some things
-  #
-  #   Returns nothing.
-  #   TOMDOC
-  #   # => #<RDoc::Markup::Document:0xXXX @parts=[...], @file=nil>
-  #
-  # Returns an RDoc::Markup::Document representing the TomDoc format.
-
-  def self.parse(text)
-    parser = new
-
-    parser.tokenize text
-    doc = RDoc::Markup::Document.new
-    parser.parse doc
-    doc
-  end
-
-  # Internal: Extracts the Signature section's method signature
-  #
-  # comment - An RDoc::Comment that will be parsed and have the signature
-  #           extracted
-  #
-  # Returns a String containing the signature and nil if not
-
-  def self.signature(comment)
-    return unless comment.tomdoc?
-
-    document = comment.parse
-
-    signature = nil
-    found_heading = false
-    found_signature = false
-
-    document.parts.delete_if do |part|
-      next false if found_signature
-
-      found_heading ||=
-        RDoc::Markup::Heading === part && part.text == 'Signature'
-
-      next false unless found_heading
-
-      next true if RDoc::Markup::BlankLine === part
-
-      if RDoc::Markup::Verbatim === part then
-        signature = part
-        found_signature = true
-      end
-    end
-
-    signature and signature.text
-  end
-
-  # Public: Creates a new TomDoc parser.  See also RDoc::Markup::parse
-
-  def initialize
-    super
-
-    @section      = nil
-    @seen_returns = false
-  end
-
-  # Internal: Builds a heading from the token stream
-  #
-  # level - The level of heading to create
-  #
-  # Returns an RDoc::Markup::Heading
-
-  def build_heading(level)
-    heading = super
-
-    @section = heading.text
-
-    heading
-  end
-
-  # Internal: Builds a verbatim from the token stream.  A verbatim in the
-  # Examples section will be marked as in Ruby format.
-  #
-  # margin - The indentation from the margin for lines that belong to this
-  #          verbatim section.
-  #
-  # Returns an RDoc::Markup::Verbatim
-
-  def build_verbatim(margin)
-    verbatim = super
-
-    verbatim.format = :ruby if @section == 'Examples'
-
-    verbatim
-  end
-
-  # Internal: Builds a paragraph from the token stream
-  #
-  # margin - Unused
-  #
-  # Returns an RDoc::Markup::Paragraph.
-
-  def build_paragraph(margin)
-    p :paragraph_start => margin if @debug
-
-    paragraph = RDoc::Markup::Paragraph.new
-
-    until @tokens.empty? do
-      type, data, = get
-
-      case type
-      when :TEXT then
-        @section = 'Returns' if data =~ /\A(Returns|Raises)/
-
-        paragraph << data
-      when :NEWLINE then
-        if :TEXT == peek_token[0] then
-          # Lines beginning with 'Raises' in the Returns section should not be
-          # treated as multiline text
-          if 'Returns' == @section and
-            peek_token[1].start_with?('Raises') then
-            break
-          else
-            paragraph << ' '
-          end
-        else
-          break
-        end
-      else
-        unget
-        break
-      end
-    end
-
-    p :paragraph_end => margin if @debug
-
-    paragraph
-  end
-
-  ##
-  # Detects a section change to "Returns" and adds a heading
-
-  def parse_text(parent, indent) # :nodoc:
-    paragraph = build_paragraph indent
-
-    if false == @seen_returns and 'Returns' == @section then
-      @seen_returns = true
-      parent << RDoc::Markup::Heading.new(3, 'Returns')
-      parent << RDoc::Markup::BlankLine.new
-    end
-
-    parent << paragraph
-  end
-
-  # Internal: Turns text into an Array of tokens
-  #
-  # text - A String containing TomDoc-format text.
-  #
-  # Returns self.
-
-  def tokenize(text)
-    text = text.sub(/\A(Public|Internal|Deprecated):\s+/, '')
-
-    setup_scanner text
-
-    until @s.eos? do
-      pos = @s.pos
-
-      # leading spaces will be reflected by the column of the next token
-      # the only thing we loose are trailing spaces at the end of the file
-      next if @s.scan(/ +/)
-
-      @tokens << case
-                 when @s.scan(/\r?\n/) then
-                   token = [:NEWLINE, @s.matched, *pos]
-                   @s.newline!
-                   token
-                 when @s.scan(/(Examples|Signature)$/) then
-                   @tokens << [:HEADER, 3, *pos]
-
-                   [:TEXT, @s[1], *pos]
-                 when @s.scan(/([:\w][\w\[\]]*)[ ]+- /) then
-                   [:NOTE, @s[1], *pos]
-                 else
-                   @s.scan(/.*/)
-                   [:TEXT, @s.matched.sub(/\r$/, ''), *pos]
-                 end
-    end
-
-    self
-  end
-
-end

package/lib/ruby/3.4.11/rdoc/version.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module RDoc
-
-  ##
-  # RDoc version you are using
-
-  VERSION = '6.14.0'
-
-end

package/lib/ruby/3.4.11/rdoc.rb

@@ -1,211 +0,0 @@
-# frozen_string_literal: true
-$DEBUG_RDOC = nil
-
-##
-# RDoc produces documentation for Ruby source files by parsing the source and
-# extracting the definition for classes, modules, methods, includes and
-# requires.  It associates these with optional documentation contained in an
-# immediately preceding comment block then renders the result using an output
-# formatter.
-#
-# For a simple introduction to writing or generating documentation using RDoc
-# see the README.
-#
-# == Roadmap
-#
-# If you think you found a bug in RDoc see CONTRIBUTING@Bugs
-#
-# If you want to use RDoc to create documentation for your Ruby source files,
-# see RDoc::Markup and refer to <tt>rdoc --help</tt> for command line usage.
-#
-# If you want to set the default markup format see
-# RDoc::Markup@Markup+Formats
-#
-# If you want to store rdoc configuration in your gem (such as the default
-# markup format) see RDoc::Options@Saved+Options
-#
-# If you want to write documentation for Ruby files see RDoc::Parser::Ruby
-#
-# If you want to write documentation for extensions written in C see
-# RDoc::Parser::C
-#
-# If you want to generate documentation using <tt>rake</tt> see RDoc::Task.
-#
-# If you want to drive RDoc programmatically, see RDoc::RDoc.
-#
-# If you want to use the library to format text blocks into HTML or other
-# formats, look at RDoc::Markup.
-#
-# If you want to make an RDoc plugin such as a generator or directive handler
-# see RDoc::RDoc.
-#
-# If you want to write your own output generator see RDoc::Generator.
-#
-# If you want an overview of how RDoc works see CONTRIBUTING
-#
-# == Credits
-#
-# RDoc is currently being maintained by Eric Hodel <drbrain@segment7.net>.
-#
-# Dave Thomas <dave@pragmaticprogrammer.com> is the original author of RDoc.
-#
-# * The Ruby parser in rdoc/parse.rb is based heavily on the outstanding
-#   work of Keiju ISHITSUKA of Nippon Rational Inc, who produced the Ruby
-#   parser for irb and the rtags package.
-
-module RDoc
-
-  ##
-  # Exception thrown by any rdoc error.
-
-  class Error < RuntimeError; end
-
-  require_relative 'rdoc/version'
-
-  ##
-  # Method visibilities
-
-  VISIBILITIES = [:public, :protected, :private]
-
-  ##
-  # Name of the dotfile that contains the description of files to be processed
-  # in the current directory
-
-  DOT_DOC_FILENAME = ".document"
-
-  ##
-  # General RDoc modifiers
-
-  GENERAL_MODIFIERS = %w[nodoc].freeze
-
-  ##
-  # RDoc modifiers for classes
-
-  CLASS_MODIFIERS = GENERAL_MODIFIERS
-
-  ##
-  # RDoc modifiers for attributes
-
-  ATTR_MODIFIERS = GENERAL_MODIFIERS
-
-  ##
-  # RDoc modifiers for constants
-
-  CONSTANT_MODIFIERS = GENERAL_MODIFIERS
-
-  ##
-  # RDoc modifiers for methods
-
-  METHOD_MODIFIERS = GENERAL_MODIFIERS +
-    %w[arg args yield yields notnew not-new not_new doc]
-
-  ##
-  # Loads the best available YAML library.
-
-  def self.load_yaml
-    begin
-      gem 'psych'
-    rescue NameError => e # --disable-gems
-      raise unless e.name == :gem
-    rescue Gem::LoadError
-    end
-
-    begin
-      require 'psych'
-    rescue ::LoadError
-    ensure
-      require 'yaml'
-    end
-  end
-
-  ##
-  # Searches and returns the directory for settings.
-  #
-  # 1. <tt>$HOME/.rdoc</tt> directory, if it exists.
-  # 2. The +rdoc+ directory under the path specified by the
-  #    +XDG_DATA_HOME+ environment variable, if it is set.
-  # 3. <tt>$HOME/.local/share/rdoc</tt> directory.
-  #
-  # Other than the home directory, the containing directory will be
-  # created automatically.
-
-  def self.home
-    rdoc_dir = begin
-                File.expand_path('~/.rdoc')
-              rescue ArgumentError
-              end
-
-    if File.directory?(rdoc_dir)
-      rdoc_dir
-    else
-      require 'fileutils'
-      begin
-        # XDG
-        xdg_data_home = ENV["XDG_DATA_HOME"] || File.join(File.expand_path("~"), '.local', 'share')
-        unless File.exist?(xdg_data_home)
-          FileUtils.mkdir_p xdg_data_home
-        end
-        File.join xdg_data_home, "rdoc"
-      rescue Errno::EACCES
-      end
-    end
-  end
-
-  autoload :RDoc,           "#{__dir__}/rdoc/rdoc"
-
-  autoload :CrossReference, "#{__dir__}/rdoc/cross_reference"
-  autoload :ERBIO,          "#{__dir__}/rdoc/erbio"
-  autoload :ERBPartial,     "#{__dir__}/rdoc/erb_partial"
-  autoload :Encoding,       "#{__dir__}/rdoc/encoding"
-  autoload :Generator,      "#{__dir__}/rdoc/generator"
-  autoload :Options,        "#{__dir__}/rdoc/options"
-  autoload :Parser,         "#{__dir__}/rdoc/parser"
-  autoload :Servlet,        "#{__dir__}/rdoc/servlet"
-  autoload :RI,             "#{__dir__}/rdoc/ri"
-  autoload :Stats,          "#{__dir__}/rdoc/stats"
-  autoload :Store,          "#{__dir__}/rdoc/store"
-  autoload :Task,           "#{__dir__}/rdoc/task"
-  autoload :Text,           "#{__dir__}/rdoc/text"
-
-  autoload :Markdown,       "#{__dir__}/rdoc/markdown"
-  autoload :Markup,         "#{__dir__}/rdoc/markup"
-  autoload :RD,             "#{__dir__}/rdoc/rd"
-  autoload :TomDoc,         "#{__dir__}/rdoc/tom_doc"
-
-  autoload :KNOWN_CLASSES,  "#{__dir__}/rdoc/known_classes"
-
-  autoload :TokenStream,    "#{__dir__}/rdoc/token_stream"
-
-  autoload :Comment,        "#{__dir__}/rdoc/comment"
-
-  require_relative 'rdoc/i18n'
-
-  # code objects
-  #
-  # We represent the various high-level code constructs that appear in Ruby
-  # programs: classes, modules, methods, and so on.
-  autoload :CodeObject,     "#{__dir__}/rdoc/code_object"
-
-  autoload :Context,        "#{__dir__}/rdoc/code_object/context"
-  autoload :TopLevel,       "#{__dir__}/rdoc/code_object/top_level"
-
-  autoload :AnonClass,      "#{__dir__}/rdoc/code_object/anon_class"
-  autoload :ClassModule,    "#{__dir__}/rdoc/code_object/class_module"
-  autoload :NormalClass,    "#{__dir__}/rdoc/code_object/normal_class"
-  autoload :NormalModule,   "#{__dir__}/rdoc/code_object/normal_module"
-  autoload :SingleClass,    "#{__dir__}/rdoc/code_object/single_class"
-
-  autoload :Alias,          "#{__dir__}/rdoc/code_object/alias"
-  autoload :AnyMethod,      "#{__dir__}/rdoc/code_object/any_method"
-  autoload :MethodAttr,     "#{__dir__}/rdoc/code_object/method_attr"
-  autoload :GhostMethod,    "#{__dir__}/rdoc/code_object/ghost_method"
-  autoload :MetaMethod,     "#{__dir__}/rdoc/code_object/meta_method"
-  autoload :Attr,           "#{__dir__}/rdoc/code_object/attr"
-
-  autoload :Constant,       "#{__dir__}/rdoc/code_object/constant"
-  autoload :Mixin,          "#{__dir__}/rdoc/code_object/mixin"
-  autoload :Include,        "#{__dir__}/rdoc/code_object/include"
-  autoload :Extend,         "#{__dir__}/rdoc/code_object/extend"
-  autoload :Require,        "#{__dir__}/rdoc/code_object/require"
-
-end

package/lib/ruby/3.4.11/readline.gemspec

@@ -1,33 +0,0 @@
-Gem::Specification.new do |spec|
-  spec.name          = 'readline'
-  spec.version       = '0.0.4'
-  spec.authors       = ['aycabta']
-  spec.email         = ['aycabta@gmail.com']
-
-  spec.summary       = %q{Loader for "readline".}
-  spec.description   = <<~EOD
-    This is just a loader for "readline". If Ruby has the "readline-ext" gem
-    that is a native extension, this gem will load it. If Ruby does not have
-    the "readline-ext" gem this gem will load "reline", a library that is
-    compatible with the "readline-ext" gem and implemented in pure Ruby.
-  EOD
-  spec.homepage      = 'https://github.com/ruby/readline'
-  spec.license       = 'Ruby'
-
-  spec.files         = Dir['BSDL', 'COPYING', 'README.md', 'lib/readline.rb']
-  spec.require_paths = ['lib']
-
-  spec.post_install_message = <<~EOM
-    +---------------------------------------------------------------------------+
-    | This is just a loader for "readline". If Ruby has the "readline-ext" gem  |
-    | that is a native extension, this gem will load it. If Ruby does not have  |
-    | the "readline-ext" gem this gem will load "reline", a library that is     |
-    | compatible with the "readline-ext" gem and implemented in pure Ruby.      |
-    |                                                                           |
-    | If you intend to use GNU Readline by `require 'readline'`, please install |
-    | the "readline-ext" gem.                                                   |
-    +---------------------------------------------------------------------------+
-  EOM
-
-  spec.add_runtime_dependency 'reline'
-end

package/lib/ruby/3.4.11/readline.rb

@@ -1,7 +0,0 @@
-begin
-  require "readline.#{RbConfig::CONFIG["DLEXT"]}"
-rescue LoadError
-  require 'reline' unless defined? Reline
-  Object.send(:remove_const, :Readline) if Object.const_defined?(:Readline)
-  Readline = Reline
-end