rubygems-update 2.6.0 → 3.4.22

data/bundler/lib/bundler/plugin/events.rb

@@ -0,0 +1,61 @@
+# 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"
+    end
+  end
+end

data/bundler/lib/bundler/plugin/index.rb

@@ -0,0 +1,193 @@
+# 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 GenericSystemCallError
+          # no need to fail when on a read-only FS, for example
+          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

data/bundler/lib/bundler/plugin/installer/git.rb

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

data/bundler/lib/bundler/plugin/installer/rubygems.rb

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

data/bundler/lib/bundler/plugin/installer.rb

@@ -0,0 +1,112 @@
+# 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__)
+
+      def install(names, options)
+        check_sources_consistency!(options)
+
+        version = options[:version] || [">= 0"]
+
+        if options[:git]
+          install_git(names, version, options)
+        elsif options[:local_git]
+          install_local_git(names, version, options)
+        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.resolve_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
+      end
+
+      def install_git(names, version, options)
+        uri = options.delete(:git)
+        options["uri"] = uri
+
+        install_all_sources(names, version, options, options[:source])
+      end
+
+      def install_local_git(names, version, options)
+        uri = options.delete(:local_git)
+        options["uri"] = uri
+
+        install_all_sources(names, version, options, options[: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)
+        install_all_sources(names, version, nil, sources)
+      end
+
+      def install_all_sources(names, version, git_source_options, rubygems_source)
+        source_list = SourceList.new
+
+        source_list.add_git_source(git_source_options) if git_source_options
+        Array(rubygems_source).each {|remote| source_list.add_global_rubygems_remote(remote) } if rubygems_source
+
+        deps = names.map {|name| Dependency.new name, version }
+
+        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

data/bundler/lib/bundler/plugin/source_list.rb

@@ -0,0 +1,31 @@
+# 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_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
+
+      def default_source
+        git_sources.first || global_rubygems_source
+      end
+
+      private
+
+      def rubygems_aggregate_class
+        Plugin::Installer::Rubygems
+      end
+    end
+  end
+end