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

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

@@ -1,298 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "version"
-
-##
-# A Requirement is a set of one or more version restrictions. It supports a
-# few (<tt>=, !=, >, <, >=, <=, ~></tt>) different restriction operators.
-#
-# See Gem::Version for a description on how versions and requirements work
-# together in RubyGems.
-
-class Gem::Requirement
-  OPS = { # :nodoc:
-    "=" => lambda {|v, r| v == r },
-    "!=" => lambda {|v, r| v != r },
-    ">" => lambda {|v, r| v > r },
-    "<" => lambda {|v, r| v < r },
-    ">=" => lambda {|v, r| v >= r },
-    "<=" => lambda {|v, r| v <= r },
-    "~>" => lambda {|v, r| v >= r && v.release < r.bump },
-  }.freeze
-
-  SOURCE_SET_REQUIREMENT = Struct.new(:for_lockfile).new "!" # :nodoc:
-
-  quoted = Regexp.union(OPS.keys)
-  PATTERN_RAW = "\\s*(#{quoted})?\\s*(#{Gem::Version::VERSION_PATTERN})\\s*".freeze # :nodoc:
-
-  ##
-  # A regular expression that matches a requirement
-
-  PATTERN = /\A#{PATTERN_RAW}\z/
-
-  ##
-  # The default requirement matches any non-prerelease version
-
-  DefaultRequirement = [">=", Gem::Version.new(0)].freeze
-
-  ##
-  # The default requirement matches any version
-
-  DefaultPrereleaseRequirement = [">=", Gem::Version.new("0.a")].freeze
-
-  ##
-  # Raised when a bad requirement is encountered
-
-  class BadRequirementError < ArgumentError; end
-
-  ##
-  # Factory method to create a Gem::Requirement object.  Input may be
-  # a Version, a String, or nil.  Intended to simplify client code.
-  #
-  # If the input is "weird", the default version requirement is
-  # returned.
-
-  def self.create(*inputs)
-    return new inputs if inputs.length > 1
-
-    input = inputs.shift
-
-    case input
-    when Gem::Requirement then
-      input
-    when Gem::Version, Array then
-      new input
-    when "!" then
-      source_set
-    else
-      if input.respond_to? :to_str
-        new [input.to_str]
-      else
-        default
-      end
-    end
-  end
-
-  def self.default
-    new ">= 0"
-  end
-
-  def self.default_prerelease
-    new ">= 0.a"
-  end
-
-  ###
-  # A source set requirement, used for Gemfiles and lockfiles
-
-  def self.source_set # :nodoc:
-    SOURCE_SET_REQUIREMENT
-  end
-
-  ##
-  # Parse +obj+, returning an <tt>[op, version]</tt> pair. +obj+ can
-  # be a String or a Gem::Version.
-  #
-  # If +obj+ is a String, it can be either a full requirement
-  # specification, like <tt>">= 1.2"</tt>, or a simple version number,
-  # like <tt>"1.2"</tt>.
-  #
-  #     parse("> 1.0")                 # => [">", Gem::Version.new("1.0")]
-  #     parse("1.0")                   # => ["=", Gem::Version.new("1.0")]
-  #     parse(Gem::Version.new("1.0")) # => ["=,  Gem::Version.new("1.0")]
-
-  def self.parse(obj)
-    return ["=", obj] if Gem::Version === obj
-
-    unless PATTERN =~ obj.to_s
-      raise BadRequirementError, "Illformed requirement [#{obj.inspect}]"
-    end
-    op = -($1 || "=")
-    version = -$2
-
-    if op == ">=" && version == "0"
-      DefaultRequirement
-    elsif op == ">=" && version == "0.a"
-      DefaultPrereleaseRequirement
-    else
-      [op, Gem::Version.new(version)]
-    end
-  end
-
-  ##
-  # An array of requirement pairs. The first element of the pair is
-  # the op, and the second is the Gem::Version.
-
-  attr_reader :requirements # :nodoc:
-
-  ##
-  # Constructs a requirement from +requirements+. Requirements can be
-  # Strings, Gem::Versions, or Arrays of those. +nil+ and duplicate
-  # requirements are ignored. An empty set of +requirements+ is the
-  # same as <tt>">= 0"</tt>.
-
-  def initialize(*requirements)
-    requirements = requirements.flatten
-    requirements.compact!
-    requirements.uniq!
-
-    if requirements.empty?
-      @requirements = [DefaultRequirement]
-    else
-      @requirements = requirements.map! {|r| self.class.parse r }
-    end
-  end
-
-  ##
-  # Concatenates the +new+ requirements onto this requirement.
-
-  def concat(new)
-    new = new.flatten
-    new.compact!
-    new.uniq!
-    new = new.map {|r| self.class.parse r }
-
-    @requirements.concat new
-  end
-
-  ##
-  # Formats this requirement for use in a Gem::RequestSet::Lockfile.
-
-  def for_lockfile # :nodoc:
-    return if @requirements == [DefaultRequirement]
-
-    list = requirements.sort_by do |_, version|
-      version
-    end.map do |op, version|
-      "#{op} #{version}"
-    end.uniq
-
-    " (#{list.join ", "})"
-  end
-
-  ##
-  # true if this gem has no requirements.
-
-  def none?
-    if @requirements.size == 1
-      @requirements[0] == DefaultRequirement
-    else
-      false
-    end
-  end
-
-  ##
-  # true if the requirement is for only an exact version
-
-  def exact?
-    return false unless @requirements.size == 1
-    @requirements[0][0] == "="
-  end
-
-  def as_list # :nodoc:
-    requirements.map {|op, version| "#{op} #{version}" }
-  end
-
-  def hash # :nodoc:
-    requirements.map {|r| r.first == "~>" ? [r[0], r[1].to_s] : r }.sort.hash
-  end
-
-  def marshal_dump # :nodoc:
-    [@requirements]
-  end
-
-  def marshal_load(array) # :nodoc:
-    @requirements = array[0]
-
-    raise TypeError, "wrong @requirements" unless Array === @requirements &&
-                                                  @requirements.all? {|r| r.size == 2 && (r.first.is_a?(String) || r[0] = "=") && r.last.is_a?(Gem::Version) }
-  end
-
-  def yaml_initialize(tag, vals) # :nodoc:
-    vals.each do |ivar, val|
-      instance_variable_set "@#{ivar}", val
-    end
-  end
-
-  def init_with(coder) # :nodoc:
-    yaml_initialize coder.tag, coder.map
-  end
-
-  def encode_with(coder) # :nodoc:
-    coder.add "requirements", @requirements
-  end
-
-  ##
-  # A requirement is a prerelease if any of the versions inside of it
-  # are prereleases
-
-  def prerelease?
-    requirements.any? {|r| r.last.prerelease? }
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group 1, "Gem::Requirement.new(", ")" do
-      q.pp as_list
-    end
-  end
-
-  ##
-  # True if +version+ satisfies this Requirement.
-
-  def satisfied_by?(version)
-    raise ArgumentError, "Need a Gem::Version: #{version.inspect}" unless
-      Gem::Version === version
-    requirements.all? {|op, rv| OPS.fetch(op).call version, rv }
-  end
-
-  alias_method :===, :satisfied_by?
-  alias_method :=~, :satisfied_by?
-
-  ##
-  # True if the requirement will not always match the latest version.
-
-  def specific?
-    return true if @requirements.length > 1 # GIGO, > 1, > 2 is silly
-
-    !%w[> >=].include? @requirements.first.first # grab the operator
-  end
-
-  def to_s # :nodoc:
-    as_list.join ", "
-  end
-
-  def ==(other) # :nodoc:
-    return unless Gem::Requirement === other
-
-    # An == check is always necessary
-    return false unless _sorted_requirements == other._sorted_requirements
-
-    # An == check is sufficient unless any requirements use ~>
-    return true unless _tilde_requirements.any?
-
-    # If any requirements use ~> we use the stricter `#eql?` that also checks
-    # that version precision is the same
-    _tilde_requirements.eql?(other._tilde_requirements)
-  end
-
-  protected
-
-  def _sorted_requirements
-    @_sorted_requirements ||= requirements.sort_by(&:to_s)
-  end
-
-  def _tilde_requirements
-    @_tilde_requirements ||= _sorted_requirements.select {|r| r.first == "~>" }
-  end
-
-  def initialize_copy(other) # :nodoc:
-    @requirements = other.requirements.dup
-    super
-  end
-end
-
-class Gem::Version
-  # This is needed for compatibility with older yaml
-  # gemspecs.
-
-  Requirement = Gem::Requirement # :nodoc:
-end

