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

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

@@ -0,0 +1,298 @@
+# 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.0/rubygems/resolver/activation_request.rb

@@ -0,0 +1,159 @@
+# 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.0/rubygems/resolver/api_set/gem_parser.rb

@@ -0,0 +1,21 @@
+# 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.0/rubygems/resolver/api_set.rb

@@ -0,0 +1,139 @@
+# 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.0/rubygems/resolver/api_specification.rb

@@ -0,0 +1,105 @@
+# 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