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

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

@@ -1,320 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class Runtime
-    include SharedHelpers
-
-    def initialize(root, definition)
-      @root = root
-      @definition = definition
-    end
-
-    def setup(*groups)
-      @definition.ensure_equivalent_gemfile_and_lockfile
-
-      # Has to happen first
-      clean_load_path
-
-      specs = @definition.specs_for(groups)
-
-      SharedHelpers.set_bundle_environment
-      Bundler.rubygems.replace_entrypoints(specs)
-
-      # Activate the specs
-      load_paths = specs.map do |spec|
-        check_for_activated_spec!(spec)
-
-        Bundler.rubygems.mark_loaded(spec)
-        spec.load_paths.reject {|path| $LOAD_PATH.include?(path) }
-      end.reverse.flatten
-
-      Gem.add_to_load_path(*load_paths)
-
-      setup_manpath
-
-      lock(preserve_unknown_sections: true)
-
-      self
-    end
-
-    def require(*groups)
-      groups.map!(&:to_sym)
-      groups = [:default] if groups.empty?
-
-      dependencies = @definition.dependencies.select do |dep|
-        # Select the dependency if it is in any of the requested groups, and
-        # for the current platform, and matches the gem constraints.
-        (dep.groups & groups).any? && dep.should_include?
-      end
-
-      Plugin.hook(Plugin::Events::GEM_BEFORE_REQUIRE_ALL, dependencies)
-
-      dependencies.each do |dep|
-        Plugin.hook(Plugin::Events::GEM_BEFORE_REQUIRE, dep)
-
-        # Loop through all the specified autorequires for the
-        # dependency. If there are none, use the dependency's name
-        # as the autorequire.
-        Array(dep.autorequire || dep.name).each do |file|
-          # Allow `require: true` as an alias for `require: <name>`
-          file = dep.name if file == true
-          required_file = file
-          begin
-            Kernel.require required_file
-          rescue LoadError => e
-            if dep.autorequire.nil? && e.path == required_file
-              if required_file.include?("-")
-                required_file = required_file.tr("-", "/")
-                retry
-              end
-            else
-              raise Bundler::GemRequireError.new e,
-                "There was an error while trying to load the gem '#{file}'."
-            end
-          rescue RuntimeError => e
-            raise Bundler::GemRequireError.new e,
-              "There was an error while trying to load the gem '#{file}'."
-          end
-        end
-
-        Plugin.hook(Plugin::Events::GEM_AFTER_REQUIRE, dep)
-      end
-
-      Plugin.hook(Plugin::Events::GEM_AFTER_REQUIRE_ALL, dependencies)
-
-      dependencies
-    end
-
-    def self.definition_method(meth)
-      define_method(meth) do
-        raise ArgumentError, "no definition when calling Runtime##{meth}" unless @definition
-        @definition.send(meth)
-      end
-    end
-    private_class_method :definition_method
-
-    definition_method :requested_specs
-    definition_method :specs
-    definition_method :dependencies
-    definition_method :current_dependencies
-    definition_method :requires
-
-    def lock(opts = {})
-      return if @definition.no_resolve_needed?
-      @definition.lock(opts[:preserve_unknown_sections])
-    end
-
-    alias_method :gems, :specs
-
-    def cache(custom_path = nil, local = false)
-      cache_path = Bundler.app_cache(custom_path)
-      SharedHelpers.filesystem_access(cache_path) do |p|
-        FileUtils.mkdir_p(p)
-      end unless File.exist?(cache_path)
-
-      Bundler.ui.info "Updating files in #{Bundler.settings.app_cache_path}"
-
-      specs_to_cache = if Bundler.settings[:cache_all_platforms]
-        @definition.resolve.materialized_for_all_platforms
-      else
-        begin
-          specs
-        rescue GemNotFound
-          if local
-            Bundler.ui.warn "Some gems seem to be missing from your #{Bundler.settings.app_cache_path} directory."
-          end
-
-          raise
-        end
-      end
-
-      specs_to_cache.each do |spec|
-        next if spec.name == "bundler"
-
-        source = spec.source
-        next if source.is_a?(Source::Gemspec)
-
-        if source.respond_to?(:migrate_cache)
-          source.migrate_cache(custom_path, local: local)
-        elsif source.respond_to?(:cache)
-          source.cache(spec, custom_path)
-        end
-      end
-
-      Dir[cache_path.join("*/.git")].each do |git_dir|
-        FileUtils.rm_rf(git_dir)
-        FileUtils.touch(File.expand_path("../.bundlecache", git_dir))
-      end
-
-      prune_cache(cache_path) unless Bundler.settings[:no_prune]
-    end
-
-    def prune_cache(cache_path)
-      SharedHelpers.filesystem_access(cache_path) do |p|
-        FileUtils.mkdir_p(p)
-      end unless File.exist?(cache_path)
-      resolve = @definition.resolve
-      prune_gem_cache(resolve, cache_path)
-      prune_git_and_path_cache(resolve, cache_path)
-    end
-
-    def clean(dry_run = false)
-      gem_bins             = Dir["#{Gem.dir}/bin/*"]
-      git_dirs             = Dir["#{Gem.dir}/bundler/gems/*"]
-      git_cache_dirs       = Dir["#{Gem.dir}/cache/bundler/git/*"]
-      gem_dirs             = Dir["#{Gem.dir}/gems/*"]
-      gem_files            = Dir["#{Gem.dir}/cache/*.gem"]
-      gemspec_files        = Dir["#{Gem.dir}/specifications/*.gemspec"]
-      extension_dirs       = Dir["#{Gem.dir}/extensions/*/*/*"] + Dir["#{Gem.dir}/bundler/gems/extensions/*/*/*"]
-      spec_gem_paths       = []
-      # need to keep git sources around
-      spec_git_paths       = @definition.spec_git_paths
-      spec_git_cache_dirs  = []
-      spec_gem_executables = []
-      spec_cache_paths     = []
-      spec_gemspec_paths   = []
-      spec_extension_paths = []
-      Bundler.rubygems.add_default_gems_to(specs).values.each do |spec|
-        spec_gem_paths << spec.full_gem_path
-        # need to check here in case gems are nested like for the rails git repo
-        md = %r{(.+bundler/gems/.+-[a-f0-9]{7,12})}.match(spec.full_gem_path)
-        spec_git_paths << md[1] if md
-        spec_gem_executables << spec.executables.collect do |executable|
-          e = "#{Bundler.rubygems.gem_bindir}/#{executable}"
-          [e, "#{e}.bat"]
-        end
-        spec_cache_paths << spec.cache_file
-        spec_gemspec_paths << spec.spec_file
-        spec_extension_paths << spec.extension_dir if spec.respond_to?(:extension_dir)
-        spec_git_cache_dirs << spec.source.cache_path.to_s if spec.source.is_a?(Bundler::Source::Git)
-      end
-      spec_gem_paths.uniq!
-      spec_gem_executables.flatten!
-
-      stale_gem_bins       = gem_bins - spec_gem_executables
-      stale_git_dirs       = git_dirs - spec_git_paths - ["#{Gem.dir}/bundler/gems/extensions"]
-      stale_git_cache_dirs = git_cache_dirs - spec_git_cache_dirs
-      stale_gem_dirs       = gem_dirs - spec_gem_paths
-      stale_gem_files      = gem_files - spec_cache_paths
-      stale_gemspec_files  = gemspec_files - spec_gemspec_paths
-      stale_extension_dirs = extension_dirs - spec_extension_paths
-
-      removed_stale_gem_dirs = stale_gem_dirs.collect {|dir| remove_dir(dir, dry_run) }
-      removed_stale_git_dirs = stale_git_dirs.collect {|dir| remove_dir(dir, dry_run) }
-      output = removed_stale_gem_dirs + removed_stale_git_dirs
-
-      unless dry_run
-        stale_files = stale_gem_bins + stale_gem_files + stale_gemspec_files
-        stale_files.each do |file|
-          SharedHelpers.filesystem_access(File.dirname(file)) do |_p|
-            FileUtils.rm(file) if File.exist?(file)
-          end
-        end
-
-        stale_dirs = stale_git_cache_dirs + stale_extension_dirs
-        stale_dirs.each do |stale_dir|
-          SharedHelpers.filesystem_access(stale_dir) do |dir|
-            FileUtils.rm_rf(dir) if File.exist?(dir)
-          end
-        end
-      end
-
-      output
-    end
-
-    private
-
-    def prune_gem_cache(resolve, cache_path)
-      cached = Dir["#{cache_path}/*.gem"]
-
-      cached = cached.delete_if do |path|
-        spec = Bundler.rubygems.spec_from_gem path
-
-        resolve.any? do |s|
-          s.name == spec.name && s.version == spec.version && !s.source.is_a?(Bundler::Source::Git)
-        end
-      end
-
-      if cached.any?
-        Bundler.ui.info "Removing outdated .gem files from #{Bundler.settings.app_cache_path}"
-
-        cached.each do |path|
-          Bundler.ui.info "  * #{File.basename(path)}"
-          File.delete(path)
-        end
-      end
-    end
-
-    def prune_git_and_path_cache(resolve, cache_path)
-      cached = Dir["#{cache_path}/*/.bundlecache"]
-
-      cached = cached.delete_if do |path|
-        name = File.basename(File.dirname(path))
-
-        resolve.any? do |s|
-          source = s.source
-          source.respond_to?(:app_cache_dirname) && source.app_cache_dirname == name
-        end
-      end
-
-      if cached.any?
-        Bundler.ui.info "Removing outdated git and path gems from #{Bundler.settings.app_cache_path}"
-
-        cached.each do |path|
-          path = File.dirname(path)
-          Bundler.ui.info "  * #{File.basename(path)}"
-          FileUtils.rm_rf(path)
-        end
-      end
-    end
-
-    def setup_manpath
-      # Add man/ subdirectories from activated bundles to MANPATH for man(1)
-      manuals = $LOAD_PATH.filter_map do |path|
-        man_subdir = path.sub(/lib$/, "man")
-        man_subdir unless Dir[man_subdir + "/man?/"].empty?
-      end
-
-      return if manuals.empty?
-      Bundler::SharedHelpers.set_env "MANPATH", manuals.concat(
-        ENV["MANPATH"] ? ENV["MANPATH"].to_s.split(File::PATH_SEPARATOR) : [""]
-      ).uniq.join(File::PATH_SEPARATOR)
-    end
-
-    def remove_dir(dir, dry_run)
-      full_name = Pathname.new(dir).basename.to_s
-
-      parts    = full_name.split("-")
-      name     = parts[0..-2].join("-")
-      version  = parts.last
-      output   = "#{name} (#{version})"
-
-      if dry_run
-        Bundler.ui.info "Would have removed #{output}"
-      else
-        Bundler.ui.info "Removing #{output}"
-        FileUtils.rm_rf(dir)
-      end
-
-      output
-    end
-
-    def check_for_activated_spec!(spec)
-      return unless activated_spec = Bundler.rubygems.loaded_specs(spec.name)
-      return if activated_spec.version == spec.version
-
-      suggestion = if activated_spec.default_gem?
-        "Since #{spec.name} is a default gem, you can either remove your dependency on it" \
-        " or try updating to a newer version of bundler that supports #{spec.name} as a default gem."
-      else
-        "Prepending `bundle exec` to your command may solve this."
-      end
-
-      e = Gem::LoadError.new "You have already activated #{activated_spec.name} #{activated_spec.version}, " \
-                             "but your Gemfile requires #{spec.name} #{spec.version}. #{suggestion}"
-      e.name = spec.name
-      e.requirement = Gem::Requirement.new(spec.version.to_s)
-      raise e
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module SafeMarshal
-    ALLOWED_CLASSES = [
-      Array,
-      FalseClass,
-      Gem::Specification,
-      Gem::Version,
-      Hash,
-      String,
-      Symbol,
-      Time,
-      TrueClass,
-    ].freeze
-
-    ERROR = "Unexpected class %s present in marshaled data. Only %s are allowed."
-
-    PROC = proc do |object|
-      object.tap do
-        unless ALLOWED_CLASSES.include?(object.class)
-          raise TypeError, format(ERROR, object.class, ALLOWED_CLASSES.join(", "))
-        end
-      end
-    end
-
-    def self.proc
-      PROC
-    end
-  end
-end

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

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  #
-  # This class handles installing and switching to the version of bundler needed
-  # by an application.
-  #
-  class SelfManager
-    def restart_with_locked_bundler_if_needed
-      return unless needs_switching? && installed?
-
-      restart_with(restart_version)
-    end
-
-    def install_locked_bundler_and_restart_with_it_if_needed
-      return unless needs_switching?
-
-      if restart_version == lockfile_version
-        Bundler.ui.info \
-          "Bundler #{current_version} is running, but your lockfile was generated with #{lockfile_version}. " \
-          "Installing Bundler #{lockfile_version} and restarting using that version."
-      else
-        Bundler.ui.info \
-          "Bundler #{current_version} is running, but your configuration was #{restart_version}. " \
-          "Installing Bundler #{restart_version} and restarting using that version."
-      end
-
-      install_and_restart_with(restart_version)
-    end
-
-    def update_bundler_and_restart_with_it_if_needed(target)
-      return unless autoswitching_applies?
-
-      spec = resolve_update_version_from(target)
-      return unless spec
-
-      version = spec.version
-
-      Bundler.ui.info "Updating bundler to #{version}."
-
-      install(spec)
-
-      restart_with(version)
-    end
-
-    private
-
-    def install_and_restart_with(version)
-      requirement = Gem::Requirement.new(version)
-      spec = find_latest_matching_spec(requirement)
-
-      if spec.nil?
-        Bundler.ui.warn "Your lockfile is locked to a version of bundler (#{lockfile_version}) that doesn't exist at https://rubygems.org/. Going on using #{current_version}"
-        return
-      end
-
-      install(spec)
-    rescue StandardError => e
-      Bundler.ui.trace e
-      Bundler.ui.warn "There was an error installing the locked bundler version (#{lockfile_version}), rerun with the `--verbose` flag for more details. Going on using bundler #{current_version}."
-    else
-      restart_with(version)
-    end
-
-    def install(spec)
-      spec.source.install(spec)
-    end
-
-    def restart_with(version)
-      configured_gem_home = ENV["GEM_HOME"]
-      configured_gem_path = ENV["GEM_PATH"]
-
-      # Bundler specs need some stuff to be required before Bundler starts
-      # running, for example, for faking the compact index API. However, these
-      # flags are lost when we reexec to a different version of Bundler. In the
-      # future, we may be able to properly reconstruct the original Ruby
-      # invocation (see https://bugs.ruby-lang.org/issues/6648), but for now
-      # there's no way to do it, so we need to be explicit about how to re-exec.
-      # This may be a feature end users request at some point, but maybe by that
-      # time, we have builtin tools to do. So for now, we use an undocumented
-      # ENV variable only for our specs.
-      bundler_spec_original_cmd = ENV["BUNDLER_SPEC_ORIGINAL_CMD"]
-      if bundler_spec_original_cmd
-        require "shellwords"
-        cmd = [*Shellwords.shellsplit(bundler_spec_original_cmd), *ARGV]
-      else
-        argv0 = File.exist?($PROGRAM_NAME) ? $PROGRAM_NAME : Process.argv0
-        cmd = [argv0, *ARGV]
-        cmd.unshift(Gem.ruby) unless File.executable?(argv0)
-      end
-
-      Bundler.with_original_env do
-        Kernel.exec(
-          { "GEM_HOME" => configured_gem_home, "GEM_PATH" => configured_gem_path, "BUNDLER_VERSION" => version.to_s },
-          *cmd
-        )
-      end
-    end
-
-    def needs_switching?
-      autoswitching_applies? &&
-        Bundler.settings[:version] != "system" &&
-        released?(restart_version) &&
-        !running?(restart_version) &&
-        !updating?
-    end
-
-    def autoswitching_applies?
-      ENV["BUNDLER_VERSION"].nil? &&
-        ruby_can_restart_with_same_arguments? &&
-        SharedHelpers.in_bundle? &&
-        lockfile_version
-    end
-
-    def resolve_update_version_from(target)
-      requirement = Gem::Requirement.new(target)
-      update_candidate = find_latest_matching_spec(requirement)
-
-      if update_candidate.nil?
-        raise InvalidOption, "The `bundle update --bundler` target version (#{target}) does not exist"
-      end
-
-      resolved_version = update_candidate.version
-      needs_update = requirement.specific? ? !running?(resolved_version) : running_older_than?(resolved_version)
-
-      return unless needs_update
-
-      update_candidate
-    end
-
-    def local_specs
-      @local_specs ||= Bundler::Source::Rubygems.new("allow_local" => true).specs.select {|spec| spec.name == "bundler" }
-    end
-
-    def remote_specs
-      @remote_specs ||= begin
-        source = Bundler::Source::Rubygems.new("remotes" => "https://rubygems.org")
-        source.remote!
-        source.add_dependency_names("bundler")
-        source.specs.select(&:matches_current_metadata?)
-      end
-    end
-
-    def find_latest_matching_spec(requirement)
-      local_result = find_latest_matching_spec_from_collection(local_specs, requirement)
-      return local_result if local_result && requirement.specific?
-
-      remote_result = find_latest_matching_spec_from_collection(remote_specs, requirement)
-      return remote_result if local_result.nil?
-
-      [local_result, remote_result].max
-    end
-
-    def find_latest_matching_spec_from_collection(specs, requirement)
-      specs.sort.reverse_each.find {|spec| requirement.satisfied_by?(spec.version) }
-    end
-
-    def running?(version)
-      version == current_version
-    end
-
-    def running_older_than?(version)
-      current_version < version
-    end
-
-    def released?(version)
-      !version.to_s.end_with?(".dev")
-    end
-
-    def ruby_can_restart_with_same_arguments?
-      $PROGRAM_NAME != "-e"
-    end
-
-    def updating?
-      "update".start_with?(ARGV.first || " ") && ARGV[1..-1].any? {|a| a.start_with?("--bundler") }
-    end
-
-    def installed?
-      Bundler.configure
-
-      Bundler.rubygems.find_bundler(restart_version.to_s)
-    end
-
-    def current_version
-      @current_version ||= Gem::Version.new(Bundler::VERSION)
-    end
-
-    def lockfile_version
-      return @lockfile_version if defined?(@lockfile_version)
-
-      parsed_version = Bundler::LockfileParser.bundled_with
-      @lockfile_version = parsed_version ? Gem::Version.new(parsed_version) : nil
-    rescue ArgumentError
-      @lockfile_version = nil
-    end
-
-    def restart_version
-      return @restart_version if defined?(@restart_version)
-      # BUNDLE_VERSION=x.y.z
-      @restart_version = Gem::Version.new(Bundler.settings[:version])
-    rescue ArgumentError
-      # BUNDLE_VERSION=lockfile
-      @restart_version = lockfile_version
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/settings/validator.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class Settings
-    class Validator
-      class Rule
-        attr_reader :description
-
-        def initialize(keys, description, &validate)
-          @keys = keys
-          @description = description
-          @validate = validate
-        end
-
-        def validate!(key, value, settings)
-          instance_exec(key, value, settings, &@validate)
-        end
-
-        def fail!(key, value, *reasons)
-          reasons.unshift @description
-          raise InvalidOption, "Setting `#{key}` to #{value.inspect} failed:\n#{reasons.map {|r| " - #{r}" }.join("\n")}"
-        end
-
-        def set(settings, key, value, *reasons)
-          hash_key = k(key)
-          return if settings[hash_key] == value
-          reasons.unshift @description
-          Bundler.ui.info "Setting `#{key}` to #{value.inspect}, since #{reasons.join(", ")}"
-          if value.nil?
-            settings.delete(hash_key)
-          else
-            settings[hash_key] = value
-          end
-        end
-
-        def k(key)
-          Bundler.settings.key_for(key)
-        end
-      end
-
-      def self.rules
-        @rules ||= Hash.new {|h, k| h[k] = [] }
-      end
-      private_class_method :rules
-
-      def self.rule(keys, description, &blk)
-        rule = Rule.new(keys, description, &blk)
-        keys.each {|k| rules[k] << rule }
-      end
-      private_class_method :rule
-
-      def self.validate!(key, value, settings)
-        rules_to_validate = rules[key]
-        rules_to_validate.each {|rule| rule.validate!(key, value, settings) }
-      end
-
-      rule %w[path path.system], "path and path.system are mutually exclusive" do |key, value, settings|
-        if key == "path" && value
-          set(settings, "path.system", nil)
-        elsif key == "path.system" && value
-          set(settings, :path, nil)
-        end
-      end
-
-      rule %w[with without], "a group cannot be in both `with` & `without` simultaneously" do |key, value, settings|
-        with = settings.fetch(k(:with), "").split(":").map(&:to_sym)
-        without = settings.fetch(k(:without), "").split(":").map(&:to_sym)
-
-        other_key = key == "with" ? :without : :with
-        other_setting = key == "with" ? without : with
-
-        conflicting = with & without
-        if conflicting.any?
-          fail!(key, value, "`#{other_key}` is current set to #{other_setting.inspect}", "the `#{conflicting.join("`, `")}` groups conflict")
-        end
-      end
-
-      rule %w[path], "relative paths are expanded relative to the current working directory" do |key, value, settings|
-        next if value.nil?
-
-        path = Pathname.new(value)
-        next if !path.relative? || !Bundler.feature_flag.path_relative_to_cwd?
-
-        path = path.expand_path
-
-        root = begin
-                 Bundler.root
-               rescue GemfileNotFound
-                 Pathname.pwd.expand_path
-               end
-
-        path = begin
-                 path.relative_path_from(root)
-               rescue ArgumentError
-                 path
-               end
-
-        set(settings, key, path.to_s)
-      end
-    end
-  end
-end