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

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

@@ -1,441 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "deprecate"
-
-##
-# The Version class processes string versions into comparable
-# values. A version string should normally be a series of numbers
-# separated by periods. Each part (digits separated by periods) is
-# considered its own number, and these are used for sorting. So for
-# instance, 3.10 sorts higher than 3.2 because ten is greater than
-# two.
-#
-# If any part contains letters (currently only a-z are supported) then
-# that version is considered prerelease. Versions with a prerelease
-# part in the Nth part sort less than versions with N-1
-# parts. Prerelease parts are sorted alphabetically using the normal
-# Ruby string sorting rules. If a prerelease part contains both
-# letters and numbers, it will be broken into multiple parts to
-# provide expected sort behavior (1.0.a10 becomes 1.0.a.10, and is
-# greater than 1.0.a9).
-#
-# Prereleases sort between real releases (newest to oldest):
-#
-# 1. 1.0
-# 2. 1.0.b1
-# 3. 1.0.a.2
-# 4. 0.9
-#
-# If you want to specify a version restriction that includes both prereleases
-# and regular releases of the 1.x series this is the best way:
-#
-#   s.add_dependency 'example', '>= 1.0.0.a', '< 2.0.0'
-#
-# == How Software Changes
-#
-# Users expect to be able to specify a version constraint that gives them
-# some reasonable expectation that new versions of a library will work with
-# their software if the version constraint is true, and not work with their
-# software if the version constraint is false.  In other words, the perfect
-# system will accept all compatible versions of the library and reject all
-# incompatible versions.
-#
-# Libraries change in 3 ways (well, more than 3, but stay focused here!).
-#
-# 1. The change may be an implementation detail only and have no effect on
-#    the client software.
-# 2. The change may add new features, but do so in a way that client software
-#    written to an earlier version is still compatible.
-# 3. The change may change the public interface of the library in such a way
-#    that old software is no longer compatible.
-#
-# Some examples are appropriate at this point.  Suppose I have a Stack class
-# that supports a <tt>push</tt> and a <tt>pop</tt> method.
-#
-# === Examples of Category 1 changes:
-#
-# * Switch from an array based implementation to a linked-list based
-#   implementation.
-# * Provide an automatic (and transparent) backing store for large stacks.
-#
-# === Examples of Category 2 changes might be:
-#
-# * Add a <tt>depth</tt> method to return the current depth of the stack.
-# * Add a <tt>top</tt> method that returns the current top of stack (without
-#   changing the stack).
-# * Change <tt>push</tt> so that it returns the item pushed (previously it
-#   had no usable return value).
-#
-# === Examples of Category 3 changes might be:
-#
-# * Changes <tt>pop</tt> so that it no longer returns a value (you must use
-#   <tt>top</tt> to get the top of the stack).
-# * Rename the methods to <tt>push_item</tt> and <tt>pop_item</tt>.
-#
-# == RubyGems Rational Versioning
-#
-# * Versions shall be represented by three non-negative integers, separated
-#   by periods (e.g. 3.1.4).  The first integers is the "major" version
-#   number, the second integer is the "minor" version number, and the third
-#   integer is the "build" number.
-#
-# * A category 1 change (implementation detail) will increment the build
-#   number.
-#
-# * A category 2 change (backwards compatible) will increment the minor
-#   version number and reset the build number.
-#
-# * A category 3 change (incompatible) will increment the major build number
-#   and reset the minor and build numbers.
-#
-# * Any "public" release of a gem should have a different version.  Normally
-#   that means incrementing the build number.  This means a developer can
-#   generate builds all day long, but as soon as they make a public release,
-#   the version must be updated.
-#
-# === Examples
-#
-# Let's work through a project lifecycle using our Stack example from above.
-#
-# Version 0.0.1:: The initial Stack class is release.
-# Version 0.0.2:: Switched to a linked=list implementation because it is
-#                 cooler.
-# Version 0.1.0:: Added a <tt>depth</tt> method.
-# Version 1.0.0:: Added <tt>top</tt> and made <tt>pop</tt> return nil
-#                 (<tt>pop</tt> used to return the  old top item).
-# Version 1.1.0:: <tt>push</tt> now returns the value pushed (it used it
-#                 return nil).
-# Version 1.1.1:: Fixed a bug in the linked list implementation.
-# Version 1.1.2:: Fixed a bug introduced in the last fix.
-#
-# Client A needs a stack with basic push/pop capability.  They write to the
-# original interface (no <tt>top</tt>), so their version constraint looks like:
-#
-#   gem 'stack', '>= 0.0'
-#
-# Essentially, any version is OK with Client A.  An incompatible change to
-# the library will cause them grief, but they are willing to take the chance
-# (we call Client A optimistic).
-#
-# Client B is just like Client A except for two things: (1) They use the
-# <tt>depth</tt> method and (2) they are worried about future
-# incompatibilities, so they write their version constraint like this:
-#
-#   gem 'stack', '~> 0.1'
-#
-# The <tt>depth</tt> method was introduced in version 0.1.0, so that version
-# or anything later is fine, as long as the version stays below version 1.0
-# where incompatibilities are introduced.  We call Client B pessimistic
-# because they are worried about incompatible future changes (it is OK to be
-# pessimistic!).
-#
-# == Preventing Version Catastrophe:
-#
-# From: https://www.zenspider.com/ruby/2008/10/rubygems-how-to-preventing-catastrophe.html
-#
-# Let's say you're depending on the fnord gem version 2.y.z. If you
-# specify your dependency as ">= 2.0.0" then, you're good, right? What
-# happens if fnord 3.0 comes out and it isn't backwards compatible
-# with 2.y.z? Your stuff will break as a result of using ">=". The
-# better route is to specify your dependency with an "approximate" version
-# specifier ("~>"). They're a tad confusing, so here is how the dependency
-# specifiers work:
-#
-#   Specification From  ... To (exclusive)
-#   ">= 3.0"      3.0   ... &infin;
-#   "~> 3.0"      3.0   ... 4.0
-#   "~> 3.0.0"    3.0.0 ... 3.1
-#   "~> 3.5"      3.5   ... 4.0
-#   "~> 3.5.0"    3.5.0 ... 3.6
-#   "~> 3"        3.0   ... 4.0
-#
-# For the last example, single-digit versions are automatically extended with
-# a zero to give a sensible result.
-
-class Gem::Version
-  include Comparable
-
-  VERSION_PATTERN = '[0-9]+(?>\.[0-9a-zA-Z]+)*(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?' # :nodoc:
-  ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})?\s*\z/ # :nodoc:
-
-  ##
-  # A string representation of this Version.
-
-  def version
-    @version
-  end
-
-  alias_method :to_s, :version
-
-  ##
-  # True if the +version+ string matches RubyGems' requirements.
-
-  def self.correct?(version)
-    nil_versions_are_discouraged! if version.nil?
-
-    ANCHORED_VERSION_PATTERN.match?(version.to_s)
-  end
-
-  ##
-  # Factory method to create a Version object. Input may be a Version
-  # or a String. Intended to simplify client code.
-  #
-  #   ver1 = Version.create('1.3.17')   # -> (Version object)
-  #   ver2 = Version.create(ver1)       # -> (ver1)
-  #   ver3 = Version.create(nil)        # -> nil
-
-  def self.create(input)
-    if self === input # check yourself before you wreck yourself
-      input
-    elsif input.nil?
-      nil_versions_are_discouraged!
-
-      nil
-    else
-      new input
-    end
-  end
-
-  @@all = {}
-  @@bump = {}
-  @@release = {}
-
-  def self.new(version) # :nodoc:
-    return super unless self == Gem::Version
-
-    @@all[version] ||= super
-  end
-
-  def self.nil_versions_are_discouraged!
-    unless Gem::Deprecate.skip
-      warn "nil versions are discouraged and will be deprecated in Rubygems 4"
-    end
-  end
-
-  private_class_method :nil_versions_are_discouraged!
-
-  ##
-  # Constructs a Version from the +version+ string.  A version string is a
-  # series of digits or ASCII letters separated by dots.
-
-  def initialize(version)
-    unless self.class.correct?(version)
-      raise ArgumentError, "Malformed version number string #{version}"
-    end
-
-    # If version is an empty string convert it to 0
-    version = 0 if version.is_a?(String) && /\A\s*\Z/.match?(version)
-
-    @version = version.to_s
-
-    # optimization to avoid allocation when given an integer, since we know
-    # it's to_s won't have any spaces or dashes
-    unless version.is_a?(Integer)
-      @version = @version.strip
-      @version.gsub!("-",".pre.")
-    end
-    @version = -@version
-    @segments = nil
-  end
-
-  ##
-  # Return a new version object where the next to the last revision
-  # number is one greater (e.g., 5.3.1 => 5.4).
-  #
-  # Pre-release (alpha) parts, e.g, 5.3.1.b.2 => 5.4, are ignored.
-
-  def bump
-    @@bump[self] ||= begin
-                       segments = self.segments
-                       segments.pop while segments.any? {|s| String === s }
-                       segments.pop if segments.size > 1
-
-                       segments[-1] = segments[-1].succ
-                       self.class.new segments.join(".")
-                     end
-  end
-
-  ##
-  # A Version is only eql? to another version if it's specified to the
-  # same precision. Version "1.0" is not the same as version "1".
-
-  def eql?(other)
-    self.class === other && @version == other.version
-  end
-
-  def hash # :nodoc:
-    canonical_segments.hash
-  end
-
-  def init_with(coder) # :nodoc:
-    yaml_initialize coder.tag, coder.map
-  end
-
-  def inspect # :nodoc:
-    "#<#{self.class} #{version.inspect}>"
-  end
-
-  ##
-  # Dump only the raw version string, not the complete object. It's a
-  # string for backwards (RubyGems 1.3.5 and earlier) compatibility.
-
-  def marshal_dump
-    [@version]
-  end
-
-  ##
-  # Load custom marshal format. It's a string for backwards (RubyGems
-  # 1.3.5 and earlier) compatibility.
-
-  def marshal_load(array)
-    string = array[0]
-    raise TypeError, "wrong version string" unless string.is_a?(String)
-
-    initialize string
-  end
-
-  def yaml_initialize(tag, map) # :nodoc:
-    @version = -map["version"]
-    @segments = nil
-    @hash = nil
-  end
-
-  def encode_with(coder) # :nodoc:
-    coder.add "version", @version
-  end
-
-  ##
-  # A version is considered a prerelease if it contains a letter.
-
-  def prerelease?
-    unless instance_variable_defined? :@prerelease
-      @prerelease = /[a-zA-Z]/.match?(version)
-    end
-    @prerelease
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.text "Gem::Version.new(#{version.inspect})"
-  end
-
-  ##
-  # The release for this version (e.g. 1.2.0.a -> 1.2.0).
-  # Non-prerelease versions return themselves.
-
-  def release
-    @@release[self] ||= if prerelease?
-      segments = self.segments
-      segments.pop while segments.any? {|s| String === s }
-      self.class.new segments.join(".")
-    else
-      self
-    end
-  end
-
-  def segments # :nodoc:
-    _segments.dup
-  end
-
-  ##
-  # A recommended version for use with a ~> Requirement.
-
-  def approximate_recommendation
-    segments = self.segments
-
-    segments.pop    while segments.any? {|s| String === s }
-    segments.pop    while segments.size > 2
-    segments.push 0 while segments.size < 2
-
-    recommendation = "~> #{segments.join(".")}"
-    recommendation += ".a" if prerelease?
-    recommendation
-  end
-
-  ##
-  # Compares this version with +other+ returning -1, 0, or 1 if the
-  # other version is larger, the same, or smaller than this
-  # one. Attempts to compare to something that's not a
-  # <tt>Gem::Version</tt> or a valid version String return +nil+.
-
-  def <=>(other)
-    return self <=> self.class.new(other) if (String === other) && self.class.correct?(other)
-
-    return unless Gem::Version === other
-    return 0 if @version == other.version || canonical_segments == other.canonical_segments
-
-    lhsegments = canonical_segments
-    rhsegments = other.canonical_segments
-
-    lhsize = lhsegments.size
-    rhsize = rhsegments.size
-    limit  = (lhsize > rhsize ? rhsize : lhsize)
-
-    i = 0
-
-    while i < limit
-      lhs = lhsegments[i]
-      rhs = rhsegments[i]
-      i += 1
-
-      next      if lhs == rhs
-      return -1 if String  === lhs && Numeric === rhs
-      return  1 if Numeric === lhs && String  === rhs
-
-      return lhs <=> rhs
-    end
-
-    lhs = lhsegments[i]
-
-    if lhs.nil?
-      rhs = rhsegments[i]
-
-      while i < rhsize
-        return 1 if String === rhs
-        return -1 unless rhs.zero?
-        rhs = rhsegments[i += 1]
-      end
-    else
-      while i < lhsize
-        return -1 if String === lhs
-        return 1 unless lhs.zero?
-        lhs = lhsegments[i += 1]
-      end
-    end
-
-    0
-  end
-
-  # remove trailing zeros segments before first letter or at the end of the version
-  def canonical_segments
-    @canonical_segments ||= begin
-      # remove trailing 0 segments, using dot or letter as anchor
-      # may leave a trailing dot which will be ignored by partition_segments
-      canonical_version = @version.sub(/(?<=[a-zA-Z.])[.0]+\z/, "")
-      # remove 0 segments before the first letter in a prerelease version
-      canonical_version.sub!(/(?<=\.|\A)[0.]+(?=[a-zA-Z])/, "") if prerelease?
-      partition_segments(canonical_version)
-    end
-  end
-
-  def freeze
-    prerelease?
-    _segments
-    canonical_segments
-    super
-  end
-
-  protected
-
-  def _segments
-    # segments is lazy so it can pick up version values that come from
-    # old marshaled versions, which don't go through marshal_load.
-    # since this version object is cached in @@all, its @segments should be frozen
-    @segments ||= partition_segments(@version)
-  end
-
-  def partition_segments(ver)
-    ver.scan(/\d+|[a-z]+/i).map! do |s|
-      /\A\d/.match?(s) ? s.to_i : -s
-    end.freeze
-  end
-end

