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

package/lib/ruby/3.4.11/bundled_gems.rb

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

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

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

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

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

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

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