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

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

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  # used for Creating Specifications from the Gemcutter Endpoint
-  class EndpointSpecification < Gem::Specification
-    include MatchRemoteMetadata
-
-    attr_reader :name, :version, :platform, :checksum
-    attr_writer :dependencies
-    attr_accessor :remote, :locked_platform
-
-    def initialize(name, version, platform, spec_fetcher, dependencies, metadata = nil)
-      super()
-      @name         = name
-      @version      = Gem::Version.create version
-      @platform     = Gem::Platform.new(platform)
-      @spec_fetcher = spec_fetcher
-      @dependencies = nil
-      @unbuilt_dependencies = dependencies
-
-      @loaded_from          = nil
-      @remote_specification = nil
-      @locked_platform = nil
-
-      parse_metadata(metadata)
-    end
-
-    def insecurely_materialized?
-      @locked_platform.to_s != @platform.to_s
-    end
-
-    def fetch_platform
-      @platform
-    end
-
-    def dependencies
-      @dependencies ||= @unbuilt_dependencies.map! {|dep, reqs| build_dependency(dep, reqs) }
-    end
-    alias_method :runtime_dependencies, :dependencies
-
-    # needed for standalone, load required_paths from local gemspec
-    # after the gem is installed
-    def require_paths
-      if @remote_specification
-        @remote_specification.require_paths
-      elsif _local_specification
-        _local_specification.require_paths
-      else
-        super
-      end
-    end
-
-    # needed for inline
-    def load_paths
-      # remote specs aren't installed, and can't have load_paths
-      if _local_specification
-        _local_specification.load_paths
-      else
-        super
-      end
-    end
-
-    # needed for binstubs
-    def executables
-      if @remote_specification
-        @remote_specification.executables
-      elsif _local_specification
-        _local_specification.executables
-      else
-        super
-      end
-    end
-
-    # needed for bundle clean
-    def bindir
-      if @remote_specification
-        @remote_specification.bindir
-      elsif _local_specification
-        _local_specification.bindir
-      else
-        super
-      end
-    end
-
-    # needed for post_install_messages during install
-    def post_install_message
-      if @remote_specification
-        @remote_specification.post_install_message
-      elsif _local_specification
-        _local_specification.post_install_message
-      else
-        super
-      end
-    end
-
-    # needed for "with native extensions" during install
-    def extensions
-      if @remote_specification
-        @remote_specification.extensions
-      elsif _local_specification
-        _local_specification.extensions
-      else
-        super
-      end
-    end
-
-    # needed for `bundle fund`
-    def metadata
-      if @remote_specification
-        @remote_specification.metadata
-      elsif _local_specification
-        _local_specification.metadata
-      else
-        super
-      end
-    end
-
-    def _local_specification
-      return unless @loaded_from && File.exist?(local_specification_path)
-      eval(File.read(local_specification_path), nil, local_specification_path).tap do |spec|
-        spec.loaded_from = @loaded_from
-      end
-    end
-
-    def __swap__(spec)
-      SharedHelpers.ensure_same_dependencies(self, dependencies, spec.dependencies)
-      @remote_specification = spec
-    end
-
-    def inspect
-      "#<#{self.class} @name=\"#{name}\" (#{full_name.delete_prefix("#{name}-")})>"
-    end
-
-    private
-
-    def _remote_specification
-      @_remote_specification ||= @spec_fetcher.fetch_spec([@name, @version, @platform])
-    end
-
-    def local_specification_path
-      "#{base_dir}/specifications/#{full_name}.gemspec"
-    end
-
-    def parse_metadata(data)
-      unless data
-        @required_ruby_version = nil
-        @required_rubygems_version = nil
-        return
-      end
-
-      data.each do |k, v|
-        next unless v
-        case k.to_s
-        when "checksum"
-          begin
-            @checksum = Checksum.from_api(v.last, @spec_fetcher.uri)
-          rescue ArgumentError => e
-            raise ArgumentError, "Invalid checksum for #{full_name}: #{e.message}"
-          end
-        when "rubygems"
-          @required_rubygems_version = Gem::Requirement.new(v)
-        when "ruby"
-          @required_ruby_version = Gem::Requirement.new(v)
-        end
-      end
-    rescue StandardError => e
-      raise GemspecError, "There was an error parsing the metadata for the gem #{name} (#{version}): #{e.class}\n#{e}\nThe metadata was #{data.inspect}"
-    end
-
-    def build_dependency(name, requirements)
-      Dependency.new(name, requirements)
-    end
-  end
-end

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

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "rubygems_integration"
-require_relative "source/git/git_proxy"
-
-module Bundler
-  class Env
-    def self.write(io)
-      io.write report
-    end
-
-    def self.report(options = {})
-      print_gemfile = options.delete(:print_gemfile) { true }
-      print_gemspecs = options.delete(:print_gemspecs) { true }
-
-      out = String.new
-      append_formatted_table("Environment", environment, out)
-      append_formatted_table("Bundler Build Metadata", BuildMetadata.to_h, out)
-
-      unless Bundler.settings.all.empty?
-        out << "\n## Bundler settings\n\n```\n"
-        Bundler.settings.all.each do |setting|
-          out << setting << "\n"
-          Bundler.settings.pretty_values_for(setting).each do |line|
-            out << "  " << line << "\n"
-          end
-        end
-        out << "```\n"
-      end
-
-      return out unless SharedHelpers.in_bundle?
-
-      if print_gemfile
-        gemfiles = [Bundler.default_gemfile]
-        begin
-          gemfiles = Bundler.definition.gemfiles
-        rescue GemfileNotFound
-          nil
-        end
-
-        out << "\n## Gemfile\n"
-        gemfiles.each do |gemfile|
-          out << "\n### #{SharedHelpers.relative_path_to(gemfile)}\n\n"
-          out << "```ruby\n" << read_file(gemfile).chomp << "\n```\n"
-        end
-
-        out << "\n### #{SharedHelpers.relative_path_to(Bundler.default_lockfile)}\n\n"
-        out << "```\n" << read_file(Bundler.default_lockfile).chomp << "\n```\n"
-      end
-
-      if print_gemspecs
-        dsl = Dsl.new.tap {|d| d.eval_gemfile(Bundler.default_gemfile) }
-        out << "\n## Gemspecs\n" unless dsl.gemspecs.empty?
-        dsl.gemspecs.each do |gs|
-          out << "\n### #{File.basename(gs.loaded_from)}"
-          out << "\n\n```ruby\n" << read_file(gs.loaded_from).chomp << "\n```\n"
-        end
-      end
-
-      out
-    end
-
-    def self.read_file(filename)
-      Bundler.read_file(filename.to_s).strip
-    rescue Errno::ENOENT
-      "<No #{filename} found>"
-    rescue RuntimeError => e
-      "#{e.class}: #{e.message}"
-    end
-
-    def self.ruby_version
-      "#{RUBY_VERSION}p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE} revision #{RUBY_REVISION}) [#{Gem::Platform.local}]"
-    end
-
-    def self.git_version
-      Bundler::Source::Git::GitProxy.new(nil, nil).full_version
-    rescue Bundler::Source::Git::GitNotInstalledError
-      "not installed"
-    end
-
-    def self.version_of(script)
-      return "not installed" unless Bundler.which(script)
-      `#{script} --version`.chomp
-    end
-
-    def self.chruby_version
-      return "not installed" unless Bundler.which("chruby-exec")
-      `chruby-exec -- chruby --version`.
-        sub(/.*^chruby: (#{Gem::Version::VERSION_PATTERN}).*/m, '\1')
-    end
-
-    def self.environment
-      out = []
-
-      out << ["Bundler", Bundler::VERSION]
-      out << ["  Platforms", Gem.platforms.join(", ")]
-      out << ["Ruby", ruby_version]
-      out << ["  Full Path", Gem.ruby]
-      out << ["  Config Dir", Pathname.new(Gem::ConfigFile::SYSTEM_WIDE_CONFIG_FILE).dirname]
-      out << ["RubyGems", Gem::VERSION]
-      out << ["  Gem Home", Gem.dir]
-      out << ["  Gem Path", Gem.path.join(File::PATH_SEPARATOR)]
-      out << ["  User Home", Gem.user_home]
-      out << ["  User Path", Gem.user_dir]
-      out << ["  Bin Dir", Gem.bindir]
-      if defined?(OpenSSL::SSL)
-        out << ["OpenSSL"]
-        out << ["  Compiled", OpenSSL::OPENSSL_VERSION] if defined?(OpenSSL::OPENSSL_VERSION)
-        out << ["  Loaded", OpenSSL::OPENSSL_LIBRARY_VERSION] if defined?(OpenSSL::OPENSSL_LIBRARY_VERSION)
-        out << ["  Cert File", OpenSSL::X509::DEFAULT_CERT_FILE] if defined?(OpenSSL::X509::DEFAULT_CERT_FILE)
-        out << ["  Cert Dir", OpenSSL::X509::DEFAULT_CERT_DIR] if defined?(OpenSSL::X509::DEFAULT_CERT_DIR)
-      end
-      out << ["Tools"]
-      out << ["  Git", git_version]
-      out << ["  RVM", ENV.fetch("rvm_version") { version_of("rvm") }]
-      out << ["  rbenv", version_of("rbenv")]
-      out << ["  chruby", chruby_version]
-
-      %w[rubygems-bundler open_gem].each do |name|
-        specs = Bundler.rubygems.find_name(name)
-        out << ["  #{name}", "(#{specs.map(&:version).join(",")})"] unless specs.empty?
-      end
-      if (exe = caller_locations.last.absolute_path)&.match? %r{(exe|bin)/bundler?\z}
-        shebang = File.read(exe).lines.first
-        shebang.sub!(/^#!\s*/, "")
-        unless shebang.start_with?(Gem.ruby, "/usr/bin/env ruby")
-          out << ["Gem.ruby", Gem.ruby]
-          out << ["bundle #!", shebang]
-        end
-      end
-
-      out
-    end
-
-    def self.append_formatted_table(title, pairs, out)
-      return if pairs.empty?
-      out << "\n" unless out.empty?
-      out << "## #{title}\n\n```\n"
-      ljust = pairs.map {|k, _v| k.to_s.length }.max
-      pairs.each do |k, v|
-        out << "#{k.to_s.ljust(ljust)}  #{v}\n"
-      end
-      out << "```\n"
-    end
-
-    private_class_method :read_file, :ruby_version, :git_version, :append_formatted_table, :version_of, :chruby_version
-  end
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class EnvironmentPreserver
-    INTENTIONALLY_NIL = "BUNDLER_ENVIRONMENT_PRESERVER_INTENTIONALLY_NIL"
-    BUNDLER_KEYS = %w[
-      BUNDLE_BIN_PATH
-      BUNDLE_GEMFILE
-      BUNDLER_VERSION
-      BUNDLER_SETUP
-      GEM_HOME
-      GEM_PATH
-      MANPATH
-      PATH
-      RB_USER_INSTALL
-      RUBYLIB
-      RUBYOPT
-    ].map(&:freeze).freeze
-    BUNDLER_PREFIX = "BUNDLER_ORIG_"
-
-    def self.from_env
-      new(ENV.to_hash, BUNDLER_KEYS)
-    end
-
-    # @param env [Hash]
-    # @param keys [Array<String>]
-    def initialize(env, keys)
-      @original = env
-      @keys = keys
-      @prefix = BUNDLER_PREFIX
-    end
-
-    # Replaces `ENV` with the bundler environment variables backed up
-    def replace_with_backup
-      ENV.replace(backup)
-    end
-
-    # @return [Hash]
-    def backup
-      env = @original.clone
-      @keys.each do |key|
-        value = env[key]
-        if !value.nil?
-          env[@prefix + key] ||= value
-        else
-          env[@prefix + key] ||= INTENTIONALLY_NIL
-        end
-      end
-      env
-    end
-
-    # @return [Hash]
-    def restore
-      env = @original.clone
-      @keys.each do |key|
-        value_original = env[@prefix + key]
-        next if value_original.nil?
-        if value_original == INTENTIONALLY_NIL
-          env.delete(key)
-        else
-          env[key] = value_original
-        end
-        env.delete(@prefix + key)
-      end
-      env
-    end
-  end
-end

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

@@ -1,281 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class BundlerError < StandardError
-    def self.status_code(code)
-      define_method(:status_code) { code }
-      if match = BundlerError.all_errors.find {|_k, v| v == code }
-        error, _ = match
-        raise ArgumentError,
-          "Trying to register #{self} for status code #{code} but #{error} is already registered"
-      end
-      BundlerError.all_errors[self] = code
-    end
-
-    def self.all_errors
-      @all_errors ||= {}
-    end
-  end
-
-  class GemfileError < BundlerError; status_code(4); end
-  class InstallError < BundlerError; status_code(5); end
-
-  # Internal error, should be rescued
-  class SolveFailure < BundlerError; status_code(6); end
-
-  class GemNotFound < BundlerError; status_code(7); end
-  class InstallHookError < BundlerError; status_code(8); end
-  class GemfileNotFound < BundlerError; status_code(10); end
-  class GitError < BundlerError; status_code(11); end
-  class DeprecatedError < BundlerError; status_code(12); end
-  class PathError < BundlerError; status_code(13); end
-  class GemspecError < BundlerError; status_code(14); end
-  class InvalidOption < BundlerError; status_code(15); end
-  class ProductionError < BundlerError; status_code(16); end
-
-  class HTTPError < BundlerError
-    status_code(17)
-    def filter_uri(uri)
-      URICredentialsFilter.credential_filtered_uri(uri)
-    end
-  end
-
-  class RubyVersionMismatch < BundlerError; status_code(18); end
-  class SecurityError < BundlerError; status_code(19); end
-  class LockfileError < BundlerError; status_code(20); end
-  class CyclicDependencyError < BundlerError; status_code(21); end
-  class GemfileLockNotFound < BundlerError; status_code(22); end
-  class PluginError < BundlerError; status_code(29); end
-  class ThreadCreationError < BundlerError; status_code(33); end
-  class APIResponseMismatchError < BundlerError; status_code(34); end
-  class APIResponseInvalidDependenciesError < BundlerError; status_code(35); end
-  class GemfileEvalError < GemfileError; end
-  class MarshalError < StandardError; end
-
-  class ChecksumMismatchError < SecurityError
-    def initialize(lock_name, existing, checksum)
-      @lock_name = lock_name
-      @existing = existing
-      @checksum = checksum
-    end
-
-    def message
-      <<~MESSAGE
-        Bundler found mismatched checksums. This is a potential security risk.
-          #{@lock_name} #{@existing.to_lock}
-            from #{@existing.sources.join("\n    and ")}
-          #{@lock_name} #{@checksum.to_lock}
-            from #{@checksum.sources.join("\n    and ")}
-
-        #{mismatch_resolution_instructions}
-        To ignore checksum security warnings, disable checksum validation with
-          `bundle config set --local disable_checksum_validation true`
-      MESSAGE
-    end
-
-    def mismatch_resolution_instructions
-      removable, remote = [@existing, @checksum].partition(&:removable?)
-      case removable.size
-      when 0
-        msg = +"Mismatched checksums each have an authoritative source:\n"
-        msg << "  1. #{@existing.sources.reject(&:removable?).map(&:to_s).join(" and ")}\n"
-        msg << "  2. #{@checksum.sources.reject(&:removable?).map(&:to_s).join(" and ")}\n"
-        msg << "You may need to alter your Gemfile sources to resolve this issue.\n"
-      when 1
-        msg = +"If you trust #{remote.first.sources.first}, to resolve this issue you can:\n"
-        msg << removable.first.removal_instructions
-      when 2
-        msg = +"To resolve this issue you can either:\n"
-        msg << @checksum.removal_instructions
-        msg << "or if you are sure that the new checksum from #{@checksum.sources.first} is correct:\n"
-        msg << @existing.removal_instructions
-      end
-    end
-
-    status_code(37)
-  end
-
-  class PermissionError < BundlerError
-    def initialize(path, permission_type = :write)
-      @path = path
-      @permission_type = permission_type
-    end
-
-    def action
-      case @permission_type
-      when :read then "read from"
-      when :write then "write to"
-      when :executable, :exec then "execute"
-      else @permission_type.to_s
-      end
-    end
-
-    def permission_type
-      case @permission_type
-      when :create
-        "executable permissions for all parent directories and write permissions for `#{parent_folder}`"
-      else
-        "#{@permission_type} permissions for that path"
-      end
-    end
-
-    def parent_folder
-      File.dirname(@path)
-    end
-
-    def message
-      "There was an error while trying to #{action} `#{@path}`. " \
-      "It is likely that you need to grant #{permission_type}."
-    end
-
-    status_code(23)
-  end
-
-  class GemRequireError < BundlerError
-    attr_reader :orig_exception
-
-    def initialize(orig_exception, msg)
-      full_message = msg + "\nGem Load Error is: #{orig_exception.message}\n"\
-                      "Backtrace for gem load error is:\n"\
-                      "#{orig_exception.backtrace.join("\n")}\n"\
-                      "Bundler Error Backtrace:\n"
-      super(full_message)
-      @orig_exception = orig_exception
-    end
-
-    status_code(24)
-  end
-
-  class YamlSyntaxError < BundlerError
-    attr_reader :orig_exception
-
-    def initialize(orig_exception, msg)
-      super(msg)
-      @orig_exception = orig_exception
-    end
-
-    status_code(25)
-  end
-
-  class TemporaryResourceError < PermissionError
-    def message
-      "There was an error while trying to #{action} `#{@path}`. " \
-      "Some resource was temporarily unavailable. It's suggested that you try" \
-      "the operation again."
-    end
-
-    status_code(26)
-  end
-
-  class VirtualProtocolError < BundlerError
-    def message
-      "There was an error relating to virtualization and file access. " \
-      "It is likely that you need to grant access to or mount some file system correctly."
-    end
-
-    status_code(27)
-  end
-
-  class OperationNotSupportedError < PermissionError
-    def message
-      "Attempting to #{action} `#{@path}` is unsupported by your OS."
-    end
-
-    status_code(28)
-  end
-
-  class NoSpaceOnDeviceError < PermissionError
-    def message
-      "There was an error while trying to #{action} `#{@path}`. " \
-      "There was insufficient space remaining on the device."
-    end
-
-    status_code(31)
-  end
-
-  class ReadOnlyFileSystemError < PermissionError
-    def message
-      "There was an error while trying to #{action} `#{@path}`. " \
-      "File system is read-only."
-    end
-
-    status_code(42)
-  end
-
-  class OperationNotPermittedError < PermissionError
-    def message
-      "There was an error while trying to #{action} `#{@path}`. " \
-      "Underlying OS system call raised an EPERM error."
-    end
-
-    status_code(43)
-  end
-
-  class GenericSystemCallError < BundlerError
-    attr_reader :underlying_error
-
-    def initialize(underlying_error, message)
-      @underlying_error = underlying_error
-      super("#{message}\nThe underlying system error is #{@underlying_error.class}: #{@underlying_error}")
-    end
-
-    status_code(32)
-  end
-
-  class DirectoryRemovalError < BundlerError
-    def initialize(orig_exception, msg)
-      full_message = "#{msg}.\n" \
-                     "The underlying error was #{orig_exception.class}: #{orig_exception.message}, with backtrace:\n" \
-                     "  #{orig_exception.backtrace.join("\n  ")}\n\n" \
-                     "Bundler Error Backtrace:"
-      super(full_message)
-    end
-
-    status_code(36)
-  end
-
-  class InsecureInstallPathError < BundlerError
-    def initialize(name, path)
-      @name = name
-      @path = path
-    end
-
-    def message
-      "Bundler cannot reinstall #{@name} because there's a previous installation of it at #{@path} that is unsafe to remove.\n" \
-      "The parent of #{@path} is world-writable and does not have the sticky bit set, making it insecure to remove due to potential vulnerabilities.\n" \
-      "Please change the permissions of #{File.dirname(@path)} or choose a different install path."
-    end
-
-    status_code(38)
-  end
-
-  class CorruptBundlerInstallError < BundlerError
-    def initialize(loaded_spec)
-      @loaded_spec = loaded_spec
-    end
-
-    def message
-      "The running version of Bundler (#{Bundler::VERSION}) does not match the version of the specification installed for it (#{@loaded_spec.version}). " \
-      "This can be caused by reinstalling Ruby without removing previous installation, leaving around an upgraded default version of Bundler. " \
-      "Reinstalling Ruby from scratch should fix the problem."
-    end
-
-    status_code(39)
-  end
-
-  class InvalidArgumentError < BundlerError; status_code(40); end
-
-  class IncorrectLockfileDependencies < BundlerError
-    attr_reader :spec
-
-    def initialize(spec)
-      @spec = spec
-    end
-
-    def message
-      "Bundler found incorrect dependencies in the lockfile for #{spec.full_name}"
-    end
-
-    status_code(41)
-  end
-end