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

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

@@ -1,348 +0,0 @@
-# frozen_string_literal: true
-
-##
-# The Dependency class holds a Gem name and a Gem::Requirement.
-
-class Gem::Dependency
-  ##
-  # Valid dependency types.
-  #--
-  # When this list is updated, be sure to change
-  # Gem::Specification::CURRENT_SPECIFICATION_VERSION as well.
-  #
-  # REFACTOR: This type of constant, TYPES, indicates we might want
-  # two classes, used via inheritance or duck typing.
-
-  TYPES = [
-    :development,
-    :runtime,
-  ].freeze
-
-  ##
-  # Dependency name or regular expression.
-
-  attr_accessor :name
-
-  ##
-  # Allows you to force this dependency to be a prerelease.
-
-  attr_writer :prerelease
-
-  ##
-  # Constructs a dependency with +name+ and +requirements+. The last
-  # argument can optionally be the dependency type, which defaults to
-  # <tt>:runtime</tt>.
-
-  def initialize(name, *requirements)
-    case name
-    when String then # ok
-    when Regexp then
-      msg = ["NOTE: Dependency.new w/ a regexp is deprecated.",
-             "Dependency.new called from #{Gem.location_of_caller.join(":")}"]
-      warn msg.join("\n") unless Gem::Deprecate.skip
-    else
-      raise ArgumentError,
-            "dependency name must be a String, was #{name.inspect}"
-    end
-
-    type         = Symbol === requirements.last ? requirements.pop : :runtime
-    requirements = requirements.first if requirements.length == 1 # unpack
-
-    unless TYPES.include? type
-      raise ArgumentError, "Valid types are #{TYPES.inspect}, " \
-                           "not #{type.inspect}"
-    end
-
-    @name        = name
-    @requirement = Gem::Requirement.create requirements
-    @type        = type
-    @prerelease  = false
-
-    # This is for Marshal backwards compatibility. See the comments in
-    # +requirement+ for the dirty details.
-
-    @version_requirements = @requirement
-  end
-
-  ##
-  # A dependency's hash is the XOR of the hashes of +name+, +type+,
-  # and +requirement+.
-
-  def hash # :nodoc:
-    name.hash ^ type.hash ^ requirement.hash
-  end
-
-  def inspect # :nodoc:
-    if prerelease?
-      format("<%s type=%p name=%p requirements=%p prerelease=ok>", self.class, type, name, requirement.to_s)
-    else
-      format("<%s type=%p name=%p requirements=%p>", self.class, type, name, requirement.to_s)
-    end
-  end
-
-  ##
-  # Does this dependency require a prerelease?
-
-  def prerelease?
-    @prerelease || requirement.prerelease?
-  end
-
-  ##
-  # Is this dependency simply asking for the latest version
-  # of a gem?
-
-  def latest_version?
-    @requirement.none?
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.group 1, "Gem::Dependency.new(", ")" do
-      q.pp name
-      q.text ","
-      q.breakable
-
-      q.pp requirement
-
-      q.text ","
-      q.breakable
-
-      q.pp type
-    end
-  end
-
-  ##
-  # What does this dependency require?
-
-  def requirement
-    return @requirement if defined?(@requirement) && @requirement
-
-    # @version_requirements and @version_requirement are legacy ivar
-    # names, and supported here because older gems need to keep
-    # working and Dependency doesn't implement marshal_dump and
-    # marshal_load. In a happier world, this would be an
-    # attr_accessor. The horrifying instance_variable_get you see
-    # below is also the legacy of some old restructurings.
-    #
-    # Note also that because of backwards compatibility (loading new
-    # gems in an old RubyGems installation), we can't add explicit
-    # marshaling to this class until we want to make a big
-    # break. Maybe 2.0.
-    #
-    # Children, define explicit marshal and unmarshal behavior for
-    # public classes. Marshal formats are part of your public API.
-
-    # REFACTOR: See above
-
-    if defined?(@version_requirement) && @version_requirement
-      version = @version_requirement.instance_variable_get :@version
-      @version_requirement = nil
-      @version_requirements = Gem::Requirement.new version
-    end
-
-    @requirement = @version_requirements if defined?(@version_requirements)
-  end
-
-  def requirements_list
-    requirement.as_list
-  end
-
-  def to_s # :nodoc:
-    if type != :runtime
-      "#{name} (#{requirement}, #{type})"
-    else
-      "#{name} (#{requirement})"
-    end
-  end
-
-  ##
-  # Dependency type.
-
-  def type
-    @type ||= :runtime
-  end
-
-  def runtime?
-    @type == :runtime || !@type
-  end
-
-  def ==(other) # :nodoc:
-    Gem::Dependency === other &&
-      name        == other.name &&
-      type        == other.type &&
-      requirement == other.requirement
-  end
-
-  ##
-  # Dependencies are ordered by name.
-
-  def <=>(other)
-    name <=> other.name
-  end
-
-  ##
-  # Uses this dependency as a pattern to compare to +other+. This
-  # dependency will match if the name matches the other's name, and
-  # other has only an equal version requirement that satisfies this
-  # dependency.
-
-  def =~(other)
-    unless Gem::Dependency === other
-      return unless other.respond_to?(:name) && other.respond_to?(:version)
-      other = Gem::Dependency.new other.name, other.version
-    end
-
-    return false unless name === other.name
-
-    reqs = other.requirement.requirements
-
-    return false unless reqs.length == 1
-    return false unless reqs.first.first == "="
-
-    version = reqs.first.last
-
-    requirement.satisfied_by? version
-  end
-
-  alias_method :===, :=~
-
-  ##
-  # :call-seq:
-  #   dep.match? name          => true or false
-  #   dep.match? name, version => true or false
-  #   dep.match? spec          => true or false
-  #
-  # Does this dependency match the specification described by +name+ and
-  # +version+ or match +spec+?
-  #
-  # NOTE:  Unlike #matches_spec? this method does not return true when the
-  # version is a prerelease version unless this is a prerelease dependency.
-
-  def match?(obj, version=nil, allow_prerelease=false)
-    if !version
-      name = obj.name
-      version = obj.version
-    else
-      name = obj
-    end
-
-    return false unless self.name === name
-
-    version = Gem::Version.new version
-
-    return true if requirement.none? && !version.prerelease?
-    return false if version.prerelease? &&
-                    !allow_prerelease &&
-                    !prerelease?
-
-    requirement.satisfied_by? version
-  end
-
-  ##
-  # Does this dependency match +spec+?
-  #
-  # NOTE:  This is not a convenience method.  Unlike #match? this method
-  # returns true when +spec+ is a prerelease version even if this dependency
-  # is not a prerelease dependency.
-
-  def matches_spec?(spec)
-    return false unless name === spec.name
-    return true  if requirement.none?
-
-    requirement.satisfied_by?(spec.version)
-  end
-
-  ##
-  # Merges the requirements of +other+ into this dependency
-
-  def merge(other)
-    unless name == other.name
-      raise ArgumentError,
-            "#{self} and #{other} have different names"
-    end
-
-    default = Gem::Requirement.default
-    self_req = requirement
-    other_req = other.requirement
-
-    return self.class.new name, self_req  if other_req == default
-    return self.class.new name, other_req if self_req  == default
-
-    self.class.new name, self_req.as_list.concat(other_req.as_list)
-  end
-
-  def matching_specs(platform_only = false)
-    matches = Gem::Specification.find_all_by_name(name, requirement)
-
-    if platform_only
-      matches.reject! do |spec|
-        spec.nil? || !Gem::Platform.match_spec?(spec)
-      end
-    end
-
-    matches.reject(&:ignored?)
-  end
-
-  ##
-  # True if the dependency will not always match the latest version.
-
-  def specific?
-    @requirement.specific?
-  end
-
-  def to_specs
-    matches = matching_specs true
-
-    # TODO: check Gem.activated_spec[self.name] in case matches falls outside
-
-    if matches.empty?
-      specs = Gem::Specification.stubs_for name
-
-      if specs.empty?
-        raise Gem::MissingSpecError.new name, requirement
-      else
-        raise Gem::MissingSpecVersionError.new name, requirement, specs
-      end
-    end
-
-    # TODO: any other resolver validations should go here
-
-    matches
-  end
-
-  def to_spec
-    matches = to_specs.compact
-
-    active = matches.find(&:activated?)
-    return active if active
-
-    unless prerelease?
-      # Consider prereleases only as a fallback
-      pre, matches = matches.partition {|spec| spec.version.prerelease? }
-      matches = pre if matches.empty?
-    end
-
-    matches.first
-  end
-
-  def identity
-    if prerelease?
-      if specific?
-        :complete
-      else
-        :abs_latest
-      end
-    elsif latest_version?
-      :latest
-    else
-      :released
-    end
-  end
-
-  def encode_with(coder) # :nodoc:
-    coder.add "name", @name
-    coder.add "requirement", @requirement
-    coder.add "type", @type
-    coder.add "prerelease", @prerelease
-    coder.add "version_requirements", @version_requirements
-  end
-end

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

