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

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

@@ -1,378 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "plugin/api"
-
-module Bundler
-  module Plugin
-    autoload :DSL,        File.expand_path("plugin/dsl", __dir__)
-    autoload :Events,     File.expand_path("plugin/events", __dir__)
-    autoload :Index,      File.expand_path("plugin/index", __dir__)
-    autoload :Installer,  File.expand_path("plugin/installer", __dir__)
-    autoload :SourceList, File.expand_path("plugin/source_list", __dir__)
-
-    class MalformattedPlugin < PluginError; end
-    class UndefinedCommandError < PluginError; end
-    class UnknownSourceError < PluginError; end
-    class PluginInstallError < PluginError; end
-
-    PLUGIN_FILE_NAME = "plugins.rb"
-
-    module_function
-
-    def reset!
-      instance_variables.each {|i| remove_instance_variable(i) }
-
-      @sources = {}
-      @commands = {}
-      @hooks_by_event = Hash.new {|h, k| h[k] = [] }
-      @loaded_plugin_names = []
-    end
-
-    reset!
-
-    # Installs a new plugin by the given name
-    #
-    # @param [Array<String>] names the name of plugin to be installed
-    # @param [Hash] options various parameters as described in description.
-    #               Refer to cli/plugin for available options
-    def install(names, options)
-      raise InvalidOption, "You cannot specify `--branch` and `--ref` at the same time." if options["branch"] && options["ref"]
-
-      specs = Installer.new.install(names, options)
-
-      save_plugins names, specs
-    rescue PluginError
-      specs_to_delete = specs.select {|k, _v| names.include?(k) && !index.commands.values.include?(k) }
-      specs_to_delete.each_value {|spec| Bundler.rm_rf(spec.full_gem_path) }
-
-      raise
-    end
-
-    # Uninstalls plugins by the given names
-    #
-    # @param [Array<String>] names the names of plugins to be uninstalled
-    def uninstall(names, options)
-      if names.empty? && !options[:all]
-        Bundler.ui.error "No plugins to uninstall. Specify at least 1 plugin to uninstall.\n"\
-          "Use --all option to uninstall all the installed plugins."
-        return
-      end
-
-      names = index.installed_plugins if options[:all]
-      if names.any?
-        names.each do |name|
-          if index.installed?(name)
-            path = index.plugin_path(name).to_s
-            Bundler.rm_rf(path) if index.installed_in_plugin_root?(name)
-            index.unregister_plugin(name)
-            Bundler.ui.info "Uninstalled plugin #{name}"
-          else
-            Bundler.ui.error "Plugin #{name} is not installed \n"
-          end
-        end
-      else
-        Bundler.ui.info "No plugins installed"
-      end
-    end
-
-    # List installed plugins and commands
-    #
-    def list
-      installed_plugins = index.installed_plugins
-      if installed_plugins.any?
-        output = String.new
-        installed_plugins.each do |plugin|
-          output << "#{plugin}\n"
-          output << "-----\n"
-          index.plugin_commands(plugin).each do |command|
-            output << "  #{command}\n"
-          end
-          output << "\n"
-        end
-      else
-        output = "No plugins installed"
-      end
-      Bundler.ui.info output
-    end
-
-    # Evaluates the Gemfile with a limited DSL and installs the plugins
-    # specified by plugin method
-    #
-    # @param [Pathname] gemfile path
-    # @param [Proc] block that can be evaluated for (inline) Gemfile
-    def gemfile_install(gemfile = nil, &inline)
-      Bundler.settings.temporary(frozen: false, deployment: false) do
-        builder = DSL.new
-        if block_given?
-          builder.instance_eval(&inline)
-        else
-          builder.eval_gemfile(gemfile)
-        end
-        builder.check_primary_source_safety
-        definition = builder.to_definition(nil, true)
-
-        return if definition.dependencies.empty?
-
-        plugins = definition.dependencies.map(&:name).reject {|p| index.installed? p }
-        installed_specs = Installer.new.install_definition(definition)
-
-        save_plugins plugins, installed_specs, builder.inferred_plugins
-      end
-    rescue RuntimeError => e
-      unless e.is_a?(GemfileError)
-        Bundler.ui.error "Failed to install plugin: #{e.message}\n  #{e.backtrace[0]}"
-      end
-      raise
-    end
-
-    # The index object used to store the details about the plugin
-    def index
-      @index ||= Index.new
-    end
-
-    # The directory root for all plugin related data
-    #
-    # If run in an app, points to local root, in app_config_path
-    # Otherwise, points to global root, in Bundler.user_bundle_path("plugin")
-    def root
-      @root ||= if SharedHelpers.in_bundle?
-        local_root
-      else
-        global_root
-      end
-    end
-
-    def local_root
-      Bundler.app_config_path.join("plugin")
-    end
-
-    # The global directory root for all plugin related data
-    def global_root
-      Bundler.user_bundle_path("plugin")
-    end
-
-    # The cache directory for plugin stuffs
-    def cache
-      @cache ||= root.join("cache")
-    end
-
-    # To be called via the API to register to handle a command
-    def add_command(command, cls)
-      @commands[command] = cls
-    end
-
-    # Checks if any plugin handles the command
-    def command?(command)
-      !index.command_plugin(command).nil?
-    end
-
-    # To be called from Cli class to pass the command and argument to
-    # appropriate plugin class
-    def exec_command(command, args)
-      raise UndefinedCommandError, "Command `#{command}` not found" unless command? command
-
-      load_plugin index.command_plugin(command) unless @commands.key? command
-
-      @commands[command].new.exec(command, args)
-    end
-
-    # To be called via the API to register to handle a source plugin
-    def add_source(source, cls)
-      @sources[source] = cls
-    end
-
-    # Checks if any plugin declares the source
-    def source?(name)
-      !index.source_plugin(name.to_s).nil?
-    end
-
-    # @return [Class] that handles the source. The class includes API::Source
-    def source(name)
-      raise UnknownSourceError, "Source #{name} not found" unless source? name
-
-      load_plugin(index.source_plugin(name)) unless @sources.key? name
-
-      @sources[name]
-    end
-
-    # @param [Hash] The options that are present in the lockfile
-    # @return [API::Source] the instance of the class that handles the source
-    #                       type passed in locked_opts
-    def from_lock(locked_opts)
-      src = source(locked_opts["type"])
-
-      src.new(locked_opts.merge("uri" => locked_opts["remote"]))
-    end
-
-    # To be called via the API to register a hooks and corresponding block that
-    # will be called to handle the hook
-    def add_hook(event, &block)
-      unless Events.defined_event?(event)
-        raise ArgumentError, "Event '#{event}' not defined in Bundler::Plugin::Events"
-      end
-      @hooks_by_event[event.to_s] << block
-    end
-
-    # Runs all the hooks that are registered for the passed event
-    #
-    # It passes the passed arguments and block to the block registered with
-    # the api.
-    #
-    # @param [String] event
-    def hook(event, *args, &arg_blk)
-      return unless Bundler.feature_flag.plugins?
-      unless Events.defined_event?(event)
-        raise ArgumentError, "Event '#{event}' not defined in Bundler::Plugin::Events"
-      end
-
-      plugins = index.hook_plugins(event)
-      return unless plugins.any?
-
-      plugins.each {|name| load_plugin(name) }
-
-      @hooks_by_event[event].each {|blk| blk.call(*args, &arg_blk) }
-    end
-
-    # currently only intended for specs
-    #
-    # @return [String, nil] installed path
-    def installed?(plugin)
-      Index.new.installed?(plugin)
-    end
-
-    # @return [true, false] whether the plugin is loaded
-    def loaded?(plugin)
-      @loaded_plugin_names.include?(plugin)
-    end
-
-    # Post installation processing and registering with index
-    #
-    # @param [Array<String>] plugins list to be installed
-    # @param [Hash] specs of plugins mapped to installation path (currently they
-    #               contain all the installed specs, including plugins)
-    # @param [Array<String>] names of inferred source plugins that can be ignored
-    def save_plugins(plugins, specs, optional_plugins = [])
-      plugins.each do |name|
-        next if index.installed?(name)
-
-        spec = specs[name]
-
-        save_plugin(name, spec, optional_plugins.include?(name))
-      end
-    end
-
-    # Checks if the gem is good to be a plugin
-    #
-    # At present it only checks whether it contains plugins.rb file
-    #
-    # @param [Pathname] plugin_path the path plugin is installed at
-    # @raise [MalformattedPlugin] if plugins.rb file is not found
-    def validate_plugin!(plugin_path)
-      plugin_file = plugin_path.join(PLUGIN_FILE_NAME)
-      raise MalformattedPlugin, "#{PLUGIN_FILE_NAME} was not found in the plugin." unless plugin_file.file?
-    end
-
-    # Validates and registers a plugin.
-    #
-    # @param [String] name the name of the plugin
-    # @param [Specification] spec of installed plugin
-    # @param [Boolean] optional_plugin, removed if there is conflict with any
-    #                     other plugin (used for default source plugins)
-    #
-    # @raise [PluginInstallError] if validation or registration raises any error
-    def save_plugin(name, spec, optional_plugin = false)
-      validate_plugin! Pathname.new(spec.full_gem_path)
-      installed = register_plugin(name, spec, optional_plugin)
-      Bundler.ui.info "Installed plugin #{name}" if installed
-    rescue PluginError => e
-      raise PluginInstallError, "Failed to install plugin `#{spec.name}`, due to #{e.class} (#{e.message})"
-    end
-
-    # Runs the plugins.rb file in an isolated namespace, records the plugin
-    # actions it registers for and then passes the data to index to be stored.
-    #
-    # @param [String] name the name of the plugin
-    # @param [Specification] spec of installed plugin
-    # @param [Boolean] optional_plugin, removed if there is conflict with any
-    #                     other plugin (used for default source plugins)
-    #
-    # @raise [MalformattedPlugin] if plugins.rb raises any error
-    def register_plugin(name, spec, optional_plugin = false)
-      commands = @commands
-      sources = @sources
-      hooks = @hooks_by_event
-
-      @commands = {}
-      @sources = {}
-      @hooks_by_event = Hash.new {|h, k| h[k] = [] }
-
-      load_paths = spec.load_paths
-      Gem.add_to_load_path(*load_paths)
-      path = Pathname.new spec.full_gem_path
-
-      begin
-        load path.join(PLUGIN_FILE_NAME), true
-      rescue StandardError => e
-        raise MalformattedPlugin, "#{e.class}: #{e.message}"
-      end
-
-      if optional_plugin && @sources.keys.any? {|s| source? s }
-        Bundler.rm_rf(path)
-        false
-      else
-        index.register_plugin(name, path.to_s, load_paths, @commands.keys,
-          @sources.keys, @hooks_by_event.keys)
-        true
-      end
-    ensure
-      @commands = commands
-      @sources = sources
-      @hooks_by_event = hooks
-    end
-
-    # Executes the plugins.rb file
-    #
-    # @param [String] name of the plugin
-    def load_plugin(name)
-      return unless name && !name.empty?
-      return if loaded?(name)
-
-      # Need to ensure before this that plugin root where the rest of gems
-      # are installed to be on load path to support plugin deps. Currently not
-      # done to avoid conflicts
-      path = index.plugin_path(name)
-
-      paths = index.load_paths(name)
-      invalid_paths = paths.reject {|p| File.directory?(p) }
-
-      if invalid_paths.any?
-        Bundler.ui.warn <<~MESSAGE
-          The following plugin paths don't exist: #{invalid_paths.join(", ")}.
-
-          This can happen if the plugin was installed with a different version of Ruby that has since been uninstalled.
-
-          If you would like to reinstall the plugin, run:
-
-          bundler plugin uninstall #{name} && bundler plugin install #{name}
-
-          Continuing without installing plugin #{name}.
-        MESSAGE
-
-        return
-      end
-
-      Gem.add_to_load_path(*paths)
-
-      load path.join(PLUGIN_FILE_NAME)
-
-      @loaded_plugin_names << name
-    rescue RuntimeError => e
-      Bundler.ui.error "Failed loading plugin #{name}: #{e.message}"
-      raise
-    end
-
-    class << self
-      private :load_plugin, :register_plugin, :save_plugins, :validate_plugin!
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  class ProcessLock
-    def self.lock(bundle_path = Bundler.bundle_path, &block)
-      lock_file_path = File.join(bundle_path, "bundler.lock")
-      base_lock_file_path = lock_file_path.delete_suffix(".lock")
-
-      require "fileutils" if Bundler.rubygems.provides?("< 3.6.0")
-
-      begin
-        SharedHelpers.filesystem_access(lock_file_path, :write) do
-          Gem.open_file_with_lock(base_lock_file_path, &block)
-        end
-      rescue PermissionError
-        block.call
-      end
-    end
-  end
-end

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

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  # Represents a lazily loaded gem specification, where the full specification
-  # is on the source server in rubygems' "quick" index. The proxy object is to
-  # be seeded with what we're given from the source's abbreviated index - the
-  # full specification will only be fetched when necessary.
-  class RemoteSpecification
-    include MatchRemoteMetadata
-    include MatchPlatform
-    include Comparable
-
-    attr_reader :name, :version, :platform
-    attr_writer :dependencies
-    attr_accessor :source, :remote, :locked_platform
-
-    def initialize(name, version, platform, spec_fetcher)
-      @name         = name
-      @version      = Gem::Version.create version
-      @original_platform = platform || Gem::Platform::RUBY
-      @platform     = Gem::Platform.new(platform)
-      @spec_fetcher = spec_fetcher
-      @dependencies = nil
-      @locked_platform = nil
-    end
-
-    def insecurely_materialized?
-      @locked_platform.to_s != @platform.to_s
-    end
-
-    # Needed before installs, since the arch matters then and quick
-    # specs don't bother to include the arch in the platform string
-    def fetch_platform
-      @platform = _remote_specification.platform
-    end
-
-    def full_name
-      @full_name ||= if @platform == Gem::Platform::RUBY
-        "#{@name}-#{@version}"
-      else
-        "#{@name}-#{@version}-#{@platform}"
-      end
-    end
-
-    # Compare this specification against another object. Using sort_obj
-    # is compatible with Gem::Specification and other Bundler or RubyGems
-    # objects. Otherwise, use the default Object comparison.
-    def <=>(other)
-      if other.respond_to?(:sort_obj)
-        sort_obj <=> other.sort_obj
-      else
-        super
-      end
-    end
-
-    # Because Rubyforge cannot be trusted to provide valid specifications
-    # once the remote gem is downloaded, the backend specification will
-    # be swapped out.
-    def __swap__(spec)
-      raise APIResponseInvalidDependenciesError unless spec.dependencies.all? {|d| d.is_a?(Gem::Dependency) }
-
-      SharedHelpers.ensure_same_dependencies(self, dependencies, spec.dependencies)
-      @_remote_specification = spec
-    end
-
-    # Create a delegate used for sorting. This strategy is copied from
-    # RubyGems 2.23 and ensures that Bundler's specifications can be
-    # compared and sorted with RubyGems' own specifications.
-    #
-    # @see #<=>
-    # @see Gem::Specification#sort_obj
-    #
-    # @return [Array] an object you can use to compare and sort this
-    #   specification against other specifications
-    def sort_obj
-      [@name, @version, @platform == Gem::Platform::RUBY ? -1 : 1]
-    end
-
-    def to_s
-      "#<#{self.class} name=#{name} version=#{version} platform=#{platform}>"
-    end
-
-    def dependencies
-      @dependencies ||= begin
-        deps = method_missing(:dependencies)
-
-        # allow us to handle when the specs dependencies are an array of array of string
-        # in order to delay the crash to `#__swap__` where it results in a friendlier error
-        # see https://github.com/rubygems/bundler/issues/5797
-        deps = deps.map {|d| d.is_a?(Gem::Dependency) ? d : Gem::Dependency.new(*d) }
-
-        deps
-      end
-    end
-
-    def runtime_dependencies
-      dependencies.select(&:runtime?)
-    end
-
-    def git_version
-      return unless loaded_from && source.is_a?(Bundler::Source::Git)
-      " #{source.revision[0..6]}"
-    end
-
-    private
-
-    def to_ary
-      nil
-    end
-
-    def _remote_specification
-      @_remote_specification ||= @spec_fetcher.fetch_spec([@name, @version, @original_platform])
-      @_remote_specification || raise(GemspecError, "Gemspec data for #{full_name} was" \
-        " missing from the server!")
-    end
-
-    def method_missing(method, *args, &blk)
-      _remote_specification.send(method, *args, &blk)
-    end
-
-    def respond_to?(method, include_all = false)
-      super || _remote_specification.respond_to?(method, include_all)
-    end
-    public :respond_to?
-  end
-end

