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

package/lib/ruby/3.4.11/bundled_gems.rb

@@ -1,248 +0,0 @@
-# -*- frozen-string-literal: true -*-
-
-module Gem::BUNDLED_GEMS # :nodoc:
-  SINCE = {
-    "matrix" => "3.1.0",
-    "net-ftp" => "3.1.0",
-    "net-imap" => "3.1.0",
-    "net-pop" => "3.1.0",
-    "net-smtp" => "3.1.0",
-    "prime" => "3.1.0",
-    "racc" => "3.3.0",
-    "abbrev" => "3.4.0",
-    "base64" => "3.4.0",
-    "bigdecimal" => "3.4.0",
-    "csv" => "3.4.0",
-    "drb" => "3.4.0",
-    "getoptlong" => "3.4.0",
-    "mutex_m" => "3.4.0",
-    "nkf" => "3.4.0",
-    "observer" => "3.4.0",
-    "resolv-replace" => "3.4.0",
-    "rinda" => "3.4.0",
-    "syslog" => "3.4.0",
-    "ostruct" => "4.0.0",
-    "pstore" => "4.0.0",
-    "rdoc" => "4.0.0",
-    "win32ole" => "4.0.0",
-    "fiddle" => "4.0.0",
-    "logger" => "4.0.0",
-    "benchmark" => "4.0.0",
-    "irb" => "4.0.0",
-    "reline" => "4.0.0",
-    # "readline" => "4.0.0", # This is wrapper for reline. We don't warn for this.
-  }.freeze
-
-  SINCE_FAST_PATH = SINCE.transform_keys { |g| g.sub(/\A.*\-/, "") }.freeze
-
-  EXACT = {
-    "kconv" => "nkf",
-  }.freeze
-
-  PREFIXED = {
-    "bigdecimal" => true,
-    "csv" => true,
-    "drb" => true,
-    "rinda" => true,
-    "syslog" => true,
-    "fiddle" => true,
-  }.freeze
-
-  WARNED = {}                   # unfrozen
-
-  conf = ::RbConfig::CONFIG
-  if ENV["TEST_BUNDLED_GEMS_FAKE_RBCONFIG"]
-    LIBDIR = (File.expand_path(File.join(__dir__, "..", "lib")) + "/").freeze
-    rubyarchdir = $LOAD_PATH.find{|path| path.include?(".ext/common") }
-    ARCHDIR = (File.expand_path(rubyarchdir) + "/").freeze
-  else
-    LIBDIR = (conf["rubylibdir"] + "/").freeze
-    ARCHDIR = (conf["rubyarchdir"] + "/").freeze
-  end
-  dlext = [conf["DLEXT"], "so"].uniq
-  DLEXT = /\.#{Regexp.union(dlext)}\z/
-  LIBEXT = /\.#{Regexp.union("rb", *dlext)}\z/
-
-  def self.replace_require(specs)
-    return if [::Kernel.singleton_class, ::Kernel].any? {|klass| klass.respond_to?(:no_warning_require) }
-
-    spec_names = specs.to_a.each_with_object({}) {|spec, h| h[spec.name] = true }
-
-    [::Kernel.singleton_class, ::Kernel].each do |kernel_class|
-      kernel_class.send(:alias_method, :no_warning_require, :require)
-      kernel_class.send(:define_method, :require) do |name|
-        if message = ::Gem::BUNDLED_GEMS.warning?(name, specs: spec_names)
-          uplevel = ::Gem::BUNDLED_GEMS.uplevel
-          if uplevel > 0
-            Kernel.warn message, uplevel: uplevel
-          else
-            Kernel.warn message
-          end
-        end
-        kernel_class.send(:no_warning_require, name)
-      end
-      if kernel_class == ::Kernel
-        kernel_class.send(:private, :require)
-      else
-        kernel_class.send(:public, :require)
-      end
-    end
-  end
-
-  def self.uplevel
-    frame_count = 0
-    require_labels = ["replace_require", "require"]
-    uplevel = 0
-    require_found = false
-    Thread.each_caller_location do |cl|
-      frame_count += 1
-
-      if require_found
-        unless require_labels.include?(cl.base_label)
-          return uplevel
-        end
-      else
-        if require_labels.include?(cl.base_label)
-          require_found = true
-        end
-      end
-      uplevel += 1
-      # Don't show script name when bundle exec and call ruby script directly.
-      if cl.path.end_with?("bundle")
-        frame_count = 0
-        break
-      end
-    end
-    require_found ? 1 : frame_count - 1
-  end
-
-  def self.find_gem(path)
-    if !path
-      return
-    elsif path.start_with?(ARCHDIR)
-      n = path.delete_prefix(ARCHDIR).sub(DLEXT, "").chomp(".rb")
-    elsif path.start_with?(LIBDIR)
-      n = path.delete_prefix(LIBDIR).chomp(".rb")
-    else
-      return
-    end
-    (EXACT[n] || !!SINCE[n]) or PREFIXED[n = n[%r[\A[^/]+(?=/)]]] && n
-  end
-
-  def self.warning?(name, specs: nil)
-    # name can be a feature name or a file path with String or Pathname
-    feature = File.path(name)
-
-    # irb already has reline as a dependency on gemspec, so we don't want to warn about it.
-    # We should update this with a more general solution when we have another case.
-    # ex: Gem.loaded_specs[called_gem].dependencies.any? {|d| d.name == feature }
-    return false if feature.start_with?("reline") && caller_locations(2, 1)[0].to_s.include?("irb")
-
-    # The actual checks needed to properly identify the gem being required
-    # are costly (see [Bug #20641]), so we first do a much cheaper check
-    # to exclude the vast majority of candidates.
-    if feature.include?("/")
-      # bootsnap expands `require "csv"` to `require "#{LIBDIR}/csv.rb"`,
-      # and `require "syslog"` to `require "#{ARCHDIR}/syslog.so"`.
-      name = feature.delete_prefix(ARCHDIR).delete_prefix(LIBDIR).sub(LIBEXT, "")
-      segments = name.split("/")
-      name = segments.first
-      if !SINCE[name]
-        name = segments[0..1].join("-")
-        return unless SINCE[name]
-      end
-    else
-      name = feature.sub(LIBEXT, "")
-      return unless SINCE_FAST_PATH[name]
-    end
-
-    return if specs.include?(name)
-    _t, path = $:.resolve_feature_path(feature)
-    if gem = find_gem(path)
-      return if specs.include?(gem)
-    elsif SINCE[name] && !path
-      gem = true
-    else
-      return
-    end
-
-    return if WARNED[name]
-    WARNED[name] = true
-    if gem == true
-      gem = name
-      "#{feature} was loaded from the standard library, but"
-    elsif gem
-      "#{feature} is found in #{gem}, which"
-    else
-      return
-    end + build_message(gem)
-  end
-
-  def self.build_message(gem)
-    msg = " #{RUBY_VERSION < SINCE[gem] ? "will no longer be" : "is not"} part of the default gems starting from Ruby #{SINCE[gem]}."
-
-    if defined?(Bundler)
-      msg += "\nYou can add #{gem} to your Gemfile or gemspec to silence this warning."
-
-      # We detect the gem name from caller_locations. First we walk until we find `require`
-      # then take the first frame that's not from `require`.
-      #
-      # Additionally, we need to skip Bootsnap and Zeitwerk if present, these
-      # gems decorate Kernel#require, so they are not really the ones issuing
-      # the require call users should be warned about. Those are upwards.
-      frames_to_skip = 3
-      location = nil
-      require_found = false
-      Thread.each_caller_location do |cl|
-        if frames_to_skip >= 1
-          frames_to_skip -= 1
-          next
-        end
-
-        if require_found
-          if cl.base_label != "require"
-            location = cl.path
-            break
-          end
-        else
-          if cl.base_label == "require"
-            require_found = true
-          end
-        end
-      end
-
-      if location && File.file?(location) && !location.start_with?(Gem::BUNDLED_GEMS::LIBDIR)
-        caller_gem = nil
-        Gem.path.each do |path|
-          if location =~ %r{#{path}/gems/([\w\-\.]+)}
-            caller_gem = $1
-            break
-          end
-        end
-        if caller_gem
-          msg += "\nAlso please contact the author of #{caller_gem} to request adding #{gem} into its gemspec."
-        end
-      end
-    else
-      msg += " Install #{gem} from RubyGems."
-    end
-
-    msg
-  end
-
-  freeze
-end
-
-# for RubyGems without Bundler environment.
-# If loading library is not part of the default gems and the bundled gems, warn it.
-class LoadError
-  def message # :nodoc:
-    return super unless path
-
-    name = path.tr("/", "-")
-    if !defined?(Bundler) && Gem::BUNDLED_GEMS::SINCE[name] && !Gem::BUNDLED_GEMS::WARNED[name]
-      warn name + Gem::BUNDLED_GEMS.build_message(name), uplevel: Gem::BUNDLED_GEMS.uplevel
-    end
-    super
-  end
-end

package/lib/ruby/3.4.11/bundler/.document

@@ -1 +0,0 @@
-# not in RDoc

package/lib/ruby/3.4.11/bundler/build_metadata.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  # Represents metadata from when the Bundler gem was built.
-  module BuildMetadata
-    # begin ivars
-    @release = false
-    # end ivars
-
-    # A hash representation of the build metadata.
-    def self.to_h
-      {
-        "Built At" => built_at,
-        "Git SHA" => git_commit_sha,
-        "Released Version" => release?,
-      }
-    end
-
-    # A string representing the date the bundler gem was built.
-    def self.built_at
-      @built_at ||= Time.now.utc.strftime("%Y-%m-%d").freeze
-    end
-
-    # The SHA for the git commit the bundler gem was built from.
-    def self.git_commit_sha
-      return @git_commit_sha if instance_variable_defined? :@git_commit_sha
-
-      # If Bundler has been installed without its .git directory and without a
-      # commit instance variable then we can't determine its commits SHA.
-      git_dir = File.expand_path("../../../.git", __dir__)
-      if File.directory?(git_dir)
-        return @git_commit_sha = IO.popen(%w[git rev-parse --short HEAD], { chdir: git_dir }, &:read).strip.freeze
-      end
-
-      @git_commit_sha ||= "unknown"
-    end
-
-    # Whether this is an official release build of Bundler.
-    def self.release?
-      @release
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/bundler.gemspec

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require_relative "lib/bundler/version"
-rescue LoadError
-  # for Ruby core repository
-  require_relative "version"
-end
-
-Gem::Specification.new do |s|
-  s.name        = "bundler"
-  s.version     = Bundler::VERSION
-  s.license     = "MIT"
-  s.authors     = [
-    "André Arko", "Samuel Giddins", "Colby Swandale", "Hiroshi Shibata",
-    "David Rodríguez", "Grey Baker", "Stephanie Morillo", "Chris Morris", "James Wen", "Tim Moore",
-    "André Medeiros", "Jessica Lynn Suttles", "Terence Lee", "Carl Lerche",
-    "Yehuda Katz"
-  ]
-  s.email       = ["team@bundler.io"]
-  s.homepage    = "https://bundler.io"
-  s.summary     = "The best way to manage your application's dependencies"
-  s.description = "Bundler manages an application's dependencies through its entire life, across many machines, systematically and repeatably"
-
-  s.metadata = {
-    "bug_tracker_uri" => "https://github.com/rubygems/rubygems/issues?q=is%3Aopen+is%3Aissue+label%3ABundler",
-    "changelog_uri" => "https://github.com/rubygems/rubygems/blob/master/bundler/CHANGELOG.md",
-    "homepage_uri" => "https://bundler.io/",
-    "source_code_uri" => "https://github.com/rubygems/rubygems/tree/master/bundler",
-  }
-
-  s.required_ruby_version     = ">= 3.1.0"
-
-  # It should match the RubyGems version shipped with `required_ruby_version` above
-  s.required_rubygems_version = ">= 3.3.3"
-
-  s.files = Dir.glob("lib/bundler{.rb,/**/*}", File::FNM_DOTMATCH).reject {|f| File.directory?(f) }
-
-  # include the gemspec itself because warbler breaks w/o it
-  s.files += %w[lib/bundler/bundler.gemspec]
-
-  s.bindir        = "exe"
-  s.executables   = %w[bundle bundler]
-  s.require_paths = ["lib"]
-end

package/lib/ruby/3.4.11/bundler/capistrano.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "shared_helpers"
-Bundler::SharedHelpers.major_deprecation 2,
-  "The Bundler task for Capistrano. Please use https://github.com/capistrano/bundler"
-
-# Capistrano task for Bundler.
-#
-# Add "require 'bundler/capistrano'" in your Capistrano deploy.rb, and
-# Bundler will be activated after each new deployment.
-require_relative "deployment"
-require "capistrano/version"
-
-if defined?(Capistrano::Version) && Gem::Version.new(Capistrano::Version).release >= Gem::Version.new("3.0")
-  raise "For Capistrano 3.x integration, please use https://github.com/capistrano/bundler"
-end
-
-Capistrano::Configuration.instance(:must_exist).load do
-  before "deploy:finalize_update", "bundle:install"
-  Bundler::Deployment.define_task(self, :task, except: { no_release: true })
-  set :rake, lambda { "#{fetch(:bundle_cmd, "bundle")} exec rake" }
-end

package/lib/ruby/3.4.11/bundler/checksum.rb

@@ -1,264 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class Checksum
-    ALGO_SEPARATOR = "="
-    DEFAULT_ALGORITHM = "sha256"
-    private_constant :DEFAULT_ALGORITHM
-    DEFAULT_BLOCK_SIZE = 16_384
-    private_constant :DEFAULT_BLOCK_SIZE
-
-    class << self
-      def from_gem_package(gem_package, algo = DEFAULT_ALGORITHM)
-        return if Bundler.settings[:disable_checksum_validation]
-        return unless source = gem_package.instance_variable_get(:@gem)
-        return unless source.respond_to?(:with_read_io)
-
-        source.with_read_io do |io|
-          from_gem(io, source.path)
-        ensure
-          io.rewind
-        end
-      end
-
-      def from_gem(io, pathname, algo = DEFAULT_ALGORITHM)
-        digest = Bundler::SharedHelpers.digest(algo.upcase).new
-        buf = String.new(capacity: DEFAULT_BLOCK_SIZE)
-        digest << io.readpartial(DEFAULT_BLOCK_SIZE, buf) until io.eof?
-        Checksum.new(algo, digest.hexdigest!, Source.new(:gem, pathname))
-      end
-
-      def from_api(digest, source_uri, algo = DEFAULT_ALGORITHM)
-        return if Bundler.settings[:disable_checksum_validation]
-
-        Checksum.new(algo, to_hexdigest(digest, algo), Source.new(:api, source_uri))
-      end
-
-      def from_lock(lock_checksum, lockfile_location)
-        algo, digest = lock_checksum.strip.split(ALGO_SEPARATOR, 2)
-        Checksum.new(algo, to_hexdigest(digest, algo), Source.new(:lock, lockfile_location))
-      end
-
-      def to_hexdigest(digest, algo = DEFAULT_ALGORITHM)
-        return digest unless algo == DEFAULT_ALGORITHM
-        return digest if digest.match?(/\A[0-9a-f]{64}\z/i)
-
-        if digest.match?(%r{\A[-0-9a-z_+/]{43}={0,2}\z}i)
-          digest = digest.tr("-_", "+/") # fix urlsafe base64
-          digest.unpack1("m0").unpack1("H*")
-        else
-          raise ArgumentError, "#{digest.inspect} is not a valid SHA256 hex or base64 digest"
-        end
-      end
-    end
-
-    attr_reader :algo, :digest, :sources
-
-    def initialize(algo, digest, source)
-      @algo = algo
-      @digest = digest
-      @sources = [source]
-    end
-
-    def ==(other)
-      match?(other) && other.sources == sources
-    end
-
-    alias_method :eql?, :==
-
-    def same_source?(other)
-      sources.include?(other.sources.first)
-    end
-
-    def match?(other)
-      other.is_a?(self.class) && other.digest == digest && other.algo == algo
-    end
-
-    def hash
-      digest.hash
-    end
-
-    def to_s
-      "#{to_lock} (from #{sources.first}#{", ..." if sources.size > 1})"
-    end
-
-    def to_lock
-      "#{algo}#{ALGO_SEPARATOR}#{digest}"
-    end
-
-    def merge!(other)
-      return nil unless match?(other)
-
-      @sources.concat(other.sources).uniq!
-      self
-    end
-
-    def formatted_sources
-      sources.join("\n    and ").concat("\n")
-    end
-
-    def removable?
-      sources.all?(&:removable?)
-    end
-
-    def removal_instructions
-      msg = +""
-      i = 1
-      sources.each do |source|
-        msg << "  #{i}. #{source.removal}\n"
-        i += 1
-      end
-      msg << "  #{i}. run `bundle install`\n"
-    end
-
-    def inspect
-      abbr = "#{algo}#{ALGO_SEPARATOR}#{digest[0, 8]}"
-      from = "from #{sources.join(" and ")}"
-      "#<#{self.class}:#{object_id} #{abbr} #{from}>"
-    end
-
-    class Source
-      attr_reader :type, :location
-
-      def initialize(type, location)
-        @type = type
-        @location = location
-      end
-
-      def removable?
-        [:lock, :gem].include?(type)
-      end
-
-      def ==(other)
-        other.is_a?(self.class) && other.type == type && other.location == location
-      end
-
-      # phrased so that the usual string format is grammatically correct
-      #   rake (10.3.2) sha256=abc123 from #{to_s}
-      def to_s
-        case type
-        when :lock
-          "the lockfile CHECKSUMS at #{location}"
-        when :gem
-          "the gem at #{location}"
-        when :api
-          "the API at #{location}"
-        else
-          "#{location} (#{type})"
-        end
-      end
-
-      # A full sentence describing how to remove the checksum
-      def removal
-        case type
-        when :lock
-          "remove the matching checksum in #{location}"
-        when :gem
-          "remove the gem at #{location}"
-        when :api
-          "checksums from #{location} cannot be locally modified, you may need to update your sources"
-        else
-          "remove #{location} (#{type})"
-        end
-      end
-    end
-
-    class Store
-      attr_reader :store
-      protected :store
-
-      def initialize
-        @store = {}
-        @store_mutex = Mutex.new
-      end
-
-      def inspect
-        "#<#{self.class}:#{object_id} size=#{store.size}>"
-      end
-
-      # Replace when the new checksum is from the same source.
-      # The primary purpose is registering checksums from gems where there are
-      # duplicates of the same gem (according to full_name) in the index.
-      #
-      # In particular, this is when 2 gems have two similar platforms, e.g.
-      # "darwin20" and "darwin-20", both of which resolve to darwin-20.
-      # In the Index, the later gem replaces the former, so we do that here.
-      #
-      # However, if the new checksum is from a different source, we register like normal.
-      # This ensures a mismatch error where there are multiple top level sources
-      # that contain the same gem with different checksums.
-      def replace(spec, checksum)
-        return unless checksum
-
-        lock_name = spec.lock_name
-        @store_mutex.synchronize do
-          existing = fetch_checksum(lock_name, checksum.algo)
-          if !existing || existing.same_source?(checksum)
-            store_checksum(lock_name, checksum)
-          else
-            merge_checksum(lock_name, checksum, existing)
-          end
-        end
-      end
-
-      def missing?(spec)
-        @store[spec.lock_name].nil?
-      end
-
-      def register(spec, checksum)
-        register_checksum(spec.lock_name, checksum)
-      end
-
-      def merge!(other)
-        other.store.each do |lock_name, checksums|
-          checksums.each do |_algo, checksum|
-            register_checksum(lock_name, checksum)
-          end
-        end
-      end
-
-      def to_lock(spec)
-        lock_name = spec.lock_name
-        checksums = @store[lock_name]
-        if checksums&.any?
-          "#{lock_name} #{checksums.values.map(&:to_lock).sort.join(",")}"
-        else
-          lock_name
-        end
-      end
-
-      private
-
-      def register_checksum(lock_name, checksum)
-        @store_mutex.synchronize do
-          if checksum
-            existing = fetch_checksum(lock_name, checksum.algo)
-            if existing
-              merge_checksum(lock_name, checksum, existing)
-            else
-              store_checksum(lock_name, checksum)
-            end
-          else
-            init_checksum(lock_name)
-          end
-        end
-      end
-
-      def merge_checksum(lock_name, checksum, existing)
-        existing.merge!(checksum) || raise(ChecksumMismatchError.new(lock_name, existing, checksum))
-      end
-
-      def store_checksum(lock_name, checksum)
-        init_checksum(lock_name)[checksum.algo] = checksum
-      end
-
-      def init_checksum(lock_name)
-        @store[lock_name] ||= {}
-      end
-
-      def fetch_checksum(lock_name, algo)
-        @store[lock_name]&.fetch(algo, nil)
-      end
-    end
-  end
-end