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

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

@@ -1,341 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "dependency"
-require_relative "exceptions"
-require_relative "util/list"
-
-##
-# Given a set of Gem::Dependency objects as +needed+ and a way to query the
-# set of available specs via +set+, calculates a set of ActivationRequest
-# objects which indicate all the specs that should be activated to meet the
-# all the requirements.
-
-class Gem::Resolver
-  require_relative "vendored_molinillo"
-
-  ##
-  # If the DEBUG_RESOLVER environment variable is set then debugging mode is
-  # enabled for the resolver.  This will display information about the state
-  # of the resolver while a set of dependencies is being resolved.
-
-  DEBUG_RESOLVER = !ENV["DEBUG_RESOLVER"].nil?
-
-  ##
-  # Set to true if all development dependencies should be considered.
-
-  attr_accessor :development
-
-  ##
-  # Set to true if immediate development dependencies should be considered.
-
-  attr_accessor :development_shallow
-
-  ##
-  # When true, no dependencies are looked up for requested gems.
-
-  attr_accessor :ignore_dependencies
-
-  ##
-  # List of dependencies that could not be found in the configured sources.
-
-  attr_reader :stats
-
-  ##
-  # Hash of gems to skip resolution.  Keyed by gem name, with arrays of
-  # gem specifications as values.
-
-  attr_accessor :skip_gems
-
-  ##
-  #
-
-  attr_accessor :soft_missing
-
-  ##
-  # Combines +sets+ into a ComposedSet that allows specification lookup in a
-  # uniform manner.  If one of the +sets+ is itself a ComposedSet its sets are
-  # flattened into the result ComposedSet.
-
-  def self.compose_sets(*sets)
-    sets.compact!
-
-    sets = sets.flat_map do |set|
-      case set
-      when Gem::Resolver::BestSet then
-        set
-      when Gem::Resolver::ComposedSet then
-        set.sets
-      else
-        set
-      end
-    end
-
-    case sets.length
-    when 0 then
-      raise ArgumentError, "one set in the composition must be non-nil"
-    when 1 then
-      sets.first
-    else
-      Gem::Resolver::ComposedSet.new(*sets)
-    end
-  end
-
-  ##
-  # Creates a Resolver that queries only against the already installed gems
-  # for the +needed+ dependencies.
-
-  def self.for_current_gems(needed)
-    new needed, Gem::Resolver::CurrentSet.new
-  end
-
-  ##
-  # Create Resolver object which will resolve the tree starting
-  # with +needed+ Dependency objects.
-  #
-  # +set+ is an object that provides where to look for specifications to
-  # satisfy the Dependencies. This defaults to IndexSet, which will query
-  # rubygems.org.
-
-  def initialize(needed, set = nil)
-    @set = set || Gem::Resolver::IndexSet.new
-    @needed = needed
-
-    @development         = false
-    @development_shallow = false
-    @ignore_dependencies = false
-    @skip_gems           = {}
-    @soft_missing        = false
-    @stats               = Gem::Resolver::Stats.new
-  end
-
-  def explain(stage, *data) # :nodoc:
-    return unless DEBUG_RESOLVER
-
-    d = data.map(&:pretty_inspect).join(", ")
-    $stderr.printf "%10s %s\n", stage.to_s.upcase, d
-  end
-
-  def explain_list(stage) # :nodoc:
-    return unless DEBUG_RESOLVER
-
-    data = yield
-    $stderr.printf "%10s (%d entries)\n", stage.to_s.upcase, data.size
-    unless data.empty?
-      require "pp"
-      PP.pp data, $stderr
-    end
-  end
-
-  ##
-  # Creates an ActivationRequest for the given +dep+ and the last +possible+
-  # specification.
-  #
-  # Returns the Specification and the ActivationRequest
-
-  def activation_request(dep, possible) # :nodoc:
-    spec = possible.pop
-
-    explain :activate, [spec.full_name, possible.size]
-    explain :possible, possible
-
-    activation_request =
-      Gem::Resolver::ActivationRequest.new spec, dep, possible
-
-    [spec, activation_request]
-  end
-
-  def requests(s, act, reqs=[]) # :nodoc:
-    return reqs if @ignore_dependencies
-
-    s.fetch_development_dependencies if @development
-
-    s.dependencies.reverse_each do |d|
-      next if d.type == :development && !@development
-      next if d.type == :development && @development_shallow &&
-              act.development?
-      next if d.type == :development && @development_shallow &&
-              act.parent
-
-      reqs << Gem::Resolver::DependencyRequest.new(d, act)
-      @stats.requirement!
-    end
-
-    @set.prefetch reqs
-
-    @stats.record_requirements reqs
-
-    reqs
-  end
-
-  include Gem::Molinillo::UI
-
-  def output
-    @output ||= debug? ? $stdout : File.open(IO::NULL, "w")
-  end
-
-  def debug?
-    DEBUG_RESOLVER
-  end
-
-  include Gem::Molinillo::SpecificationProvider
-
-  ##
-  # Proceed with resolution! Returns an array of ActivationRequest objects.
-
-  def resolve
-    Gem::Molinillo::Resolver.new(self, self).resolve(@needed.map {|d| DependencyRequest.new d, nil }).tsort.filter_map(&:payload)
-  rescue Gem::Molinillo::VersionConflict => e
-    conflict = e.conflicts.values.first
-    raise Gem::DependencyResolutionError, Conflict.new(conflict.requirement_trees.first.first, conflict.existing, conflict.requirement)
-  ensure
-    @output.close if defined?(@output) && !debug?
-  end
-
-  ##
-  # Extracts the specifications that may be able to fulfill +dependency+ and
-  # returns those that match the local platform and all those that match.
-
-  def find_possible(dependency) # :nodoc:
-    all = @set.find_all dependency
-
-    if (skip_dep_gems = skip_gems[dependency.name]) && !skip_dep_gems.empty?
-      matching = all.select do |api_spec|
-        skip_dep_gems.any? {|s| api_spec.version == s.version }
-      end
-
-      all = matching unless matching.empty?
-    end
-
-    matching_platform = select_local_platforms all
-
-    [matching_platform, all]
-  end
-
-  ##
-  # Returns the gems in +specs+ that match the local platform.
-
-  def select_local_platforms(specs) # :nodoc:
-    specs.select do |spec|
-      Gem::Platform.installable? spec
-    end
-  end
-
-  def search_for(dependency)
-    possibles, all = find_possible(dependency)
-    if !@soft_missing && possibles.empty?
-      exc = Gem::UnsatisfiableDependencyError.new dependency, all
-      exc.errors = @set.errors
-      raise exc
-    end
-
-    groups = Hash.new {|hash, key| hash[key] = [] }
-
-    # create groups & sources in the same loop
-    sources = possibles.map do |spec|
-      source = spec.source
-      groups[source] << spec
-      source
-    end.uniq.reverse
-
-    activation_requests = []
-
-    sources.each do |source|
-      groups[source].
-        sort_by {|spec| [spec.version, spec.platform =~ Gem::Platform.local ? 1 : 0] }. # rubocop:disable Performance/RegexpMatch
-        map {|spec| ActivationRequest.new spec, dependency }.
-        each {|activation_request| activation_requests << activation_request }
-    end
-
-    activation_requests
-  end
-
-  def dependencies_for(specification)
-    return [] if @ignore_dependencies
-    spec = specification.spec
-    requests(spec, specification)
-  end
-
-  def requirement_satisfied_by?(requirement, activated, spec)
-    matches_spec = requirement.matches_spec? spec
-    return matches_spec if @soft_missing
-
-    matches_spec &&
-      spec.spec.required_ruby_version.satisfied_by?(Gem.ruby_version) &&
-      spec.spec.required_rubygems_version.satisfied_by?(Gem.rubygems_version)
-  end
-
-  def name_for(dependency)
-    dependency.name
-  end
-
-  def allow_missing?(dependency)
-    @soft_missing
-  end
-
-  def sort_dependencies(dependencies, activated, conflicts)
-    dependencies.sort_by.with_index do |dependency, i|
-      name = name_for(dependency)
-      [
-        activated.vertex_named(name).payload ? 0 : 1,
-        amount_constrained(dependency),
-        conflicts[name] ? 0 : 1,
-        activated.vertex_named(name).payload ? 0 : search_for(dependency).count,
-        i, # for stable sort
-      ]
-    end
-  end
-
-  SINGLE_POSSIBILITY_CONSTRAINT_PENALTY = 1_000_000
-  private_constant :SINGLE_POSSIBILITY_CONSTRAINT_PENALTY if defined?(private_constant)
-
-  # returns an integer \in (-\infty, 0]
-  # a number closer to 0 means the dependency is less constraining
-  #
-  # dependencies w/ 0 or 1 possibilities (ignoring version requirements)
-  # are given very negative values, so they _always_ sort first,
-  # before dependencies that are unconstrained
-  def amount_constrained(dependency)
-    @amount_constrained ||= {}
-    @amount_constrained[dependency.name] ||= begin
-      name_dependency = Gem::Dependency.new(dependency.name)
-      dependency_request_for_name = Gem::Resolver::DependencyRequest.new(name_dependency, dependency.requester)
-      all = @set.find_all(dependency_request_for_name).size
-
-      if all <= 1
-        all - SINGLE_POSSIBILITY_CONSTRAINT_PENALTY
-      else
-        search = search_for(dependency).size
-        search - all
-      end
-    end
-  end
-  private :amount_constrained
-end
-
-require_relative "resolver/activation_request"
-require_relative "resolver/conflict"
-require_relative "resolver/dependency_request"
-require_relative "resolver/requirement_list"
-require_relative "resolver/stats"
-
-require_relative "resolver/set"
-require_relative "resolver/api_set"
-require_relative "resolver/composed_set"
-require_relative "resolver/best_set"
-require_relative "resolver/current_set"
-require_relative "resolver/git_set"
-require_relative "resolver/index_set"
-require_relative "resolver/installer_set"
-require_relative "resolver/lock_set"
-require_relative "resolver/vendor_set"
-require_relative "resolver/source_set"
-
-require_relative "resolver/specification"
-require_relative "resolver/spec_specification"
-require_relative "resolver/api_specification"
-require_relative "resolver/git_specification"
-require_relative "resolver/index_specification"
-require_relative "resolver/installed_specification"
-require_relative "resolver/local_specification"
-require_relative "resolver/lock_specification"
-require_relative "resolver/vendor_specification"

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

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "openssl"
-
-##
-# S3URISigner implements AWS SigV4 for S3 Source to avoid a dependency on the aws-sdk-* gems
-# More on AWS SigV4: https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html
-class Gem::S3URISigner
-  class ConfigurationError < Gem::Exception
-    def initialize(message)
-      super message
-    end
-
-    def to_s # :nodoc:
-      super.to_s
-    end
-  end
-
-  class InstanceProfileError < Gem::Exception
-    def initialize(message)
-      super message
-    end
-
-    def to_s # :nodoc:
-      super.to_s
-    end
-  end
-
-  attr_accessor :uri
-
-  def initialize(uri)
-    @uri = uri
-  end
-
-  ##
-  # Signs S3 URI using query-params according to the reference: https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
-  def sign(expiration = 86_400)
-    s3_config = fetch_s3_config
-
-    current_time = Time.now.utc
-    date_time = current_time.strftime("%Y%m%dT%H%m%SZ")
-    date = date_time[0,8]
-
-    credential_info = "#{date}/#{s3_config.region}/s3/aws4_request"
-    canonical_host = "#{uri.host}.s3.#{s3_config.region}.amazonaws.com"
-
-    query_params = generate_canonical_query_params(s3_config, date_time, credential_info, expiration)
-    canonical_request = generate_canonical_request(canonical_host, query_params)
-    string_to_sign = generate_string_to_sign(date_time, credential_info, canonical_request)
-    signature = generate_signature(s3_config, date, string_to_sign)
-
-    Gem::URI.parse("https://#{canonical_host}#{uri.path}?#{query_params}&X-Amz-Signature=#{signature}")
-  end
-
-  private
-
-  S3Config = Struct.new :access_key_id, :secret_access_key, :security_token, :region
-
-  def generate_canonical_query_params(s3_config, date_time, credential_info, expiration)
-    canonical_params = {}
-    canonical_params["X-Amz-Algorithm"] = "AWS4-HMAC-SHA256"
-    canonical_params["X-Amz-Credential"] = "#{s3_config.access_key_id}/#{credential_info}"
-    canonical_params["X-Amz-Date"] = date_time
-    canonical_params["X-Amz-Expires"] = expiration.to_s
-    canonical_params["X-Amz-SignedHeaders"] = "host"
-    canonical_params["X-Amz-Security-Token"] = s3_config.security_token if s3_config.security_token
-
-    # Sorting is required to generate proper signature
-    canonical_params.sort.to_h.map do |key, value|
-      "#{base64_uri_escape(key)}=#{base64_uri_escape(value)}"
-    end.join("&")
-  end
-
-  def generate_canonical_request(canonical_host, query_params)
-    [
-      "GET",
-      uri.path,
-      query_params,
-      "host:#{canonical_host}",
-      "", # empty params
-      "host",
-      "UNSIGNED-PAYLOAD",
-    ].join("\n")
-  end
-
-  def generate_string_to_sign(date_time, credential_info, canonical_request)
-    [
-      "AWS4-HMAC-SHA256",
-      date_time,
-      credential_info,
-      OpenSSL::Digest::SHA256.hexdigest(canonical_request),
-    ].join("\n")
-  end
-
-  def generate_signature(s3_config, date, string_to_sign)
-    date_key = OpenSSL::HMAC.digest("sha256", "AWS4" + s3_config.secret_access_key, date)
-    date_region_key = OpenSSL::HMAC.digest("sha256", date_key, s3_config.region)
-    date_region_service_key = OpenSSL::HMAC.digest("sha256", date_region_key, "s3")
-    signing_key = OpenSSL::HMAC.digest("sha256", date_region_service_key, "aws4_request")
-    OpenSSL::HMAC.hexdigest("sha256", signing_key, string_to_sign)
-  end
-
-  ##
-  # Extracts S3 configuration for S3 bucket
-  def fetch_s3_config
-    return S3Config.new(uri.user, uri.password, nil, "us-east-1") if uri.user && uri.password
-
-    s3_source = Gem.configuration[:s3_source] || Gem.configuration["s3_source"]
-    host = uri.host
-    raise ConfigurationError.new("no s3_source key exists in .gemrc") unless s3_source
-
-    auth = s3_source[host] || s3_source[host.to_sym]
-    raise ConfigurationError.new("no key for host #{host} in s3_source in .gemrc") unless auth
-
-    provider = auth[:provider] || auth["provider"]
-    case provider
-    when "env"
-      id = ENV["AWS_ACCESS_KEY_ID"]
-      secret = ENV["AWS_SECRET_ACCESS_KEY"]
-      security_token = ENV["AWS_SESSION_TOKEN"]
-    when "instance_profile"
-      credentials = ec2_metadata_credentials_json
-      id = credentials["AccessKeyId"]
-      secret = credentials["SecretAccessKey"]
-      security_token = credentials["Token"]
-    else
-      id = auth[:id] || auth["id"]
-      secret = auth[:secret] || auth["secret"]
-      security_token = auth[:security_token] || auth["security_token"]
-    end
-
-    raise ConfigurationError.new("s3_source for #{host} missing id or secret") unless id && secret
-
-    region = auth[:region] || auth["region"] || "us-east-1"
-    S3Config.new(id, secret, security_token, region)
-  end
-
-  def base64_uri_escape(str)
-    str.gsub(%r{[\+/=\n]}, BASE64_URI_TRANSLATE)
-  end
-
-  def ec2_metadata_credentials_json
-    require_relative "vendored_net_http"
-    require_relative "request"
-    require_relative "request/connection_pools"
-    require "json"
-
-    iam_info = ec2_metadata_request(EC2_IAM_INFO)
-    # Expected format: arn:aws:iam::<id>:instance-profile/<role_name>
-    role_name = iam_info["InstanceProfileArn"].split("/").last
-    ec2_metadata_request(EC2_IAM_SECURITY_CREDENTIALS + role_name)
-  end
-
-  def ec2_metadata_request(url)
-    uri = Gem::URI(url)
-    @request_pool ||= create_request_pool(uri)
-    request = Gem::Request.new(uri, Gem::Net::HTTP::Get, nil, @request_pool)
-    response = request.fetch
-
-    case response
-    when Gem::Net::HTTPOK then
-      JSON.parse(response.body)
-    else
-      raise InstanceProfileError.new("Unable to fetch AWS metadata from #{uri}: #{response.message} #{response.code}")
-    end
-  end
-
-  def create_request_pool(uri)
-    proxy_uri = Gem::Request.proxy_uri(Gem::Request.get_proxy_from_env(uri.scheme))
-    certs = Gem::Request.get_cert_files
-    Gem::Request::ConnectionPools.new(proxy_uri, certs).pool_for(uri)
-  end
-
-  BASE64_URI_TRANSLATE = { "+" => "%2B", "/" => "%2F", "=" => "%3D", "\n" => "" }.freeze
-  EC2_IAM_INFO = "http://169.254.169.254/latest/meta-data/iam/info"
-  EC2_IAM_SECURITY_CREDENTIALS = "http://169.254.169.254/latest/meta-data/iam/security-credentials/"
-end