package/lib/ruby/3.4.11/rubygems/resolver/activation_request.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-##
-# Specifies a Specification object that should be activated.  Also contains a
-# dependency that was used to introduce this activation.
-
-class Gem::Resolver::ActivationRequest
-  ##
-  # The parent request for this activation request.
-
-  attr_reader :request
-
-  ##
-  # The specification to be activated.
-
-  attr_reader :spec
-
-  ##
-  # Creates a new ActivationRequest that will activate +spec+.  The parent
-  # +request+ is used to provide diagnostics in case of conflicts.
-
-  def initialize(spec, request)
-    @spec = spec
-    @request = request
-  end
-
-  def ==(other) # :nodoc:
-    case other
-    when Gem::Specification
-      @spec == other
-    when Gem::Resolver::ActivationRequest
-      @spec == other.spec
-    else
-      false
-    end
-  end
-
-  def eql?(other)
-    self == other
-  end
-
-  def hash
-    @spec.hash
-  end
-
-  ##
-  # Is this activation request for a development dependency?
-
-  def development?
-    @request.development?
-  end
-
-  ##
-  # Downloads a gem at +path+ and returns the file path.
-
-  def download(path)
-    Gem.ensure_gem_subdirectories path
-
-    if @spec.respond_to? :sources
-      exception = nil
-      path = @spec.sources.find do |source|
-        source.download full_spec, path
-      rescue exception
-      end
-      return path      if path
-      raise  exception if exception
-
-    elsif @spec.respond_to? :source
-      source = @spec.source
-      source.download full_spec, path
-
-    else
-      source = Gem.sources.first
-      source.download full_spec, path
-    end
-  end
-
-  ##
-  # The full name of the specification to be activated.
-
-  def full_name
-    name_tuple.full_name
-  end
-
-  alias_method :to_s, :full_name
-
-  ##
-  # The Gem::Specification for this activation request.
-
-  def full_spec
-    Gem::Specification === @spec ? @spec : @spec.spec
-  end
-
-  def inspect # :nodoc:
-    format("#<%s for %p from %s>", self.class, @spec, @request)
-  end
-
-  ##
-  # True if the requested gem has already been installed.
-
-  def installed?
-    case @spec
-    when Gem::Resolver::VendorSpecification then
-      true
-    else
-      this_spec = full_spec
-
-      Gem::Specification.any? do |s|
-        s == this_spec && s.base_dir == this_spec.base_dir
-      end
-    end
-  end
-
-  ##
-  # The name of this activation request's specification
-
-  def name
-    @spec.name
-  end
-
-  ##
-  # Return the ActivationRequest that contained the dependency
-  # that we were activated for.
-
-  def parent
-    @request.requester
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group 2, "[Activation request", "]" do
-      q.breakable
-      q.pp @spec
-
-      q.breakable
-      q.text " for "
-      q.pp @request
-    end
-  end
-
-  ##
-  # The version of this activation request's specification
-
-  def version
-    @spec.version
-  end
-
-  ##
-  # The platform of this activation request's specification
-
-  def platform
-    @spec.platform
-  end
-
-  private
-
-  def name_tuple
-    @name_tuple ||= Gem::NameTuple.new(name, version, platform)
-  end
-end