package/lib/ruby/3.4.11/rubygems/version_option.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
-# All rights reserved.
-# See LICENSE.txt for permissions.
-#++
-
-require_relative "../rubygems"
-
-##
-# Mixin methods for --version and --platform Gem::Command options.
-
-module Gem::VersionOption
-  ##
-  # Add the --platform option to the option parser.
-
-  def add_platform_option(task = command, *wrap)
-    Gem::OptionParser.accept Gem::Platform do |value|
-      if value == Gem::Platform::RUBY
-        value
-      else
-        Gem::Platform.new value
-      end
-    end
-
-    add_option("--platform PLATFORM", Gem::Platform,
-               "Specify the platform of gem to #{task}", *wrap) do |value, options|
-      unless options[:added_platform]
-        Gem.platforms = [Gem::Platform::RUBY]
-        options[:added_platform] = true
-      end
-
-      Gem.platforms << value unless Gem.platforms.include? value
-    end
-  end
-
-  ##
-  # Add the --prerelease option to the option parser.
-
-  def add_prerelease_option(*wrap)
-    add_option("--[no-]prerelease",
-               "Allow prerelease versions of a gem", *wrap) do |value, options|
-      options[:prerelease] = value
-      options[:explicit_prerelease] = true
-    end
-  end
-
-  ##
-  # Add the --version option to the option parser.
-
-  def add_version_option(task = command, *wrap)
-    Gem::OptionParser.accept Gem::Requirement do |value|
-      Gem::Requirement.new(*value.split(/\s*,\s*/))
-    end
-
-    add_option("-v", "--version VERSION", Gem::Requirement,
-               "Specify version of gem to #{task}", *wrap) do |value, options|
-      # Allow handling for multiple --version operators
-      if options[:version] && !options[:version].none?
-        options[:version].concat([value])
-      else
-        options[:version] = value
-      end
-
-      explicit_prerelease_set = !options[:explicit_prerelease].nil?
-      options[:explicit_prerelease] = false unless explicit_prerelease_set
-
-      options[:prerelease] = value.prerelease? unless
-        options[:explicit_prerelease]
-    end
-  end
-
-  ##
-  # Extract platform given on the command line
-
-  def get_platform_from_requirements(requirements)
-    Gem.platforms[1].to_s if requirements.key? :added_platform
-  end
-end