package/lib/ruby/3.4.11/rubygems/safe_marshal/elements.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-module Gem
-  module SafeMarshal
-    module Elements
-      class Element
-      end
-
-      class Symbol < Element
-        def initialize(name)
-          @name = name
-        end
-        attr_reader :name
-      end
-
-      class UserDefined < Element
-        def initialize(name, binary_string)
-          @name = name
-          @binary_string = binary_string
-        end
-
-        attr_reader :name, :binary_string
-      end
-
-      class UserMarshal < Element
-        def initialize(name, data)
-          @name = name
-          @data = data
-        end
-
-        attr_reader :name, :data
-      end
-
-      class String < Element
-        def initialize(str)
-          @str = str
-        end
-
-        attr_reader :str
-      end
-
-      class Hash < Element
-        def initialize(pairs)
-          @pairs = pairs
-        end
-
-        attr_reader :pairs
-      end
-
-      class HashWithDefaultValue < Hash
-        def initialize(pairs, default)
-          super(pairs)
-          @default = default
-        end
-
-        attr_reader :default
-      end
-
-      class Array < Element
-        def initialize(elements)
-          @elements = elements
-        end
-
-        attr_reader :elements
-      end
-
-      class Integer < Element
-        def initialize(int)
-          @int = int
-        end
-
-        attr_reader :int
-      end
-
-      class True < Element
-        def initialize
-        end
-        TRUE = new.freeze
-      end
-
-      class False < Element
-        def initialize
-        end
-
-        FALSE = new.freeze
-      end
-
-      class WithIvars < Element
-        def initialize(object, ivars)
-          @object = object
-          @ivars = ivars
-        end
-
-        attr_reader :object, :ivars
-      end
-
-      class Object < Element
-        def initialize(name)
-          @name = name
-        end
-        attr_reader :name
-      end
-
-      class Nil < Element
-        NIL = new.freeze
-      end
-
-      class ObjectLink < Element
-        def initialize(offset)
-          @offset = offset
-        end
-        attr_reader :offset
-      end
-
-      class SymbolLink < Element
-        def initialize(offset)
-          @offset = offset
-        end
-        attr_reader :offset
-      end
-
-      class Float < Element
-        def initialize(string)
-          @string = string
-        end
-        attr_reader :string
-      end
-
-      class Bignum < Element # rubocop:disable Lint/UnifiedInteger
-        def initialize(sign, data)
-          @sign = sign
-          @data = data
-        end
-        attr_reader :sign, :data
-      end
-
-      class UserClass < Element
-        def initialize(name, wrapped_object)
-          @name = name
-          @wrapped_object = wrapped_object
-        end
-        attr_reader :name, :wrapped_object
-      end
-    end
-  end
-end