rubygems-update 2.6.0 → 3.5.4

data/bundler/lib/bundler/plugin.rb

@@ -0,0 +1,359 @@
+# 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 lock file
+    # @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)
+
+      Gem.add_to_load_path(*index.load_paths(name))
+
+      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

data/bundler/lib/bundler/process_lock.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Bundler
+  class ProcessLock
+    def self.lock(bundle_path = Bundler.bundle_path)
+      lock_file_path = File.join(bundle_path, "bundler.lock")
+      has_lock = false
+
+      File.open(lock_file_path, "w") do |f|
+        f.flock(File::LOCK_EX)
+        has_lock = true
+        yield
+        f.flock(File::LOCK_UN)
+      end
+    rescue Errno::EACCES, Errno::ENOLCK, Errno::ENOTSUP, Errno::EPERM, Errno::EROFS
+      # In the case the user does not have access to
+      # create the lock file or is using NFS where
+      # locks are not available we skip locking.
+      yield
+    ensure
+      FileUtils.rm_f(lock_file_path) if has_lock
+    end
+  end
+end

data/bundler/lib/bundler/remote_specification.rb

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

data/bundler/lib/bundler/resolver/base.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "package"
+
+module Bundler
+  class Resolver
+    class Base
+      attr_reader :packages, :requirements, :source_requirements
+
+      def initialize(source_requirements, dependencies, base, platforms, options)
+        @source_requirements = source_requirements
+
+        @base = base
+
+        @packages = Hash.new do |hash, name|
+          hash[name] = Package.new(name, platforms, **options)
+        end
+
+        @requirements = dependencies.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.compact
+      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
+
+      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|
+          req = Gem::Requirement.new(ls.version)
+          base_requirements[ls.name] = req
+        end
+        base_requirements
+      end
+    end
+  end
+end

data/bundler/lib/bundler/resolver/candidate.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative "spec_group"
+
+module Bundler
+  class Resolver
+    #
+    # This class is a PubGrub compatible "Version" class that takes Bundler
+    # resolution complexities into account.
+    #
+    # Each Resolver::Candidate has a underlying `Gem::Version` plus a set of
+    # platforms. For example, 1.1.0-x86_64-linux is a different resolution candidate
+    # from 1.1.0 (generic). This is because different platform variants of the
+    # same gem version can bring different dependencies, so they need to be
+    # considered separately.
+    #
+    # Some candidates may also keep some information explicitly about the
+    # package the refer to. These candidates are referred to as "canonical" and
+    # are used when materializing resolution results back into RubyGems
+    # specifications that can be installed, written to lock files, and so on.
+    #
+    class Candidate
+      include Comparable
+
+      attr_reader :version
+
+      def initialize(version, specs: [])
+        @spec_group = Resolver::SpecGroup.new(specs)
+        @version = Gem::Version.new(version)
+        @ruby_only = specs.map(&:platform).uniq == [Gem::Platform::RUBY]
+      end
+
+      def dependencies
+        @spec_group.dependencies
+      end
+
+      def to_specs(package)
+        return [] if package.meta?
+
+        @spec_group.to_specs(package.force_ruby_platform?)
+      end
+
+      def generic!
+        @ruby_only = true
+
+        self
+      end
+
+      def platform_specific!
+        @ruby_only = false
+
+        self
+      end
+
+      def prerelease?
+        @version.prerelease?
+      end
+
+      def segments
+        @version.segments
+      end
+
+      def sort_obj
+        [@version, @ruby_only ? -1 : 1]
+      end
+
+      def <=>(other)
+        return unless other.is_a?(self.class)
+
+        sort_obj <=> other.sort_obj
+      end
+
+      def ==(other)
+        return unless other.is_a?(self.class)
+
+        sort_obj == other.sort_obj
+      end
+
+      def eql?(other)
+        return unless other.is_a?(self.class)
+
+        sort_obj.eql?(other.sort_obj)
+      end
+
+      def hash
+        sort_obj.hash
+      end
+
+      def to_s
+        @version.to_s
+      end
+    end
+  end
+end