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

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module Plugin
-    # Dsl to parse the Gemfile looking for plugins to install
-    class DSL < Bundler::Dsl
-      class PluginGemfileError < PluginError; end
-      alias_method :_gem, :gem # To use for plugin installation as gem
-
-      # So that we don't have to override all there methods to dummy ones
-      # explicitly.
-      # They will be handled by method_missing
-      [:gemspec, :gem, :install_if, :platforms, :env].each {|m| undef_method m }
-
-      # This lists the plugins that was added automatically and not specified by
-      # the user.
-      #
-      # When we encounter :type attribute with a source block, we add a plugin
-      # by name bundler-source-<type> to list of plugins to be installed.
-      #
-      # These plugins are optional and are not installed when there is conflict
-      # with any other plugin.
-      attr_reader :inferred_plugins
-
-      def initialize
-        super
-        @sources = Plugin::SourceList.new
-        @inferred_plugins = [] # The source plugins inferred from :type
-      end
-
-      def plugin(name, *args)
-        _gem(name, *args)
-      end
-
-      def method_missing(name, *args)
-        raise PluginGemfileError, "Undefined local variable or method `#{name}' for Gemfile" unless Bundler::Dsl.method_defined? name
-      end
-
-      def source(source, *args, &blk)
-        options = args.last.is_a?(Hash) ? args.pop.dup : {}
-        options = normalize_hash(options)
-        return super unless options.key?("type")
-
-        plugin_name = "bundler-source-#{options["type"]}"
-
-        return if @dependencies.any? {|d| d.name == plugin_name }
-
-        plugin(plugin_name)
-        @inferred_plugins << plugin_name
-      end
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module Plugin
-    module Events
-      def self.define(const, event)
-        const = const.to_sym.freeze
-        if const_defined?(const) && const_get(const) != event
-          raise ArgumentError, "Attempting to reassign #{const} to a different value"
-        end
-        const_set(const, event) unless const_defined?(const)
-        @events ||= {}
-        @events[event] = const
-      end
-      private_class_method :define
-
-      def self.reset
-        @events.each_value do |const|
-          remove_const(const)
-        end
-        @events = nil
-      end
-      private_class_method :reset
-
-      # Check if an event has been defined
-      # @param event [String] An event to check
-      # @return [Boolean] A boolean indicating if the event has been defined
-      def self.defined_event?(event)
-        @events ||= {}
-        @events.key?(event)
-      end
-
-      # @!parse
-      #   A hook called before each individual gem is installed
-      #   Includes a Bundler::ParallelInstaller::SpecInstallation.
-      #   No state, error, post_install_message will be present as nothing has installed yet
-      #   GEM_BEFORE_INSTALL = "before-install"
-      define :GEM_BEFORE_INSTALL, "before-install"
-
-      # @!parse
-      #   A hook called after each individual gem is installed
-      #   Includes a Bundler::ParallelInstaller::SpecInstallation.
-      #     - If state is failed, an error will be present.
-      #     - If state is success, a post_install_message may be present.
-      #   GEM_AFTER_INSTALL = "after-install"
-      define :GEM_AFTER_INSTALL,  "after-install"
-
-      # @!parse
-      #   A hook called before any gems install
-      #   Includes an Array of Bundler::Dependency objects
-      #   GEM_BEFORE_INSTALL_ALL = "before-install-all"
-      define :GEM_BEFORE_INSTALL_ALL, "before-install-all"
-
-      # @!parse
-      #   A hook called after any gems install
-      #   Includes an Array of Bundler::Dependency objects
-      #   GEM_AFTER_INSTALL_ALL = "after-install-all"
-      define :GEM_AFTER_INSTALL_ALL,  "after-install-all"
-
-      # @!parse
-      #   A hook called before each individual gem is required
-      #   Includes a Bundler::Dependency.
-      #   GEM_BEFORE_REQUIRE = "before-require"
-      define :GEM_BEFORE_REQUIRE, "before-require"
-
-      # @!parse
-      #   A hook called after each individual gem is required
-      #   Includes a Bundler::Dependency.
-      #   GEM_AFTER_REQUIRE = "after-require"
-      define :GEM_AFTER_REQUIRE,  "after-require"
-
-      # @!parse
-      #   A hook called before any gems require
-      #   Includes an Array of Bundler::Dependency objects.
-      #   GEM_BEFORE_REQUIRE_ALL = "before-require-all"
-      define :GEM_BEFORE_REQUIRE_ALL, "before-require-all"
-
-      # @!parse
-      #   A hook called after all gems required
-      #   Includes an Array of Bundler::Dependency objects.
-      #   GEM_AFTER_REQUIRE_ALL = "after-require-all"
-      define :GEM_AFTER_REQUIRE_ALL,  "after-require-all"
-    end
-  end
-end

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

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  # Manages which plugins are installed and their sources. This also is supposed to map
-  # which plugin does what (currently the features are not implemented so this class is
-  # now a stub class).
-  module Plugin
-    class Index
-      class CommandConflict < PluginError
-        def initialize(plugin, commands)
-          msg = "Command(s) `#{commands.join("`, `")}` declared by #{plugin} are already registered."
-          super msg
-        end
-      end
-
-      class SourceConflict < PluginError
-        def initialize(plugin, sources)
-          msg = "Source(s) `#{sources.join("`, `")}` declared by #{plugin} are already registered."
-          super msg
-        end
-      end
-
-      attr_reader :commands
-
-      def initialize
-        @plugin_paths = {}
-        @commands = {}
-        @sources = {}
-        @hooks = {}
-        @load_paths = {}
-
-        begin
-          load_index(global_index_file, true)
-        rescue PermissionError
-          # no need to fail when on a read-only FS, for example
-          nil
-        rescue ArgumentError => e
-          # ruby 3.4 checks writability in Dir.tmpdir
-          raise unless e.message&.include?("could not find a temporary directory")
-          nil
-        end
-        load_index(local_index_file) if SharedHelpers.in_bundle?
-      end
-
-      # This function is to be called when a new plugin is installed. This
-      # function shall add the functions of the plugin to existing maps and also
-      # the name to source location.
-      #
-      # @param [String] name of the plugin to be registered
-      # @param [String] path where the plugin is installed
-      # @param [Array<String>] load_paths for the plugin
-      # @param [Array<String>] commands that are handled by the plugin
-      # @param [Array<String>] sources that are handled by the plugin
-      def register_plugin(name, path, load_paths, commands, sources, hooks)
-        old_commands = @commands.dup
-
-        common = commands & @commands.keys
-        raise CommandConflict.new(name, common) unless common.empty?
-        commands.each {|c| @commands[c] = name }
-
-        common = sources & @sources.keys
-        raise SourceConflict.new(name, common) unless common.empty?
-        sources.each {|k| @sources[k] = name }
-
-        hooks.each do |event|
-          event_hooks = (@hooks[event] ||= []) << name
-          event_hooks.uniq!
-        end
-
-        @plugin_paths[name] = path
-        @load_paths[name] = load_paths
-        save_index
-      rescue StandardError
-        @commands = old_commands
-        raise
-      end
-
-      def unregister_plugin(name)
-        @commands.delete_if {|_, v| v == name }
-        @sources.delete_if {|_, v| v == name }
-        @hooks.each do |hook, names|
-          names.delete(name)
-          @hooks.delete(hook) if names.empty?
-        end
-        @plugin_paths.delete(name)
-        @load_paths.delete(name)
-        save_index
-      end
-
-      # Path of default index file
-      def index_file
-        Plugin.root.join("index")
-      end
-
-      # Path where the global index file is stored
-      def global_index_file
-        Plugin.global_root.join("index")
-      end
-
-      # Path where the local index file is stored
-      def local_index_file
-        Plugin.local_root.join("index")
-      end
-
-      def plugin_path(name)
-        Pathname.new @plugin_paths[name]
-      end
-
-      def load_paths(name)
-        @load_paths[name]
-      end
-
-      # Fetch the name of plugin handling the command
-      def command_plugin(command)
-        @commands[command]
-      end
-
-      def installed?(name)
-        @plugin_paths[name]
-      end
-
-      def installed_plugins
-        @plugin_paths.keys
-      end
-
-      def plugin_commands(plugin)
-        @commands.find_all {|_, n| n == plugin }.map(&:first)
-      end
-
-      def source?(source)
-        @sources.key? source
-      end
-
-      def source_plugin(name)
-        @sources[name]
-      end
-
-      # Returns the list of plugin names handling the passed event
-      def hook_plugins(event)
-        @hooks[event] || []
-      end
-
-      # This plugin is installed inside the .bundle/plugin directory,
-      # and thus is managed solely by Bundler
-      def installed_in_plugin_root?(name)
-        return false unless (path = installed?(name))
-
-        path.start_with?("#{Plugin.root}/")
-      end
-
-      private
-
-      # Reads the index file from the directory and initializes the instance
-      # variables.
-      #
-      # It skips the sources if the second param is true
-      # @param [Pathname] index file path
-      # @param [Boolean] is the index file global index
-      def load_index(index_file, global = false)
-        SharedHelpers.filesystem_access(index_file, :read) do |index_f|
-          valid_file = index_f&.exist? && !index_f.size.zero?
-          break unless valid_file
-
-          data = index_f.read
-
-          require_relative "../yaml_serializer"
-          index = YAMLSerializer.load(data)
-
-          @commands.merge!(index["commands"])
-          @hooks.merge!(index["hooks"])
-          @load_paths.merge!(index["load_paths"])
-          @plugin_paths.merge!(index["plugin_paths"])
-          @sources.merge!(index["sources"]) unless global
-        end
-      end
-
-      # Should be called when any of the instance variables change. Stores the
-      # instance variables in YAML format. (The instance variables are supposed
-      # to be only String key value pairs)
-      def save_index
-        index = {
-          "commands" => @commands,
-          "hooks" => @hooks,
-          "load_paths" => @load_paths,
-          "plugin_paths" => @plugin_paths,
-          "sources" => @sources,
-        }
-
-        require_relative "../yaml_serializer"
-        SharedHelpers.filesystem_access(index_file) do |index_f|
-          FileUtils.mkdir_p(index_f.dirname)
-          File.open(index_f, "w") {|f| f.puts YAMLSerializer.dump(index) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module Plugin
-    class Installer
-      class Git < Bundler::Source::Git
-        def cache_path
-          @cache_path ||= begin
-            git_scope = "#{base_name}-#{uri_hash}"
-
-            Plugin.cache.join("bundler", "git", git_scope)
-          end
-        end
-
-        def install_path
-          @install_path ||= begin
-            git_scope = "#{base_name}-#{shortref_for_path(revision)}"
-
-            Plugin.root.join("bundler", "gems", git_scope)
-          end
-        end
-
-        def root
-          Plugin.root
-        end
-
-        def generate_bin(spec, disable_extensions = false)
-          # Need to find a way without code duplication
-          # For now, we can ignore this
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module Plugin
-    class Installer
-      class Path < Bundler::Source::Path
-        def root
-          SharedHelpers.in_bundle? ? Bundler.root : Plugin.root
-        end
-
-        def eql?(other)
-          return unless other.class == self.class
-          expanded_original_path == other.expanded_original_path &&
-            version == other.version
-        end
-
-        alias_method :==, :eql?
-
-        def generate_bin(spec, disable_extensions = false)
-          # Need to find a way without code duplication
-          # For now, we can ignore this
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module Plugin
-    class Installer
-      class Rubygems < Bundler::Source::Rubygems
-        private
-
-        def rubygems_dir
-          Plugin.root
-        end
-
-        def cache_path
-          Plugin.cache
-        end
-      end
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  # Handles the installation of plugin in appropriate directories.
-  #
-  # This class is supposed to be wrapper over the existing gem installation infra
-  # but currently it itself handles everything as the Source's subclasses (e.g. Source::RubyGems)
-  # are heavily dependent on the Gemfile.
-  module Plugin
-    class Installer
-      autoload :Rubygems, File.expand_path("installer/rubygems", __dir__)
-      autoload :Git,      File.expand_path("installer/git", __dir__)
-      autoload :Path, File.expand_path("installer/path", __dir__)
-
-      def install(names, options)
-        check_sources_consistency!(options)
-
-        version = options[:version] || [">= 0"]
-
-        if options[:git]
-          install_git(names, version, options)
-        elsif options[:path]
-          install_path(names, version, options[:path])
-        else
-          sources = options[:source] || Gem.sources
-          install_rubygems(names, version, sources)
-        end
-      end
-
-      # Installs the plugin from Definition object created by limited parsing of
-      # Gemfile searching for plugins to be installed
-      #
-      # @param [Definition] definition object
-      # @return [Hash] map of names to their specs they are installed with
-      def install_definition(definition)
-        def definition.lock(*); end
-        definition.remotely!
-        specs = definition.specs
-
-        install_from_specs specs
-      end
-
-      private
-
-      def check_sources_consistency!(options)
-        if options.key?(:git) && options.key?(:local_git)
-          raise InvalidOption, "Remote and local plugin git sources can't be both specified"
-        end
-
-        # back-compat; local_git is an alias for git
-        if options.key?(:local_git)
-          Bundler::SharedHelpers.major_deprecation(2, "--local_git is deprecated, use --git")
-          options[:git] = options.delete(:local_git)
-        end
-
-        if (options.keys & [:source, :git, :path]).length > 1
-          raise InvalidOption, "Only one of --source, --git, or --path may be specified"
-        end
-
-        if (options.key?(:branch) || options.key?(:ref)) && !options.key?(:git)
-          raise InvalidOption, "--#{options.key?(:branch) ? "branch" : "ref"} can only be used with git sources"
-        end
-
-        if options.key?(:branch) && options.key?(:ref)
-          raise InvalidOption, "--branch and --ref can't be both specified"
-        end
-      end
-
-      def install_git(names, version, options)
-        source_list = SourceList.new
-        source = source_list.add_git_source({ "uri" => options[:git],
-                                              "branch" => options[:branch],
-                                              "ref" => options[:ref] })
-
-        install_all_sources(names, version, source_list, source)
-      end
-
-      def install_path(names, version, path)
-        source_list = SourceList.new
-        source = source_list.add_path_source({ "path" => path, "root_path" => SharedHelpers.pwd })
-
-        install_all_sources(names, version, source_list, source)
-      end
-
-      # Installs the plugin from rubygems source and returns the path where the
-      # plugin was installed
-      #
-      # @param [String] name of the plugin gem to search in the source
-      # @param [Array] version of the gem to install
-      # @param [String, Array<String>] source(s) to resolve the gem
-      #
-      # @return [Hash] map of names to the specs of plugins installed
-      def install_rubygems(names, version, sources)
-        source_list = SourceList.new
-
-        Array(sources).each {|remote| source_list.add_global_rubygems_remote(remote) }
-
-        install_all_sources(names, version, source_list)
-      end
-
-      def install_all_sources(names, version, source_list, source = nil)
-        deps = names.map {|name| Dependency.new(name, version, { "source" => source }) }
-
-        Bundler.configure_gem_home_and_path(Plugin.root)
-
-        Bundler.settings.temporary(deployment: false, frozen: false) do
-          definition = Definition.new(nil, deps, source_list, true)
-
-          install_definition(definition)
-        end
-      end
-
-      # Installs the plugins and deps from the provided specs and returns map of
-      # gems to their paths
-      #
-      # @param specs to install
-      #
-      # @return [Hash] map of names to the specs
-      def install_from_specs(specs)
-        paths = {}
-
-        specs.each do |spec|
-          spec.source.install spec
-
-          paths[spec.name] = spec
-        end
-
-        paths
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  # SourceList object to be used while parsing the Gemfile, setting the
-  # approptiate options to be used with Source classes for plugin installation
-  module Plugin
-    class SourceList < Bundler::SourceList
-      def add_git_source(options = {})
-        add_source_to_list Plugin::Installer::Git.new(options), git_sources
-      end
-
-      def add_path_source(options = {})
-        add_source_to_list Plugin::Installer::Path.new(options), path_sources
-      end
-
-      def add_rubygems_source(options = {})
-        add_source_to_list Plugin::Installer::Rubygems.new(options), @rubygems_sources
-      end
-
-      def all_sources
-        path_sources + git_sources + rubygems_sources + [metadata_source]
-      end
-
-      private
-
-      def rubygems_aggregate_class
-        Plugin::Installer::Rubygems
-      end
-    end
-  end
-end