package/lib/ruby/3.4.11/rubygems/yaml_serializer.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Gem
-  # A stub yaml serializer that can handle only hashes and strings (as of now).
-  module YAMLSerializer
-    module_function
-
-    def dump(hash)
-      yaml = String.new("---")
-      yaml << dump_hash(hash)
-    end
-
-    def dump_hash(hash)
-      yaml = String.new("\n")
-      hash.each do |k, v|
-        yaml << k << ":"
-        if v.is_a?(Hash)
-          yaml << dump_hash(v).gsub(/^(?!$)/, "  ") # indent all non-empty lines
-        elsif v.is_a?(Array) # Expected to be array of strings
-          if v.empty?
-            yaml << " []\n"
-          else
-            yaml << "\n- " << v.map {|s| s.to_s.gsub(/\s+/, " ").inspect }.join("\n- ") << "\n"
-          end
-        else
-          yaml << " " << v.to_s.gsub(/\s+/, " ").inspect << "\n"
-        end
-      end
-      yaml
-    end
-
-    ARRAY_REGEX = /
-      ^
-      (?:[ ]*-[ ]) # '- ' before array items
-      (['"]?) # optional opening quote
-      (.*) # value
-      \1 # matching closing quote
-      $
-    /xo
-
-    HASH_REGEX = /
-      ^
-      ([ ]*) # indentations
-      ([^#]+) # key excludes comment char '#'
-      (?::(?=(?:\s|$))) # :  (without the lookahead the #key includes this when : is present in value)
-      [ ]?
-      (['"]?) # optional opening quote
-      (.*) # value
-      \3 # matching closing quote
-      $
-    /xo
-
-    def load(str)
-      res = {}
-      stack = [res]
-      last_hash = nil
-      last_empty_key = nil
-      str.split(/\r?\n/) do |line|
-        if match = HASH_REGEX.match(line)
-          indent, key, quote, val = match.captures
-          val = strip_comment(val)
-
-          depth = indent.size / 2
-          if quote.empty? && val.empty?
-            new_hash = {}
-            stack[depth][key] = new_hash
-            stack[depth + 1] = new_hash
-            last_empty_key = key
-            last_hash = stack[depth]
-          else
-            val = [] if val == "[]" # empty array
-            stack[depth][key] = val
-          end
-        elsif match = ARRAY_REGEX.match(line)
-          _, val = match.captures
-          val = strip_comment(val)
-
-          last_hash[last_empty_key] = [] unless last_hash[last_empty_key].is_a?(Array)
-
-          last_hash[last_empty_key].push(val)
-        end
-      end
-      res
-    end
-
-    def strip_comment(val)
-      if val.include?("#") && !val.start_with?("#")
-        val.split("#", 2).first.strip
-      else
-        val
-      end
-    end
-
-    class << self
-      private :dump_hash
-    end
-  end
-end