@@ -1,335 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../rubygems"
-require_relative "dependency_list"
-require_relative "package"
-require_relative "installer"
-require_relative "spec_fetcher"
-require_relative "user_interaction"
-require_relative "available_set"
-require_relative "deprecate"
-
-##
-# Installs a gem along with all its dependencies from local and remote gems.
-
-class Gem::DependencyInstaller
-  include Gem::UserInteraction
-  extend Gem::Deprecate
-
-  DEFAULT_OPTIONS = { # :nodoc:
-    env_shebang: false,
-    document: %w[ri],
-    domain: :both, # HACK: dup
-    force: false,
-    format_executable: false, # HACK: dup
-    ignore_dependencies: false,
-    prerelease: false,
-    security_policy: nil, # HACK: NoSecurity requires OpenSSL. AlmostNo? Low?
-    wrappers: true,
-    build_args: nil,
-    build_docs_in_background: false,
-    install_as_default: false,
-  }.freeze
-
-  ##
-  # Documentation types.  For use by the Gem.done_installing hook
-
-  attr_reader :document
-
-  ##
-  # Errors from SpecFetcher while searching for remote specifications
-
-  attr_reader :errors
-
-  ##
-  # List of gems installed by #install in alphabetic order
-
-  attr_reader :installed_gems
-
-  ##
-  # Creates a new installer instance.
-  #
-  # Options are:
-  # :cache_dir:: Alternate repository path to store .gem files in.
-  # :domain:: :local, :remote, or :both.  :local only searches gems in the
-  #           current directory.  :remote searches only gems in Gem::sources.
-  #           :both searches both.
-  # :env_shebang:: See Gem::Installer::new.
-  # :force:: See Gem::Installer#install.
-  # :format_executable:: See Gem::Installer#initialize.
-  # :ignore_dependencies:: Don't install any dependencies.
-  # :install_dir:: See Gem::Installer#install.
-  # :prerelease:: Allow prerelease versions.  See #install.
-  # :security_policy:: See Gem::Installer::new and Gem::Security.
-  # :user_install:: See Gem::Installer.new
-  # :wrappers:: See Gem::Installer::new
-  # :build_args:: See Gem::Installer::new
-
-  def initialize(options = {})
-    @only_install_dir = !options[:install_dir].nil?
-    @install_dir = options[:install_dir] || Gem.dir
-    @build_root = options[:build_root]
-
-    options = DEFAULT_OPTIONS.merge options
-
-    @bin_dir             = options[:bin_dir]
-    @dev_shallow         = options[:dev_shallow]
-    @development         = options[:development]
-    @document            = options[:document]
-    @domain              = options[:domain]
-    @env_shebang         = options[:env_shebang]
-    @force               = options[:force]
-    @format_executable   = options[:format_executable]
-    @ignore_dependencies = options[:ignore_dependencies]
-    @prerelease          = options[:prerelease]
-    @security_policy     = options[:security_policy]
-    @user_install        = options[:user_install]
-    @wrappers            = options[:wrappers]
-    @build_args          = options[:build_args]
-    @build_docs_in_background = options[:build_docs_in_background]
-    @install_as_default = options[:install_as_default]
-    @dir_mode = options[:dir_mode]
-    @data_mode = options[:data_mode]
-    @prog_mode = options[:prog_mode]
-
-    # Indicates that we should not try to update any deps unless
-    # we absolutely must.
-    @minimal_deps = options[:minimal_deps]
-
-    @available      = nil
-    @installed_gems = []
-    @toplevel_specs = nil
-
-    @cache_dir = options[:cache_dir] || @install_dir
-
-    @errors = []
-  end
-
-  ##
-  # Indicated, based on the requested domain, if local
-  # gems should be considered.
-
-  def consider_local?
-    @domain == :both || @domain == :local
-  end
-
-  ##
-  # Indicated, based on the requested domain, if remote
-  # gems should be considered.
-
-  def consider_remote?
-    @domain == :both || @domain == :remote
-  end
-
-  ##
-  # Returns a list of pairs of gemspecs and source_uris that match
-  # Gem::Dependency +dep+ from both local (Dir.pwd) and remote (Gem.sources)
-  # sources.  Gems are sorted with newer gems preferred over older gems, and
-  # local gems preferred over remote gems.
-
-  def find_gems_with_sources(dep, best_only=false) # :nodoc:
-    set = Gem::AvailableSet.new
-
-    if consider_local?
-      sl = Gem::Source::Local.new
-
-      if spec = sl.find_gem(dep.name)
-        if dep.matches_spec? spec
-          set.add spec, sl
-        end
-      end
-    end
-
-    if consider_remote?
-      begin
-        # This is pulled from #spec_for_dependency to allow
-        # us to filter tuples before fetching specs.
-        tuples, errors = Gem::SpecFetcher.fetcher.search_for_dependency dep
-
-        if best_only && !tuples.empty?
-          tuples.sort! do |a,b|
-            if b[0].version == a[0].version
-              if b[0].platform != Gem::Platform::RUBY
-                1
-              else
-                -1
-              end
-            else
-              b[0].version <=> a[0].version
-            end
-          end
-          tuples = [tuples.first]
-        end
-
-        specs = []
-        tuples.each do |tup, source|
-          spec = source.fetch_spec(tup)
-        rescue Gem::RemoteFetcher::FetchError => e
-          errors << Gem::SourceFetchProblem.new(source, e)
-        else
-          specs << [spec, source]
-        end
-
-        if @errors
-          @errors += errors
-        else
-          @errors = errors
-        end
-
-        set << specs
-      rescue Gem::RemoteFetcher::FetchError => e
-        # FIX if there is a problem talking to the network, we either need to always tell
-        # the user (no really_verbose) or fail hard, not silently tell them that we just
-        # couldn't find their requested gem.
-        verbose do
-          "Error fetching remote data:\t\t#{e.message}\n" \
-            "Falling back to local-only install"
-        end
-        @domain = :local
-      end
-    end
-
-    set
-  end
-  rubygems_deprecate :find_gems_with_sources
-
-  def in_background(what) # :nodoc:
-    fork_happened = false
-    if @build_docs_in_background && Process.respond_to?(:fork)
-      begin
-        Process.fork do
-          yield
-        end
-        fork_happened = true
-        say "#{what} in a background process."
-      rescue NotImplementedError
-      end
-    end
-    yield unless fork_happened
-  end
-
-  ##
-  # Installs the gem +dep_or_name+ and all its dependencies.  Returns an Array
-  # of installed gem specifications.
-  #
-  # If the +:prerelease+ option is set and there is a prerelease for
-  # +dep_or_name+ the prerelease version will be installed.
-  #
-  # Unless explicitly specified as a prerelease dependency, prerelease gems
-  # that +dep_or_name+ depend on will not be installed.
-  #
-  # If c-1.a depends on b-1 and a-1.a and there is a gem b-1.a available then
-  # c-1.a, b-1 and a-1.a will be installed.  b-1.a will need to be installed
-  # separately.
-
-  def install(dep_or_name, version = Gem::Requirement.default)
-    request_set = resolve_dependencies dep_or_name, version
-
-    @installed_gems = []
-
-    options = {
-      bin_dir: @bin_dir,
-      build_args: @build_args,
-      document: @document,
-      env_shebang: @env_shebang,
-      force: @force,
-      format_executable: @format_executable,
-      ignore_dependencies: @ignore_dependencies,
-      prerelease: @prerelease,
-      security_policy: @security_policy,
-      user_install: @user_install,
-      wrappers: @wrappers,
-      build_root: @build_root,
-      install_as_default: @install_as_default,
-      dir_mode: @dir_mode,
-      data_mode: @data_mode,
-      prog_mode: @prog_mode,
-    }
-    options[:install_dir] = @install_dir if @only_install_dir
-
-    request_set.install options do |_, installer|
-      @installed_gems << installer.spec if installer
-    end
-
-    @installed_gems.sort!
-
-    # Since this is currently only called for docs, we can be lazy and just say
-    # it's documentation. Ideally the hook adder could decide whether to be in
-    # the background or not, and what to call it.
-    in_background "Installing documentation" do
-      Gem.done_installing_hooks.each do |hook|
-        hook.call self, @installed_gems
-      end
-    end unless Gem.done_installing_hooks.empty?
-
-    @installed_gems
-  end
-
-  def install_development_deps # :nodoc:
-    if @development && @dev_shallow
-      :shallow
-    elsif @development
-      :all
-    else
-      :none
-    end
-  end
-
-  def resolve_dependencies(dep_or_name, version) # :nodoc:
-    request_set = Gem::RequestSet.new
-    request_set.development         = @development
-    request_set.development_shallow = @dev_shallow
-    request_set.soft_missing = @force
-    request_set.prerelease = @prerelease
-
-    installer_set = Gem::Resolver::InstallerSet.new @domain
-    installer_set.ignore_installed = (@minimal_deps == false) || @only_install_dir
-    installer_set.force = @force
-
-    if consider_local?
-      if dep_or_name =~ /\.gem$/ && File.file?(dep_or_name)
-        src = Gem::Source::SpecificFile.new dep_or_name
-        installer_set.add_local dep_or_name, src.spec, src
-        version = src.spec.version if version == Gem::Requirement.default
-      elsif dep_or_name =~ /\.gem$/ # rubocop:disable Performance/RegexpMatch
-        Dir[dep_or_name].each do |name|
-          src = Gem::Source::SpecificFile.new name
-          installer_set.add_local dep_or_name, src.spec, src
-        rescue Gem::Package::FormatError
-        end
-        # else This is a dependency. InstallerSet handles this case
-      end
-    end
-
-    dependency =
-      if spec = installer_set.local?(dep_or_name)
-        installer_set.remote = nil if spec.dependencies.none?
-        Gem::Dependency.new spec.name, version
-      elsif String === dep_or_name
-        Gem::Dependency.new dep_or_name, version
-      else
-        dep_or_name
-      end
-
-    dependency.prerelease = @prerelease
-
-    request_set.import [dependency]
-
-    installer_set.add_always_install dependency
-
-    request_set.always_install = installer_set.always_install
-    request_set.remote = installer_set.consider_remote?
-
-    if @ignore_dependencies
-      installer_set.ignore_dependencies = true
-      request_set.ignore_dependencies   = true
-      request_set.soft_missing          = true
-    end
-
-    request_set.resolve installer_set
-
-    @errors.concat request_set.errors
-
-    request_set
-  end
-end