package/lib/ruby/3.4.11/rubygems/resolver/api_set/gem_parser.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-class Gem::Resolver::APISet::GemParser
-  def parse(line)
-    version_and_platform, rest = line.split(" ", 2)
-    version, platform = version_and_platform.split("-", 2)
-    dependencies, requirements = rest.split("|", 2).map! {|s| s.split(",") } if rest
-    dependencies = dependencies ? dependencies.map! {|d| parse_dependency(d) } : []
-    requirements = requirements ? requirements.map! {|d| parse_dependency(d) } : []
-    [version, platform, dependencies, requirements]
-  end
-
-  private
-
-  def parse_dependency(string)
-    dependency = string.split(":")
-    dependency[-1] = dependency[-1].split("&") if dependency.size > 1
-    dependency[0] = -dependency[0]
-    dependency
-  end
-end

package/lib/ruby/3.4.11/rubygems/resolver/api_set.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-##
-# The global rubygems pool, available via the rubygems.org API.
-# Returns instances of APISpecification.
-
-class Gem::Resolver::APISet < Gem::Resolver::Set
-  autoload :GemParser, File.expand_path("api_set/gem_parser", __dir__)
-
-  ##
-  # The URI for the dependency API this APISet uses.
-
-  attr_reader :dep_uri # :nodoc:
-
-  ##
-  # The Gem::Source that gems are fetched from
-
-  attr_reader :source
-
-  ##
-  # The corresponding place to fetch gems.
-
-  attr_reader :uri
-
-  ##
-  # Creates a new APISet that will retrieve gems from +uri+ using the RubyGems
-  # API URL +dep_uri+ which is described at
-  # https://guides.rubygems.org/rubygems-org-api
-
-  def initialize(dep_uri = "https://index.rubygems.org/info/")
-    super()
-
-    dep_uri = Gem::URI dep_uri unless Gem::URI === dep_uri
-
-    @dep_uri = dep_uri
-    @uri     = dep_uri + ".."
-
-    @data   = Hash.new {|h,k| h[k] = [] }
-    @source = Gem::Source.new @uri
-
-    @to_fetch = []
-  end
-
-  ##
-  # Return an array of APISpecification objects matching
-  # DependencyRequest +req+.
-
-  def find_all(req)
-    res = []
-
-    return res unless @remote
-
-    if @to_fetch.include?(req.name)
-      prefetch_now
-    end
-
-    versions(req.name).each do |ver|
-      if req.dependency.match? req.name, ver[:number], @prerelease
-        res << Gem::Resolver::APISpecification.new(self, ver)
-      end
-    end
-
-    res
-  end
-
-  ##
-  # A hint run by the resolver to allow the Set to fetch
-  # data for DependencyRequests +reqs+.
-
-  def prefetch(reqs)
-    return unless @remote
-    names = reqs.map {|r| r.dependency.name }
-    needed = names - @data.keys - @to_fetch
-
-    @to_fetch += needed
-  end
-
-  def prefetch_now # :nodoc:
-    needed = @to_fetch
-    @to_fetch = []
-
-    needed.sort.each do |name|
-      versions(name)
-    end
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group 2, "[APISet", "]" do
-      q.breakable
-      q.text "URI: #{@dep_uri}"
-
-      q.breakable
-      q.text "gem names:"
-      q.pp @data.keys
-    end
-  end
-
-  ##
-  # Return data for all versions of the gem +name+.
-
-  def versions(name) # :nodoc:
-    if @data.key?(name)
-      return @data[name]
-    end
-
-    uri = @dep_uri + name
-
-    begin
-      str = Gem::RemoteFetcher.fetcher.fetch_path uri
-    rescue Gem::RemoteFetcher::FetchError
-      @data[name] = []
-    else
-      lines(str).each do |ver|
-        number, platform, dependencies, requirements = parse_gem(ver)
-
-        platform ||= "ruby"
-        dependencies = dependencies.map {|dep_name, reqs| [dep_name, reqs.join(", ")] }
-        requirements = requirements.map {|req_name, reqs| [req_name.to_sym, reqs] }.to_h
-
-        @data[name] << { name: name, number: number, platform: platform, dependencies: dependencies, requirements: requirements }
-      end
-    end
-
-    @data[name]
-  end
-
-  private
-
-  def lines(str)
-    lines = str.split("\n")
-    header = lines.index("---")
-    header ? lines[header + 1..-1] : lines
-  end
-
-  def parse_gem(string)
-    @gem_parser ||= GemParser.new
-    @gem_parser.parse(string)
-  end
-end

