bundler 1.15.2 → 2.4.12

data/lib/bundler/plugin.rb

@@ -1,20 +1,23 @@
 # frozen_string_literal: true
-require "bundler/plugin/api"
+
+require_relative "plugin/api"
 
 module Bundler
   module Plugin
-    autoload :DSL,        "bundler/plugin/dsl"
-    autoload :Index,      "bundler/plugin/index"
-    autoload :Installer,  "bundler/plugin/installer"
-    autoload :SourceList, "bundler/plugin/source_list"
+    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".freeze
+    PLUGIN_FILE_NAME = "plugins.rb"
 
-  module_function
+    module_function
 
     def reset!
       instance_variables.each {|i| remove_instance_variable(i) }
@@ -33,16 +36,62 @@ module Bundler
     # @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 => e
-      if specs
-        specs_to_delete = Hash[specs.select {|k, _v| names.include?(k) && !index.commands.values.include?(k) }]
-        specs_to_delete.values.each {|spec| Bundler.rm_rf(spec.full_gem_path) }
+    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
 
-      Bundler.ui.error "Failed to install plugin #{name}: #{e.message}\n  #{e.backtrace.join("\n ")}"
+      names = index.installed_plugins if options[:all]
+      if names.any?
+        names.each do |name|
+          if index.installed?(name)
+            Bundler.rm_rf(index.plugin_path(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
@@ -51,21 +100,24 @@ module Bundler
     # @param [Pathname] gemfile path
     # @param [Proc] block that can be evaluated for (inline) Gemfile
     def gemfile_install(gemfile = nil, &inline)
-      builder = DSL.new
-      if block_given?
-        builder.instance_eval(&inline)
-      else
-        builder.eval_gemfile(gemfile)
+      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
-      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
-    rescue => e
+    rescue RuntimeError => e
       unless e.is_a?(GemfileError)
         Bundler.ui.error "Failed to install plugin: #{e.message}\n  #{e.backtrace[0]}"
       end
@@ -79,8 +131,8 @@ module Bundler
 
     # The directory root for all plugin related data
     #
-    # Points to root in app_config_path if ran in an app else points to the one
-    # in user_bundle_path
+    # 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
@@ -95,7 +147,7 @@ module Bundler
 
     # The global directory root for all plugin related data
     def global_root
-      Bundler.user_bundle_path.join("plugin")
+      Bundler.user_bundle_path("plugin")
     end
 
     # The cache directory for plugin stuffs
@@ -114,7 +166,7 @@ module Bundler
     end
 
     # To be called from Cli class to pass the command and argument to
-    # approriate plugin class
+    # appropriate plugin class
     def exec_command(command, args)
       raise UndefinedCommandError, "Command `#{command}` not found" unless command? command
 
@@ -133,7 +185,7 @@ module Bundler
       !index.source_plugin(name.to_s).nil?
     end
 
-    # @return [Class] that handles the source. The calss includes API::Source
+    # @return [Class] that handles the source. The class includes API::Source
     def source(name)
       raise UnknownSourceError, "Source #{name} not found" unless source? name
 
@@ -154,6 +206,9 @@ module Bundler
     # 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
 
@@ -165,6 +220,9 @@ module Bundler
     # @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?
@@ -189,10 +247,11 @@ module Bundler
     # @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]
-        validate_plugin! Pathname.new(spec.full_gem_path)
-        installed = register_plugin(name, spec, optional_plugins.include?(name))
-        Bundler.ui.info "Installed plugin #{name}" if installed
+
+        save_plugin(name, spec, optional_plugins.include?(name))
       end
     end
 
@@ -207,6 +266,22 @@ module Bundler
       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.
     #
@@ -226,7 +301,7 @@ module Bundler
       @hooks_by_event = Hash.new {|h, k| h[k] = [] }
 
       load_paths = spec.load_paths
-      add_to_load_path(load_paths)
+      Bundler.rubygems.add_to_load_path(load_paths)
       path = Pathname.new spec.full_gem_path
 
       begin
@@ -253,32 +328,25 @@ module Bundler
     #
     # @param [String] name of the plugin
     def load_plugin(name)
+      return unless name && !name.empty?
+
       # 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)
 
-      add_to_load_path(index.load_paths(name))
+      Bundler.rubygems.add_to_load_path(index.load_paths(name))
 
       load path.join(PLUGIN_FILE_NAME)
 
       @loaded_plugin_names << name
-    rescue => e
+    rescue RuntimeError => e
       Bundler.ui.error "Failed loading plugin #{name}: #{e.message}"
       raise
     end
 
-    def add_to_load_path(load_paths)
-      if insert_index = Bundler.rubygems.load_path_insert_index
-        $LOAD_PATH.insert(insert_index, *load_paths)
-      else
-        $LOAD_PATH.unshift(*load_paths)
-      end
-    end
-
     class << self
-      private :load_plugin, :register_plugin, :save_plugins, :validate_plugin!,
-        :add_to_load_path
+      private :load_plugin, :register_plugin, :save_plugins, :validate_plugin!
     end
   end
 end

data/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/lib/bundler/remote_specification.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "uri"
 
 module Bundler
   # Represents a lazily loaded gem specification, where the full specification
@@ -7,6 +6,7 @@ module Bundler
   # 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
 
@@ -17,7 +17,8 @@ module Bundler
     def initialize(name, version, platform, spec_fetcher)
       @name         = name
       @version      = Gem::Version.create version
-      @platform     = platform
+      @original_platform = platform || Gem::Platform::RUBY
+      @platform     = Gem::Platform.new(platform)
       @spec_fetcher = spec_fetcher
       @dependencies = nil
     end
@@ -29,10 +30,10 @@ module Bundler
     end
 
     def full_name
-      if platform == Gem::Platform::RUBY || platform.nil?
+      @full_name ||= if @platform == Gem::Platform::RUBY
         "#{@name}-#{@version}"
       else
-        "#{@name}-#{@version}-#{platform}"
+        "#{@name}-#{@version}-#{@platform}"
       end
     end
 
@@ -51,6 +52,8 @@ module Bundler
     # 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
@@ -77,7 +80,8 @@ module Bundler
         deps = method_missing(:dependencies)
 
         # allow us to handle when the specs dependencies are an array of array of string
-        # see https://github.com/bundler/bundler/issues/5797
+        # 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
@@ -89,16 +93,16 @@ module Bundler
       " #{source.revision[0..6]}"
     end
 
-  private
+    private
 
     def to_ary
       nil
     end
 
     def _remote_specification
-      @_remote_specification ||= @spec_fetcher.fetch_spec([@name, @version, @platform])
+      @_remote_specification ||= @spec_fetcher.fetch_spec([@name, @version, @original_platform])
       @_remote_specification || raise(GemspecError, "Gemspec data for #{full_name} was" \
-        " missing from the server! Try installing with `--full-index` as a workaround.")
+        " missing from the server!")
     end
 
     def method_missing(method, *args, &blk)

data/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/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

data/lib/bundler/resolver/incompatibility.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Resolver
+    class Incompatibility < PubGrub::Incompatibility
+      attr_reader :extended_explanation
+
+      def initialize(terms, cause:, custom_explanation: nil, extended_explanation: nil)
+        @extended_explanation = extended_explanation
+
+        super(terms, :cause => cause, :custom_explanation => custom_explanation)
+      end
+    end
+  end
+end

data/lib/bundler/resolver/package.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Resolver
+    #
+    # Represents a gem being resolved, in a format PubGrub likes.
+    #
+    # The class holds the following information:
+    #
+    # * Platforms this gem will be resolved on.
+    # * The locked version of this gem resolution should favor (if any).
+    # * Whether the gem should be unlocked to its latest version.
+    # * The dependency explicit set in the Gemfile for this gem (if any).
+    #
+    class Package
+      attr_reader :name, :platforms, :dependency, :locked_version
+
+      def initialize(name, platforms, locked_specs:, unlock:, prerelease: false, dependency: nil)
+        @name = name
+        @platforms = platforms
+        @locked_version = locked_specs[name].first&.version
+        @unlock = unlock
+        @dependency = dependency || Dependency.new(name, @locked_version)
+        @prerelease = @dependency.prerelease? || @locked_version&.prerelease? || prerelease ? :consider_first : :ignore
+      end
+
+      def to_s
+        @name.delete("\0")
+      end
+
+      def root?
+        false
+      end
+
+      def meta?
+        @name.end_with?("\0")
+      end
+
+      def ==(other)
+        self.class == other.class && @name == other.name
+      end
+
+      def hash
+        @name.hash
+      end
+
+      def unlock?
+        @unlock.empty? || @unlock.include?(name)
+      end
+
+      def ignores_prereleases?
+        @prerelease == :ignore
+      end
+
+      def prerelease_specified?
+        @prerelease == :consider_first
+      end
+
+      def consider_prereleases!
+        @prerelease = :consider_last
+      end
+
+      def force_ruby_platform?
+        @dependency.force_ruby_platform
+      end
+
+      def current_platform?
+        @dependency.current_platform?
+      end
+    end
+  end
+end

data/lib/bundler/resolver/root.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "package"
+
+module Bundler
+  class Resolver
+    #
+    # Represents the Gemfile from the resolver's perspective. It's the root
+    # package and Gemfile entries depend on it.
+    #
+    class Root < Package
+      def initialize(name)
+        @name = name
+      end
+
+      def meta?
+        true
+      end
+
+      def root?
+        true
+      end
+    end
+  end
+end