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

package/lib/ruby/3.4.11/rubygems/source/git.rb

@@ -1,244 +0,0 @@
-# frozen_string_literal: true
-
-##
-# A git gem for use in a gem dependencies file.
-#
-# Example:
-#
-#   source =
-#     Gem::Source::Git.new 'rake', 'git@example:rake.git', 'rake-10.1.0', false
-#
-#   source.specs
-
-class Gem::Source::Git < Gem::Source
-  ##
-  # The name of the gem created by this git gem.
-
-  attr_reader :name
-
-  ##
-  # The commit reference used for checking out this git gem.
-
-  attr_reader :reference
-
-  ##
-  # When false the cache for this repository will not be updated.
-
-  attr_accessor :remote
-
-  ##
-  # The git repository this gem is sourced from.
-
-  attr_reader :repository
-
-  ##
-  # The directory for cache and git gem installation
-
-  attr_accessor :root_dir
-
-  ##
-  # Does this repository need submodules checked out too?
-
-  attr_reader :need_submodules
-
-  ##
-  # Creates a new git gem source for a gems from loaded from +repository+ at
-  # the given +reference+.  The +name+ is only used to track the repository
-  # back to a gem dependencies file, it has no real significance as a git
-  # repository may contain multiple gems.  If +submodules+ is true, submodules
-  # will be checked out when the gem is installed.
-
-  def initialize(name, repository, reference, submodules = false)
-    require_relative "../uri"
-    @uri = Gem::Uri.parse(repository)
-    @name            = name
-    @repository      = repository
-    @reference       = reference || "HEAD"
-    @need_submodules = submodules
-
-    @remote   = true
-    @root_dir = Gem.dir
-  end
-
-  def <=>(other)
-    case other
-    when Gem::Source::Git then
-      0
-    when Gem::Source::Vendor,
-         Gem::Source::Lock then
-      -1
-    when Gem::Source then
-      1
-    end
-  end
-
-  def ==(other) # :nodoc:
-    super &&
-      @name            == other.name &&
-      @repository      == other.repository &&
-      @reference       == other.reference &&
-      @need_submodules == other.need_submodules
-  end
-
-  def git_command
-    ENV.fetch("git", "git")
-  end
-
-  ##
-  # Checks out the files for the repository into the install_dir.
-
-  def checkout # :nodoc:
-    cache
-
-    return false unless File.exist? repo_cache_dir
-
-    unless File.exist? install_dir
-      system git_command, "clone", "--quiet", "--no-checkout",
-             repo_cache_dir, install_dir
-    end
-
-    Dir.chdir install_dir do
-      system git_command, "fetch", "--quiet", "--force", "--tags", install_dir
-
-      success = system git_command, "reset", "--quiet", "--hard", rev_parse
-
-      if @need_submodules
-        require "open3"
-        _, status = Open3.capture2e(git_command, "submodule", "update", "--quiet", "--init", "--recursive")
-
-        success &&= status.success?
-      end
-
-      success
-    end
-  end
-
-  ##
-  # Creates a local cache repository for the git gem.
-
-  def cache # :nodoc:
-    return unless @remote
-
-    if File.exist? repo_cache_dir
-      Dir.chdir repo_cache_dir do
-        system git_command, "fetch", "--quiet", "--force", "--tags",
-               @repository, "refs/heads/*:refs/heads/*"
-      end
-    else
-      system git_command, "clone", "--quiet", "--bare", "--no-hardlinks",
-             @repository, repo_cache_dir
-    end
-  end
-
-  ##
-  # Directory where git gems get unpacked and so-forth.
-
-  def base_dir # :nodoc:
-    File.join @root_dir, "bundler"
-  end
-
-  ##
-  # A short reference for use in git gem directories
-
-  def dir_shortref # :nodoc:
-    rev_parse[0..11]
-  end
-
-  ##
-  # Nothing to download for git gems
-
-  def download(full_spec, path) # :nodoc:
-  end
-
-  ##
-  # The directory where the git gem will be installed.
-
-  def install_dir # :nodoc:
-    return unless File.exist? repo_cache_dir
-
-    File.join base_dir, "gems", "#{@name}-#{dir_shortref}"
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.object_group(self) do
-      q.group 2, "[Git: ", "]" do
-        q.breakable
-        q.text @repository
-
-        q.breakable
-        q.text @reference
-      end
-    end
-  end
-
-  ##
-  # The directory where the git gem's repository will be cached.
-
-  def repo_cache_dir # :nodoc:
-    File.join @root_dir, "cache", "bundler", "git", "#{@name}-#{uri_hash}"
-  end
-
-  ##
-  # Converts the git reference for the repository into a commit hash.
-
-  def rev_parse # :nodoc:
-    hash = nil
-
-    Dir.chdir repo_cache_dir do
-      hash = Gem::Util.popen(git_command, "rev-parse", @reference).strip
-    end
-
-    raise Gem::Exception,
-          "unable to find reference #{@reference} in #{@repository}" unless
-            $?.success?
-
-    hash
-  end
-
-  ##
-  # Loads all gemspecs in the repository
-
-  def specs
-    checkout
-
-    return [] unless install_dir
-
-    Dir.chdir install_dir do
-      Dir["{,*,*/*}.gemspec"].filter_map do |spec_file|
-        directory = File.dirname spec_file
-        file      = File.basename spec_file
-
-        Dir.chdir directory do
-          spec = Gem::Specification.load file
-          if spec
-            spec.base_dir = base_dir
-
-            spec.extension_dir =
-              File.join base_dir, "extensions", Gem::Platform.local.to_s,
-                Gem.extension_api_version, "#{name}-#{dir_shortref}"
-
-            spec.full_gem_path = File.dirname spec.loaded_from if spec
-          end
-          spec
-        end
-      end
-    end
-  end
-
-  ##
-  # A hash for the git gem based on the git repository Gem::URI.
-
-  def uri_hash # :nodoc:
-    require_relative "../openssl"
-
-    normalized =
-      if @repository.match?(%r{^\w+://(\w+@)?})
-        uri = Gem::URI(@repository).normalize.to_s.sub %r{/$},""
-        uri.sub(/\A(\w+)/) { $1.downcase }
-      else
-        @repository
-      end
-
-    OpenSSL::Digest::SHA1.hexdigest normalized
-  end
-end

package/lib/ruby/3.4.11/rubygems/source/installed.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-##
-# Represents an installed gem.  This is used for dependency resolution.
-
-class Gem::Source::Installed < Gem::Source
-  def initialize # :nodoc:
-    @uri = nil
-  end
-
-  ##
-  # Installed sources sort before all other sources
-
-  def <=>(other)
-    case other
-    when Gem::Source::Git,
-         Gem::Source::Lock,
-         Gem::Source::Vendor then
-      -1
-    when Gem::Source::Installed then
-      0
-    when Gem::Source then
-      1
-    end
-  end
-
-  ##
-  # We don't need to download an installed gem
-
-  def download(spec, path)
-    nil
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.object_group(self) do
-      q.text "[Installed]"
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/source/local.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-##
-# The local source finds gems in the current directory for fulfilling
-# dependencies.
-
-class Gem::Source::Local < Gem::Source
-  def initialize # :nodoc:
-    @specs   = nil
-    @api_uri = nil
-    @uri     = nil
-    @load_specs_names = {}
-  end
-
-  ##
-  # Local sorts before Gem::Source and after Gem::Source::Installed
-
-  def <=>(other)
-    case other
-    when Gem::Source::Installed,
-         Gem::Source::Lock then
-      -1
-    when Gem::Source::Local then
-      0
-    when Gem::Source then
-      1
-    end
-  end
-
-  def inspect # :nodoc:
-    keys = @specs ? @specs.keys.sort : "NOT LOADED"
-    format("#<%s specs: %p>", self.class, keys)
-  end
-
-  def load_specs(type) # :nodoc:
-    @load_specs_names[type] ||= begin
-      names = []
-
-      @specs = {}
-
-      Dir["*.gem"].each do |file|
-        pkg = Gem::Package.new(file)
-        spec = pkg.spec
-      rescue SystemCallError, Gem::Package::FormatError
-        # ignore
-      else
-        tup = spec.name_tuple
-        @specs[tup] = [File.expand_path(file), pkg]
-
-        case type
-        when :released
-          unless pkg.spec.version.prerelease?
-            names << pkg.spec.name_tuple
-          end
-        when :prerelease
-          if pkg.spec.version.prerelease?
-            names << pkg.spec.name_tuple
-          end
-        when :latest
-          tup = pkg.spec.name_tuple
-
-          cur = names.find {|x| x.name == tup.name }
-          if !cur
-            names << tup
-          elsif cur.version < tup.version
-            names.delete cur
-            names << tup
-          end
-        else
-          names << pkg.spec.name_tuple
-        end
-      end
-
-      names
-    end
-  end
-
-  def find_gem(gem_name, version = Gem::Requirement.default, prerelease = false) # :nodoc:
-    load_specs :complete
-
-    found = []
-
-    @specs.each do |n, data|
-      next unless n.name == gem_name
-      s = data[1].spec
-
-      if version.satisfied_by?(s.version)
-        if prerelease
-          found << s
-        elsif !s.version.prerelease? || version.prerelease?
-          found << s
-        end
-      end
-    end
-
-    found.max_by(&:version)
-  end
-
-  def fetch_spec(name) # :nodoc:
-    load_specs :complete
-
-    if data = @specs[name]
-      data.last.spec
-    else
-      raise Gem::Exception, "Unable to find spec for #{name.inspect}"
-    end
-  end
-
-  def download(spec, cache_dir = nil) # :nodoc:
-    load_specs :complete
-
-    @specs.each do |_name, data|
-      return data[0] if data[1].spec == spec
-    end
-
-    raise Gem::Exception, "Unable to find file for '#{spec.full_name}'"
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.object_group(self) do
-      q.group 2, "[Local gems:", "]" do
-        q.breakable
-        if @specs
-          q.seplist @specs.keys do |v|
-            q.text v.full_name
-          end
-        end
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/source/lock.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-##
-# A Lock source wraps an installed gem's source and sorts before other sources
-# during dependency resolution.  This allows RubyGems to prefer gems from
-# dependency lock files.
-
-class Gem::Source::Lock < Gem::Source
-  ##
-  # The wrapped Gem::Source
-
-  attr_reader :wrapped
-
-  ##
-  # Creates a new Lock source that wraps +source+ and moves it earlier in the
-  # sort list.
-
-  def initialize(source)
-    @wrapped = source
-  end
-
-  def <=>(other) # :nodoc:
-    case other
-    when Gem::Source::Lock then
-      @wrapped <=> other.wrapped
-    when Gem::Source then
-      1
-    end
-  end
-
-  def ==(other) # :nodoc:
-    (self <=> other) == 0
-  end
-
-  def hash # :nodoc:
-    @wrapped.hash ^ 3
-  end
-
-  ##
-  # Delegates to the wrapped source's fetch_spec method.
-
-  def fetch_spec(name_tuple)
-    @wrapped.fetch_spec name_tuple
-  end
-
-  def uri # :nodoc:
-    @wrapped.uri
-  end
-end

package/lib/ruby/3.4.11/rubygems/source/specific_file.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-##
-# A source representing a single .gem file.  This is used for installation of
-# local gems.
-
-class Gem::Source::SpecificFile < Gem::Source
-  ##
-  # The path to the gem for this specific file.
-
-  attr_reader :path
-
-  ##
-  # Creates a new SpecificFile for the gem in +file+
-
-  def initialize(file)
-    @uri = nil
-    @path = ::File.expand_path(file)
-
-    @package = Gem::Package.new @path
-    @spec = @package.spec
-    @name = @spec.name_tuple
-  end
-
-  ##
-  # The Gem::Specification extracted from this .gem.
-
-  attr_reader :spec
-
-  def load_specs(*a) # :nodoc:
-    [@name]
-  end
-
-  def fetch_spec(name) # :nodoc:
-    return @spec if name == @name
-    raise Gem::Exception, "Unable to find '#{name}'"
-  end
-
-  def download(spec, dir = nil) # :nodoc:
-    return @path if spec == @spec
-    raise Gem::Exception, "Unable to download '#{spec.full_name}'"
-  end
-
-  def pretty_print(q) # :nodoc:
-    q.object_group(self) do
-      q.group 2, "[SpecificFile:", "]" do
-        q.breakable
-        q.text @path
-      end
-    end
-  end
-
-  ##
-  # Orders this source against +other+.
-  #
-  # If +other+ is a SpecificFile from a different gem name +nil+ is returned.
-  #
-  # If +other+ is a SpecificFile from the same gem name the versions are
-  # compared using Gem::Version#<=>
-  #
-  # Otherwise Gem::Source#<=> is used.
-
-  def <=>(other)
-    case other
-    when Gem::Source::SpecificFile then
-      return nil if @spec.name != other.spec.name
-
-      @spec.version <=> other.spec.version
-    else
-      super
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/source/vendor.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-##
-# This represents a vendored source that is similar to an installed gem.
-
-class Gem::Source::Vendor < Gem::Source::Installed
-  ##
-  # Creates a new Vendor source for a gem that was unpacked at +path+.
-
-  def initialize(path)
-    @uri = path
-  end
-
-  def <=>(other)
-    case other
-    when Gem::Source::Lock then
-      -1
-    when Gem::Source::Vendor then
-      0
-    when Gem::Source then
-      1
-    end
-  end
-end