@ai-ecoverse/wasix-ruby 3.4.11-1

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+##
+# Represents a possible Specification object returned from IndexSet.  Used to
+# delay needed to download full Specification objects when only the +name+
+# and +version+ are needed.
+
+class Gem::Resolver::IndexSpecification < Gem::Resolver::Specification
+  ##
+  # An IndexSpecification is created from the index format described in `gem
+  # help generate_index`.
+  #
+  # The +set+ contains other specifications for this (URL) +source+.
+  #
+  # The +name+, +version+ and +platform+ are the name, version and platform of
+  # the gem.
+
+  def initialize(set, name, version, source, platform)
+    super()
+
+    @set = set
+    @name = name
+    @version = version
+    @source = source
+    @platform = Gem::Platform.new(platform.to_s)
+    @original_platform = platform.to_s
+
+    @spec = nil
+  end
+
+  ##
+  # The dependencies of the gem for this specification
+
+  def dependencies
+    spec.dependencies
+  end
+
+  ##
+  # The required_ruby_version constraint for this specification
+  #
+  # A fallback is included because when generated, some marshalled specs have it
+  # set to +nil+.
+
+  def required_ruby_version
+    spec.required_ruby_version || Gem::Requirement.default
+  end
+
+  ##
+  # The required_rubygems_version constraint for this specification
+  #
+  # A fallback is included because the original version of the specification
+  # API didn't include that field, so some marshalled specs in the index have it
+  # set to +nil+.
+
+  def required_rubygems_version
+    spec.required_rubygems_version || Gem::Requirement.default
+  end
+
+  def ==(other)
+    self.class === other &&
+      @name == other.name &&
+      @version == other.version &&
+      @platform == other.platform
+  end
+
+  def hash
+    @name.hash ^ @version.hash ^ @platform.hash
+  end
+
+  def inspect # :nodoc:
+    format("#<%s %s source %s>", self.class, full_name, @source)
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group 2, "[Index specification", "]" do
+      q.breakable
+      q.text full_name
+
+      unless @platform == Gem::Platform::RUBY
+        q.breakable
+        q.text @platform.to_s
+      end
+
+      q.breakable
+      q.text "source "
+      q.pp @source
+    end
+  end
+
+  ##
+  # Fetches a Gem::Specification for this IndexSpecification from the #source.
+
+  def spec # :nodoc:
+    @spec ||=
+      begin
+        tuple = Gem::NameTuple.new @name, @version, @original_platform
+
+        @source.fetch_spec tuple
+      end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+##
+# An InstalledSpecification represents a gem that is already installed
+# locally.
+
+class Gem::Resolver::InstalledSpecification < Gem::Resolver::SpecSpecification
+  def ==(other) # :nodoc:
+    self.class === other &&
+      @set  == other.set &&
+      @spec == other.spec
+  end
+
+  ##
+  # This is a null install as this specification is already installed.
+  # +options+ are ignored.
+
+  def install(options = {})
+    yield nil
+  end
+
+  ##
+  # Returns +true+ if this gem is installable for the current platform.
+
+  def installable_platform?
+    # BACKCOMPAT If the file is coming out of a specified file, then we
+    # ignore the platform. This code can be removed in RG 3.0.
+    return true if @source.is_a? Gem::Source::SpecificFile
+
+    super
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group 2, "[InstalledSpecification", "]" 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 spec.dependencies
+    end
+  end
+
+  ##
+  # The source for this specification
+
+  def source
+    @source ||= Gem::Source::Installed.new
+  end
+end

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

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+##
+# A set of gems for installation sourced from remote sources and local .gem
+# files
+
+class Gem::Resolver::InstallerSet < Gem::Resolver::Set
+  ##
+  # List of Gem::Specification objects that must always be installed.
+
+  attr_reader :always_install # :nodoc:
+
+  ##
+  # Only install gems in the always_install list
+
+  attr_accessor :ignore_dependencies # :nodoc:
+
+  ##
+  # Do not look in the installed set when finding specifications.  This is
+  # used by the --install-dir option to `gem install`
+
+  attr_accessor :ignore_installed # :nodoc:
+
+  ##
+  # The remote_set looks up remote gems for installation.
+
+  attr_reader :remote_set # :nodoc:
+
+  ##
+  # Ignore ruby & rubygems specification constraints.
+  #
+
+  attr_accessor :force # :nodoc:
+
+  ##
+  # Creates a new InstallerSet that will look for gems in +domain+.
+
+  def initialize(domain)
+    super()
+
+    @domain = domain
+
+    @f = Gem::SpecFetcher.fetcher
+
+    @always_install      = []
+    @ignore_dependencies = false
+    @ignore_installed    = false
+    @local               = {}
+    @local_source        = Gem::Source::Local.new
+    @remote_set          = Gem::Resolver::BestSet.new
+    @force               = false
+    @specs               = {}
+  end
+
+  ##
+  # Looks up the latest specification for +dependency+ and adds it to the
+  # always_install list.
+
+  def add_always_install(dependency)
+    request = Gem::Resolver::DependencyRequest.new dependency, nil
+
+    found = find_all request
+
+    found.delete_if do |s|
+      s.version.prerelease? && !s.local?
+    end unless dependency.prerelease?
+
+    found = found.select do |s|
+      Gem::Source::SpecificFile === s.source ||
+        Gem::Platform.match_spec?(s)
+    end
+
+    found = found.sort_by do |s|
+      [s.version, Gem::Platform.sort_priority(s.platform)]
+    end
+
+    newest = found.last
+
+    unless newest
+      exc = Gem::UnsatisfiableDependencyError.new request
+      exc.errors = errors
+
+      raise exc
+    end
+
+    unless @force
+      found_matching_metadata = found.reverse.find do |spec|
+        metadata_satisfied?(spec)
+      end
+
+      if found_matching_metadata.nil?
+        ensure_required_ruby_version_met(newest.spec)
+        ensure_required_rubygems_version_met(newest.spec)
+      else
+        newest = found_matching_metadata
+      end
+    end
+
+    @always_install << newest.spec
+  end
+
+  ##
+  # Adds a local gem requested using +dep_name+ with the given +spec+ that can
+  # be loaded and installed using the +source+.
+
+  def add_local(dep_name, spec, source)
+    @local[dep_name] = [spec, source]
+  end
+
+  ##
+  # Should local gems should be considered?
+
+  def consider_local? # :nodoc:
+    @domain == :both || @domain == :local
+  end
+
+  ##
+  # Should remote gems should be considered?
+
+  def consider_remote? # :nodoc:
+    @domain == :both || @domain == :remote
+  end
+
+  ##
+  # Errors encountered while resolving gems
+
+  def errors
+    @errors + @remote_set.errors
+  end
+
+  ##
+  # Returns an array of IndexSpecification objects matching DependencyRequest
+  # +req+.
+
+  def find_all(req)
+    res = []
+
+    dep = req.dependency
+
+    return res if @ignore_dependencies &&
+                  @always_install.none? {|spec| dep.match? spec }
+
+    name = dep.name
+
+    dep.matching_specs.each do |gemspec|
+      next if @always_install.any? {|spec| spec.name == gemspec.name }
+
+      res << Gem::Resolver::InstalledSpecification.new(self, gemspec)
+    end unless @ignore_installed
+
+    matching_local = []
+
+    if consider_local?
+      matching_local = @local.values.select do |spec, _|
+        req.match? spec
+      end.map do |spec, source|
+        Gem::Resolver::LocalSpecification.new self, spec, source
+      end
+
+      res.concat matching_local
+
+      begin
+        if local_spec = @local_source.find_gem(name, dep.requirement)
+          res << Gem::Resolver::IndexSpecification.new(
+            self, local_spec.name, local_spec.version,
+            @local_source, local_spec.platform
+          )
+        end
+      rescue Gem::Package::FormatError
+        # ignore
+      end
+    end
+
+    res.concat @remote_set.find_all req if consider_remote? && matching_local.empty?
+
+    res
+  end
+
+  def prefetch(reqs)
+    @remote_set.prefetch(reqs) if consider_remote?
+  end
+
+  def prerelease=(allow_prerelease)
+    super
+
+    @remote_set.prerelease = allow_prerelease
+  end
+
+  def inspect # :nodoc:
+    always_install = @always_install.map(&:full_name)
+
+    format("#<%s domain: %s specs: %p always install: %p>", self.class, @domain, @specs.keys, always_install)
+  end
+
+  ##
+  # Called from IndexSpecification to get a true Specification
+  # object.
+
+  def load_spec(name, ver, platform, source) # :nodoc:
+    key = "#{name}-#{ver}-#{platform}"
+
+    @specs.fetch key do
+      tuple = Gem::NameTuple.new name, ver, platform
+
+      @specs[key] = source.fetch_spec tuple
+    end
+  end
+
+  ##
+  # Has a local gem for +dep_name+ been added to this set?
+
+  def local?(dep_name) # :nodoc:
+    spec, _ = @local[dep_name]
+
+    spec
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group 2, "[InstallerSet", "]" do
+      q.breakable
+      q.text "domain: #{@domain}"
+
+      q.breakable
+      q.text "specs: "
+      q.pp @specs.keys
+
+      q.breakable
+      q.text "always install: "
+      q.pp @always_install
+    end
+  end
+
+  def remote=(remote) # :nodoc:
+    case @domain
+    when :local then
+      @domain = :both if remote
+    when :remote then
+      @domain = nil unless remote
+    when :both then
+      @domain = :local unless remote
+    end
+  end
+
+  private
+
+  def metadata_satisfied?(spec)
+    spec.required_ruby_version.satisfied_by?(Gem.ruby_version) &&
+      spec.required_rubygems_version.satisfied_by?(Gem.rubygems_version)
+  end
+
+  def ensure_required_ruby_version_met(spec) # :nodoc:
+    if rrv = spec.required_ruby_version
+      ruby_version = Gem.ruby_version
+      unless rrv.satisfied_by? ruby_version
+        raise Gem::RuntimeRequirementNotMetError,
+          "#{spec.full_name} requires Ruby version #{rrv}. The current ruby version is #{ruby_version}."
+      end
+    end
+  end
+
+  def ensure_required_rubygems_version_met(spec) # :nodoc:
+    if rrgv = spec.required_rubygems_version
+      unless rrgv.satisfied_by? Gem.rubygems_version
+        rg_version = Gem::VERSION
+        raise Gem::RuntimeRequirementNotMetError,
+          "#{spec.full_name} requires RubyGems version #{rrgv}. The current RubyGems version is #{rg_version}. " \
+          "Try 'gem update --system' to update RubyGems itself."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+##
+# A LocalSpecification comes from a .gem file on the local filesystem.
+
+class Gem::Resolver::LocalSpecification < Gem::Resolver::SpecSpecification
+  ##
+  # Returns +true+ if this gem is installable for the current platform.
+
+  def installable_platform?
+    return true if @source.is_a? Gem::Source::SpecificFile
+
+    super
+  end
+
+  def local? # :nodoc:
+    true
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group 2, "[LocalSpecification", "]" 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 "source: #{@source.path}"
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+##
+# A set of gems from a gem dependencies lockfile.
+
+class Gem::Resolver::LockSet < Gem::Resolver::Set
+  attr_reader :specs # :nodoc:
+
+  ##
+  # Creates a new LockSet from the given +sources+
+
+  def initialize(sources)
+    super()
+
+    @sources = sources.map do |source|
+      Gem::Source::Lock.new source
+    end
+
+    @specs = []
+  end
+
+  ##
+  # Creates a new IndexSpecification in this set using the given +name+,
+  # +version+ and +platform+.
+  #
+  # The specification's set will be the current set, and the source will be
+  # the current set's source.
+
+  def add(name, version, platform) # :nodoc:
+    version = Gem::Version.new version
+    specs = [
+      Gem::Resolver::LockSpecification.new(self, name, version, @sources, platform),
+    ]
+
+    @specs.concat specs
+
+    specs
+  end
+
+  ##
+  # Returns an Array of IndexSpecification objects matching the
+  # DependencyRequest +req+.
+
+  def find_all(req)
+    @specs.select do |spec|
+      req.match? spec
+    end
+  end
+
+  ##
+  # Loads a Gem::Specification with the given +name+, +version+ and
+  # +platform+.  +source+ is ignored.
+
+  def load_spec(name, version, platform, source) # :nodoc:
+    dep = Gem::Dependency.new name, version
+
+    found = @specs.find do |spec|
+      dep.matches_spec?(spec) && spec.platform == platform
+    end
+
+    tuple = Gem::NameTuple.new found.name, found.version, found.platform
+
+    found.source.fetch_spec tuple
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group 2, "[LockSet", "]" do
+      q.breakable
+      q.text "source:"
+
+      q.breakable
+      q.pp @source
+
+      q.breakable
+      q.text "specs:"
+
+      q.breakable
+      q.pp @specs.map(&:full_name)
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+##
+# The LockSpecification comes from a lockfile (Gem::RequestSet::Lockfile).
+#
+# A LockSpecification's dependency information is pre-filled from the
+# lockfile.
+
+class Gem::Resolver::LockSpecification < Gem::Resolver::Specification
+  attr_reader :sources
+
+  def initialize(set, name, version, sources, platform)
+    super()
+
+    @name     = name
+    @platform = platform
+    @set      = set
+    @source   = sources.first
+    @sources  = sources
+    @version  = version
+
+    @dependencies = []
+    @spec         = nil
+  end
+
+  ##
+  # This is a null install as a locked specification is considered installed.
+  # +options+ are ignored.
+
+  def install(options = {})
+    destination = options[:install_dir] || Gem.dir
+
+    if File.exist? File.join(destination, "specifications", spec.spec_name)
+      yield nil
+      return
+    end
+
+    super
+  end
+
+  ##
+  # Adds +dependency+ from the lockfile to this specification
+
+  def add_dependency(dependency) # :nodoc:
+    @dependencies << dependency
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group 2, "[LockSpecification", "]" do
+      q.breakable
+      q.text "name: #{@name}"
+
+      q.breakable
+      q.text "version: #{@version}"
+
+      unless @platform == Gem::Platform::RUBY
+        q.breakable
+        q.text "platform: #{@platform}"
+      end
+
+      unless @dependencies.empty?
+        q.breakable
+        q.text "dependencies:"
+        q.breakable
+        q.pp @dependencies
+      end
+    end
+  end
+
+  ##
+  # A specification constructed from the lockfile is returned
+
+  def spec
+    @spec ||= Gem::Specification.find do |spec|
+      spec.name == @name && spec.version == @version
+    end
+
+    @spec ||= Gem::Specification.new do |s|
+      s.name     = @name
+      s.version  = @version
+      s.platform = @platform
+
+      s.dependencies.concat @dependencies
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+##
+# The RequirementList is used to hold the requirements being considered
+# while resolving a set of gems.
+#
+# The RequirementList acts like a queue where the oldest items are removed
+# first.
+
+class Gem::Resolver::RequirementList
+  include Enumerable
+
+  ##
+  # Creates a new RequirementList.
+
+  def initialize
+    @exact = []
+    @list = []
+  end
+
+  def initialize_copy(other) # :nodoc:
+    @exact = @exact.dup
+    @list = @list.dup
+  end
+
+  ##
+  # Adds Resolver::DependencyRequest +req+ to this requirements list.
+
+  def add(req)
+    if req.requirement.exact?
+      @exact.push req
+    else
+      @list.push req
+    end
+    req
+  end
+
+  ##
+  # Enumerates requirements in the list
+
+  def each # :nodoc:
+    return enum_for __method__ unless block_given?
+
+    @exact.each do |requirement|
+      yield requirement
+    end
+
+    @list.each do |requirement|
+      yield requirement
+    end
+  end
+
+  ##
+  # How many elements are in the list
+
+  def size
+    @exact.size + @list.size
+  end
+
+  ##
+  # Is the list empty?
+
+  def empty?
+    @exact.empty? && @list.empty?
+  end
+
+  ##
+  # Remove the oldest DependencyRequest from the list.
+
+  def remove
+    return @exact.shift unless @exact.empty?
+    @list.shift
+  end
+
+  ##
+  # Returns the oldest five entries from the list.
+
+  def next5
+    x = @exact[0,5]
+    x + @list[0,5 - x.size]
+  end
+end