package/lib/ruby/3.4.11/rubygems/resolver/api_specification.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-##
-# Represents a specification retrieved via the rubygems.org API.
-#
-# This is used to avoid loading the full Specification object when all we need
-# is the name, version, and dependencies.
-
-class Gem::Resolver::APISpecification < Gem::Resolver::Specification
-  ##
-  # We assume that all instances of this class are immutable;
-  # so avoid duplicated generation for performance.
-  @@cache = {}
-  def self.new(set, api_data)
-    cache_key = [set, api_data]
-    cache = @@cache[cache_key]
-    return cache if cache
-    @@cache[cache_key] = super
-  end
-
-  ##
-  # Creates an APISpecification for the given +set+ from the rubygems.org
-  # +api_data+.
-  #
-  # See https://guides.rubygems.org/rubygems-org-api/#misc-methods for the
-  # format of the +api_data+.
-
-  def initialize(set, api_data)
-    super()
-
-    @set = set
-    @name = api_data[:name]
-    @version = Gem::Version.new(api_data[:number]).freeze
-    @platform = Gem::Platform.new(api_data[:platform]).freeze
-    @original_platform = api_data[:platform].freeze
-    @dependencies = api_data[:dependencies].map do |name, ver|
-      Gem::Dependency.new(name, ver.split(/\s*,\s*/)).freeze
-    end.freeze
-    @required_ruby_version = Gem::Requirement.new(api_data.dig(:requirements, :ruby)).freeze
-    @required_rubygems_version = Gem::Requirement.new(api_data.dig(:requirements, :rubygems)).freeze
-  end
-
-  def ==(other) # :nodoc:
-    self.class === other &&
-      @set          == other.set &&
-      @name         == other.name &&
-      @version      == other.version &&
-      @platform     == other.platform
-  end
-
-  def hash
-    @set.hash ^ @name.hash ^ @version.hash ^ @platform.hash
-  end
-
-  def fetch_development_dependencies # :nodoc:
-    spec = source.fetch_spec Gem::NameTuple.new @name, @version, @platform
-
-    @dependencies = spec.dependencies
-  end
-
-  def installable_platform? # :nodoc:
-    Gem::Platform.match_gem? @platform, @name
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group 2, "[APISpecification", "]" do
-      q.breakable
-      q.text "name: #{name}"
-
-      q.breakable
-      q.text "version: #{version}"
-
-      q.breakable
-      q.text "platform: #{platform}"
-
-      q.breakable
-      q.text "dependencies:"
-      q.breakable
-      q.pp @dependencies
-
-      q.breakable
-      q.text "set uri: #{@set.dep_uri}"
-    end
-  end
-
-  ##
-  # Fetches a Gem::Specification for this APISpecification.
-
-  def spec # :nodoc:
-    @spec ||=
-      begin
-        tuple = Gem::NameTuple.new @name, @version, @platform
-        source.fetch_spec tuple
-      rescue Gem::RemoteFetcher::FetchError
-        raise if @original_platform == @platform
-
-        tuple = Gem::NameTuple.new @name, @version, @original_platform
-        source.fetch_spec tuple
-      end
-  end
-
-  def source # :nodoc:
-    @set.source
-  end
-end