@ai-ecoverse/wasix-ruby 3.4.11-1

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

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require_relative "text"
+##
+# A Source knows how to list and fetch gems from a RubyGems marshal index.
+#
+# There are other Source subclasses for installed gems, local gems, the
+# bundler dependency API and so-forth.
+
+class Gem::Source
+  include Comparable
+  include Gem::Text
+
+  FILES = { # :nodoc:
+    released: "specs",
+    latest: "latest_specs",
+    prerelease: "prerelease_specs",
+  }.freeze
+
+  ##
+  # The URI this source will fetch gems from.
+
+  attr_reader :uri
+
+  ##
+  # Creates a new Source which will use the index located at +uri+.
+
+  def initialize(uri)
+    require_relative "uri"
+    @uri = Gem::Uri.parse!(uri)
+    @update_cache = nil
+  end
+
+  ##
+  # Sources are ordered by installation preference.
+
+  def <=>(other)
+    case other
+    when Gem::Source::Installed,
+         Gem::Source::Local,
+         Gem::Source::Lock,
+         Gem::Source::SpecificFile,
+         Gem::Source::Git,
+         Gem::Source::Vendor then
+      -1
+    when Gem::Source then
+      unless @uri
+        return 0 unless other.uri
+        return 1
+      end
+
+      return -1 unless other.uri
+
+      # Returning 1 here ensures that when sorting a list of sources, the
+      # original ordering of sources supplied by the user is preserved.
+      return 1 unless @uri.to_s == other.uri.to_s
+
+      0
+    end
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other && @uri == other.uri
+  end
+
+  alias_method :eql?, :== # :nodoc:
+
+  ##
+  # Returns a Set that can fetch specifications from this source.
+
+  def dependency_resolver_set # :nodoc:
+    return Gem::Resolver::IndexSet.new self if uri.scheme == "file"
+
+    fetch_uri = if uri.host == "rubygems.org"
+      index_uri = uri.dup
+      index_uri.host = "index.rubygems.org"
+      index_uri
+    else
+      uri
+    end
+
+    bundler_api_uri = enforce_trailing_slash(fetch_uri) + "versions"
+
+    begin
+      fetcher = Gem::RemoteFetcher.fetcher
+      response = fetcher.fetch_path bundler_api_uri, nil, true
+    rescue Gem::RemoteFetcher::FetchError
+      Gem::Resolver::IndexSet.new self
+    else
+      Gem::Resolver::APISet.new response.uri + "./info/"
+    end
+  end
+
+  def hash # :nodoc:
+    @uri.hash
+  end
+
+  ##
+  # Returns the local directory to write +uri+ to.
+
+  def cache_dir(uri)
+    # Correct for windows paths
+    escaped_path = uri.path.sub(%r{^/([a-z]):/}i, '/\\1-/')
+
+    File.join Gem.spec_cache_dir, "#{uri.host}%#{uri.port}", File.dirname(escaped_path)
+  end
+
+  ##
+  # Returns true when it is possible and safe to update the cache directory.
+
+  def update_cache?
+    return @update_cache unless @update_cache.nil?
+    @update_cache =
+      begin
+        File.stat(Gem.user_home).uid == Process.uid
+      rescue Errno::ENOENT
+        false
+      end
+  end
+
+  ##
+  # Fetches a specification for the given +name_tuple+.
+
+  def fetch_spec(name_tuple)
+    fetcher = Gem::RemoteFetcher.fetcher
+
+    spec_file_name = name_tuple.spec_name
+
+    source_uri = enforce_trailing_slash(uri) + "#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}"
+
+    cache_dir = cache_dir source_uri
+
+    local_spec = File.join cache_dir, spec_file_name
+
+    if File.exist? local_spec
+      spec = Gem.read_binary local_spec
+      Gem.load_safe_marshal
+      spec = begin
+               Gem::SafeMarshal.safe_load(spec)
+             rescue StandardError
+               nil
+             end
+      return spec if spec
+    end
+
+    source_uri.path << ".rz"
+
+    spec = fetcher.fetch_path source_uri
+    spec = Gem::Util.inflate spec
+
+    if update_cache?
+      require "fileutils"
+      FileUtils.mkdir_p cache_dir
+
+      File.open local_spec, "wb" do |io|
+        io.write spec
+      end
+    end
+
+    Gem.load_safe_marshal
+    # TODO: Investigate setting Gem::Specification#loaded_from to a URI
+    Gem::SafeMarshal.safe_load spec
+  end
+
+  ##
+  # Loads +type+ kind of specs fetching from +@uri+ if the on-disk cache is
+  # out of date.
+  #
+  # +type+ is one of the following:
+  #
+  # :released   => Return the list of all released specs
+  # :latest     => Return the list of only the highest version of each gem
+  # :prerelease => Return the list of all prerelease only specs
+  #
+
+  def load_specs(type)
+    file       = FILES[type]
+    fetcher    = Gem::RemoteFetcher.fetcher
+    file_name  = "#{file}.#{Gem.marshal_version}"
+    spec_path  = enforce_trailing_slash(uri) + "#{file_name}.gz"
+    cache_dir  = cache_dir spec_path
+    local_file = File.join(cache_dir, file_name)
+    retried    = false
+
+    if update_cache?
+      require "fileutils"
+      FileUtils.mkdir_p cache_dir
+    end
+
+    spec_dump = fetcher.cache_update_path spec_path, local_file, update_cache?
+
+    Gem.load_safe_marshal
+    begin
+      Gem::NameTuple.from_list Gem::SafeMarshal.safe_load(spec_dump)
+    rescue ArgumentError
+      if update_cache? && !retried
+        FileUtils.rm local_file
+        retried = true
+        retry
+      else
+        raise Gem::Exception.new("Invalid spec cache file in #{local_file}")
+      end
+    end
+  end
+
+  ##
+  # Downloads +spec+ and writes it to +dir+.  See also
+  # Gem::RemoteFetcher#download.
+
+  def download(spec, dir=Dir.pwd)
+    fetcher = Gem::RemoteFetcher.fetcher
+    fetcher.download spec, uri.to_s, dir
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.object_group(self) do
+      q.group 2, "[Remote:", "]" do
+        q.breakable
+        q.text @uri.to_s
+
+        if api = uri
+          q.breakable
+          q.text "API URI: "
+          q.text api.to_s
+        end
+      end
+    end
+  end
+
+  def typo_squatting?(host, distance_threshold=4)
+    return if @uri.host.nil?
+    levenshtein_distance(@uri.host, host).between? 1, distance_threshold
+  end
+
+  private
+
+  def enforce_trailing_slash(uri)
+    uri.merge(uri.path.gsub(%r{/+$}, "") + "/")
+  end
+end
+
+require_relative "source/git"
+require_relative "source/installed"
+require_relative "source/specific_file"
+require_relative "source/local"
+require_relative "source/lock"
+require_relative "source/vendor"

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+##
+# The SourceList represents the sources rubygems has been configured to use.
+# A source may be created from an array of sources:
+#
+#   Gem::SourceList.from %w[https://rubygems.example https://internal.example]
+#
+# Or by adding them:
+#
+#   sources = Gem::SourceList.new
+#   sources << 'https://rubygems.example'
+#
+# The most common way to get a SourceList is Gem.sources.
+
+class Gem::SourceList
+  include Enumerable
+
+  ##
+  # Creates a new SourceList
+
+  def initialize
+    @sources = []
+  end
+
+  ##
+  # The sources in this list
+
+  attr_reader :sources
+
+  ##
+  # Creates a new SourceList from an array of sources.
+
+  def self.from(ary)
+    list = new
+
+    list.replace ary
+
+    list
+  end
+
+  def initialize_copy(other) # :nodoc:
+    @sources = @sources.dup
+  end
+
+  ##
+  # Appends +obj+ to the source list which may be a Gem::Source, Gem::URI or URI
+  # String.
+
+  def <<(obj)
+    src = case obj
+          when Gem::Source
+            obj
+          else
+            Gem::Source.new(obj)
+    end
+
+    @sources << src unless @sources.include?(src)
+    src
+  end
+
+  ##
+  # Replaces this SourceList with the sources in +other+  See #<< for
+  # acceptable items in +other+.
+
+  def replace(other)
+    clear
+
+    other.each do |x|
+      self << x
+    end
+
+    self
+  end
+
+  ##
+  # Removes all sources from the SourceList.
+
+  def clear
+    @sources.clear
+  end
+
+  ##
+  # Yields each source URI in the list.
+
+  def each
+    @sources.each {|s| yield s.uri.to_s }
+  end
+
+  ##
+  # Yields each source in the list.
+
+  def each_source(&b)
+    @sources.each(&b)
+  end
+
+  ##
+  # Returns true if there are no sources in this SourceList.
+
+  def empty?
+    @sources.empty?
+  end
+
+  def ==(other) # :nodoc:
+    to_a == other
+  end
+
+  ##
+  # Returns an Array of source URI Strings.
+
+  def to_a
+    @sources.map {|x| x.uri.to_s }
+  end
+
+  alias_method :to_ary, :to_a
+
+  ##
+  # Returns the first source in the list.
+
+  def first
+    @sources.first
+  end
+
+  ##
+  # Returns true if this source list includes +other+ which may be a
+  # Gem::Source or a source URI.
+
+  def include?(other)
+    if other.is_a? Gem::Source
+      @sources.include? other
+    else
+      @sources.find {|x| x.uri.to_s == other.to_s }
+    end
+  end
+
+  ##
+  # Deletes +source+ from the source list which may be a Gem::Source or a URI.
+
+  def delete(source)
+    if source.is_a? Gem::Source
+      @sources.delete source
+    else
+      @sources.delete_if {|x| x.uri.to_s == source.to_s }
+    end
+  end
+end

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

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require_relative "remote_fetcher"
+require_relative "user_interaction"
+require_relative "errors"
+require_relative "text"
+require_relative "name_tuple"
+
+##
+# SpecFetcher handles metadata updates from remote gem repositories.
+
+class Gem::SpecFetcher
+  include Gem::UserInteraction
+  include Gem::Text
+
+  ##
+  # Cache of latest specs
+
+  attr_reader :latest_specs # :nodoc:
+
+  ##
+  # Sources for this SpecFetcher
+
+  attr_reader :sources # :nodoc:
+
+  ##
+  # Cache of all released specs
+
+  attr_reader :specs # :nodoc:
+
+  ##
+  # Cache of prerelease specs
+
+  attr_reader :prerelease_specs # :nodoc:
+
+  @fetcher = nil
+
+  ##
+  # Default fetcher instance.  Use this instead of ::new to reduce object
+  # allocation.
+
+  def self.fetcher
+    @fetcher ||= new
+  end
+
+  def self.fetcher=(fetcher) # :nodoc:
+    @fetcher = fetcher
+  end
+
+  ##
+  # Creates a new SpecFetcher.  Ordinarily you want to use the default fetcher
+  # from Gem::SpecFetcher::fetcher which uses the Gem.sources.
+  #
+  # If you need to retrieve specifications from a different +source+, you can
+  # send it as an argument.
+
+  def initialize(sources = nil)
+    @sources = sources || Gem.sources
+
+    @update_cache =
+      begin
+        File.stat(Gem.user_home).uid == Process.uid
+      rescue Errno::EACCES, Errno::ENOENT
+        false
+      end
+
+    @specs = {}
+    @latest_specs = {}
+    @prerelease_specs = {}
+
+    @caches = {
+      latest: @latest_specs,
+      prerelease: @prerelease_specs,
+      released: @specs,
+    }
+
+    @fetcher = Gem::RemoteFetcher.fetcher
+  end
+
+  ##
+  #
+  # Find and fetch gem name tuples that match +dependency+.
+  #
+  # If +matching_platform+ is false, gems for all platforms are returned.
+
+  def search_for_dependency(dependency, matching_platform=true)
+    found = {}
+
+    rejected_specs = {}
+
+    list, errors = available_specs(dependency.identity)
+
+    list.each do |source, specs|
+      if dependency.name.is_a?(String) && specs.respond_to?(:bsearch)
+        start_index = (0...specs.length).bsearch {|i| specs[i].name >= dependency.name }
+        end_index   = (0...specs.length).bsearch {|i| specs[i].name > dependency.name }
+        specs = specs[start_index...end_index] if start_index && end_index
+      end
+
+      found[source] = specs.select do |tup|
+        if dependency.match?(tup)
+          if matching_platform && !Gem::Platform.match_gem?(tup.platform, tup.name)
+            pm = (
+              rejected_specs[dependency] ||= \
+                Gem::PlatformMismatch.new(tup.name, tup.version))
+            pm.add_platform tup.platform
+            false
+          else
+            true
+          end
+        end
+      end
+    end
+
+    errors += rejected_specs.values
+
+    tuples = []
+
+    found.each do |source, specs|
+      specs.each do |s|
+        tuples << [s, source]
+      end
+    end
+
+    tuples = tuples.sort_by {|x| x[0].version }
+
+    [tuples, errors]
+  end
+
+  ##
+  # Return all gem name tuples who's names match +obj+
+
+  def detect(type=:complete)
+    tuples = []
+
+    list, _ = available_specs(type)
+    list.each do |source, specs|
+      specs.each do |tup|
+        if yield(tup)
+          tuples << [tup, source]
+        end
+      end
+    end
+
+    tuples
+  end
+
+  ##
+  # Find and fetch specs that match +dependency+.
+  #
+  # If +matching_platform+ is false, gems for all platforms are returned.
+
+  def spec_for_dependency(dependency, matching_platform=true)
+    tuples, errors = search_for_dependency(dependency, matching_platform)
+
+    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
+
+    [specs, errors]
+  end
+
+  ##
+  # Suggests gems based on the supplied +gem_name+. Returns an array of
+  # alternative gem names.
+
+  def suggest_gems_from_name(gem_name, type = :latest, num_results = 5)
+    gem_name = gem_name.downcase.tr("_-", "")
+
+    # All results for 3-character-or-shorter (minus hyphens/underscores) gem
+    # names get rejected, so we just return an empty array immediately instead.
+    return [] if gem_name.length <= 3
+
+    max   = gem_name.size / 2
+    names = available_specs(type).first.values.flatten(1)
+
+    min_length = gem_name.length - max
+    max_length = gem_name.length + max
+
+    gem_name_with_postfix = "#{gem_name}ruby"
+    gem_name_with_prefix = "ruby#{gem_name}"
+
+    matches = names.filter_map do |n|
+      len = n.name.length
+      # If the gem doesn't support the current platform, bail early.
+      next unless n.match_platform?
+
+      # If the length is min_length or shorter, we've done `max` deletions.
+      # This would be rejected later, so we skip it for performance.
+      next if len <= min_length
+
+      # The candidate name, normalized the same as gem_name.
+      normalized_name = n.name.downcase
+      normalized_name.tr!("_-", "")
+
+      # If the gem is "{NAME}-ruby" and "ruby-{NAME}", we want to return it.
+      # But we already removed hyphens, so we check "{NAME}ruby" and "ruby{NAME}".
+      next [n.name, 0] if normalized_name == gem_name_with_postfix
+      next [n.name, 0] if normalized_name == gem_name_with_prefix
+
+      # If the length is max_length or longer, we've done `max` insertions.
+      # This would be rejected later, so we skip it for performance.
+      next if len >= max_length
+
+      # If we found an exact match (after stripping underscores and hyphens),
+      # that's our most likely candidate.
+      # Return it immediately, and skip the rest of the loop.
+      return [n.name] if normalized_name == gem_name
+
+      distance = levenshtein_distance gem_name, normalized_name
+
+      # Skip current candidate, if the edit distance is greater than allowed.
+      next if distance >= max
+
+      # If all else fails, return the name and the calculated distance.
+      [n.name, distance]
+    end
+
+    matches = if matches.empty? && type != :prerelease
+      suggest_gems_from_name gem_name, :prerelease
+    else
+      matches.uniq.sort_by {|_name, dist| dist }
+    end
+
+    matches.map {|name, _dist| name }.uniq.first(num_results)
+  end
+
+  ##
+  # Returns a list of gems available for each source in Gem::sources.
+  #
+  # +type+ can be one of 3 values:
+  # :released   => Return the list of all released specs
+  # :complete   => Return the list of all specs
+  # :latest     => Return the list of only the highest version of each gem
+  # :prerelease => Return the list of all prerelease only specs
+  #
+
+  def available_specs(type)
+    errors = []
+    list = {}
+
+    @sources.each_source do |source|
+      names = case type
+              when :latest
+                tuples_for source, :latest
+              when :released
+                tuples_for source, :released
+              when :complete
+                names =
+                  tuples_for(source, :prerelease, true) +
+                  tuples_for(source, :released)
+
+                names.sort
+              when :abs_latest
+                names =
+                  tuples_for(source, :prerelease, true) +
+                  tuples_for(source, :latest)
+
+                names.sort
+              when :prerelease
+                tuples_for(source, :prerelease)
+              else
+                raise Gem::Exception, "Unknown type - :#{type}"
+      end
+    rescue Gem::RemoteFetcher::FetchError => e
+      errors << Gem::SourceFetchProblem.new(source, e)
+    else
+      list[source] = names
+    end
+
+    [list, errors]
+  end
+
+  ##
+  # Retrieves NameTuples from +source+ of the given +type+ (:prerelease,
+  # etc.).  If +gracefully_ignore+ is true, errors are ignored.
+
+  def tuples_for(source, type, gracefully_ignore=false) # :nodoc:
+    @caches[type][source.uri] ||=
+      source.load_specs(type).sort_by(&:name)
+  rescue Gem::RemoteFetcher::FetchError
+    raise unless gracefully_ignore
+    []
+  end
+end