package/lib/ruby/3.4.11/bundler/resolver/base.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "package"
-
-module Bundler
-  class Resolver
-    class Base
-      attr_reader :packages, :requirements, :source_requirements, :locked_specs
-
-      def initialize(source_requirements, dependencies, base, platforms, options)
-        @source_requirements = source_requirements
-        @locked_specs = options[:locked_specs]
-
-        @base = base
-
-        @packages = Hash.new do |hash, name|
-          hash[name] = Package.new(name, platforms, **options)
-        end
-
-        @requirements = dependencies.filter_map do |dep|
-          dep_platforms = dep.gem_platforms(platforms)
-
-          # Dependencies scoped to external platforms are ignored
-          next if dep_platforms.empty?
-
-          name = dep.name
-
-          @packages[name] = Package.new(name, dep_platforms, **options.merge(dependency: dep))
-
-          dep
-        end
-      end
-
-      def [](name)
-        @base[name]
-      end
-
-      def delete(specs)
-        @base.delete(specs)
-      end
-
-      def get_package(name)
-        @packages[name]
-      end
-
-      def base_requirements
-        @base_requirements ||= build_base_requirements
-      end
-
-      def unlock_names(names)
-        indirect_pins = indirect_pins(names)
-
-        if indirect_pins.any?
-          loosen_names(indirect_pins)
-        else
-          pins = pins(names)
-
-          if pins.any?
-            loosen_names(pins)
-          else
-            unrestrict_names(names)
-          end
-        end
-      end
-
-      def include_prereleases(names)
-        names.each do |name|
-          get_package(name).consider_prereleases!
-        end
-      end
-
-      def include_remote_specs(names)
-        names.each do |name|
-          get_package(name).consider_remote_versions!
-        end
-      end
-
-      private
-
-      def indirect_pins(names)
-        names.select {|name| @base_requirements[name].exact? && @requirements.none? {|dep| dep.name == name } }
-      end
-
-      def pins(names)
-        names.select {|name| @base_requirements[name].exact? }
-      end
-
-      def loosen_names(names)
-        names.each do |name|
-          version = @base_requirements[name].requirements.first[1]
-
-          @base_requirements[name] = Gem::Requirement.new(">= #{version}")
-
-          @base.delete_by_name(name)
-        end
-      end
-
-      def unrestrict_names(names)
-        names.each do |name|
-          @base_requirements.delete(name)
-        end
-      end
-
-      def build_base_requirements
-        base_requirements = {}
-        @base.each do |ls|
-          if ls.source_changed? && ls.source.specs.search(ls.name).empty?
-            raise GemNotFound, "Could not find gem '#{ls.name}' in #{ls.source}"
-          end
-
-          req = Gem::Requirement.new(ls.version)
-          base_requirements[ls.name] = req
-        end
-        base_requirements
-      end
-    end
-  end
-end