npm - @ai-ecoverse/wasix-ruby - Versions diffs - 3.4.11-3 → 3.4.11-4 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1127) hide show

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

@@ -1,247 +0,0 @@
-# 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 DELETED Viewed

@@ -1,146 +0,0 @@
-# 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 DELETED Viewed

@@ -1,290 +0,0 @@
-# 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