rubygems-update 3.4.10 → 3.5.22

data/bundler/lib/bundler/cli/gem.rb

@@ -11,7 +11,7 @@ module Bundler
   class CLI::Gem
     TEST_FRAMEWORK_VERSIONS = {
       "rspec" => "3.0",
-      "minitest" => "5.0",
+      "minitest" => "5.16",
       "test-unit" => "3.0",
     }.freeze
 
@@ -32,7 +32,6 @@ module Bundler
 
       validate_ext_name if @extension
       validate_rust_builder_rubygems_version if @extension == "rust"
-      travis_removal_info
     end
 
     def run
@@ -59,28 +58,28 @@ module Bundler
       end
 
       config = {
-        :name => name,
-        :underscored_name => underscored_name,
-        :namespaced_path => namespaced_path,
-        :makefile_path => "#{underscored_name}/#{underscored_name}",
-        :constant_name => constant_name,
-        :constant_array => constant_array,
-        :author => git_author_name.empty? ? "TODO: Write your name" : git_author_name,
-        :email => git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
-        :test => options[:test],
-        :ext => extension,
-        :exe => options[:exe],
-        :bundler_version => bundler_dependency_version,
-        :git => use_git,
-        :github_username => github_username.empty? ? "[USERNAME]" : github_username,
-        :required_ruby_version => required_ruby_version,
-        :rust_builder_required_rubygems_version => rust_builder_required_rubygems_version,
-        :minitest_constant_name => minitest_constant_name,
+        name: name,
+        underscored_name: underscored_name,
+        namespaced_path: namespaced_path,
+        makefile_path: "#{underscored_name}/#{underscored_name}",
+        constant_name: constant_name,
+        constant_array: constant_array,
+        author: git_author_name.empty? ? "TODO: Write your name" : git_author_name,
+        email: git_user_email.empty? ? "TODO: Write your email address" : git_user_email,
+        test: options[:test],
+        ext: extension,
+        exe: options[:exe],
+        bundler_version: bundler_dependency_version,
+        git: use_git,
+        github_username: github_username.empty? ? "[USERNAME]" : github_username,
+        required_ruby_version: required_ruby_version,
+        rust_builder_required_rubygems_version: rust_builder_required_rubygems_version,
+        minitest_constant_name: minitest_constant_name,
       }
       ensure_safe_gem_name(name, constant_array)
 
       templates = {
-        "#{Bundler.preferred_gemfile_name}.tt" => Bundler.preferred_gemfile_name,
+        "Gemfile.tt" => Bundler.preferred_gemfile_name,
         "lib/newgem.rb.tt" => "lib/#{namespaced_path}.rb",
         "lib/newgem/version.rb.tt" => "lib/#{namespaced_path}/version.rb",
         "sig/newgem.rbs.tt" => "sig/#{namespaced_path}.rbs",
@@ -137,10 +136,13 @@ module Bundler
       case config[:ci]
       when "github"
         templates.merge!("github/workflows/main.yml.tt" => ".github/workflows/main.yml")
+        config[:ci_config_path] = ".github "
       when "gitlab"
         templates.merge!("gitlab-ci.yml.tt" => ".gitlab-ci.yml")
+        config[:ci_config_path] = ".gitlab-ci.yml "
       when "circle"
         templates.merge!("circleci/config.yml.tt" => ".circleci/config.yml")
+        config[:ci_config_path] = ".circleci "
       end
 
       if ask_and_set(:mit, "Do you want to license your code permissively under the MIT license?",
@@ -189,7 +191,10 @@ module Bundler
         templates.merge!("standard.yml.tt" => ".standard.yml")
       end
 
-      templates.merge!("exe/newgem.tt" => "exe/#{name}") if config[:exe]
+      if config[:exe]
+        templates.merge!("exe/newgem.tt" => "exe/#{name}")
+        executables.push("exe/#{name}")
+      end
 
       if extension == "c"
         templates.merge!(
@@ -233,9 +238,7 @@ module Bundler
       end
 
       if use_git
-        Dir.chdir(target) do
-          `git add .`
-        end
+        IO.popen(%w[git add .], { chdir: target }, &:read)
       end
 
       # Open gemspec in editor
@@ -275,6 +278,7 @@ module Bundler
     end
 
     def ask_and_set_test_framework
+      return if skip?(:test)
       test_framework = options[:test] || Bundler.settings["gem.test"]
 
       if test_framework.to_s.empty?
@@ -300,6 +304,10 @@ module Bundler
       test_framework
     end
 
+    def skip?(option)
+      options.key?(option) && options[option].nil?
+    end
+
     def hint_text(setting)
       if Bundler.settings["gem.#{setting}"] == false
         "Your choice will only be applied to this gem."
@@ -310,6 +318,7 @@ module Bundler
     end
 
     def ask_and_set_ci
+      return if skip?(:ci)
       ci_template = options[:ci] || Bundler.settings["gem.ci"]
 
       if ci_template.to_s.empty?
@@ -341,6 +350,7 @@ module Bundler
     end
 
     def ask_and_set_linter
+      return if skip?(:linter)
       linter_template = options[:linter] || Bundler.settings["gem.linter"]
       linter_template = deprecated_rubocop_option if linter_template.nil?
 
@@ -348,7 +358,7 @@ module Bundler
         Bundler.ui.confirm "Do you want to add a code linter and formatter to your gem? " \
           "Supported Linters:\n" \
           "* RuboCop:       https://rubocop.org\n" \
-          "* Standard:      https://github.com/testdouble/standard\n" \
+          "* Standard:      https://github.com/standardrb/standard\n" \
           "\n"
         Bundler.ui.info hint_text("linter")
 
@@ -379,15 +389,20 @@ module Bundler
     def deprecated_rubocop_option
       if !options[:rubocop].nil?
         if options[:rubocop]
-          Bundler::SharedHelpers.major_deprecation 2, "--rubocop is deprecated, use --linter=rubocop"
+          Bundler::SharedHelpers.major_deprecation 2,
+            "--rubocop is deprecated, use --linter=rubocop",
+            removed_message: "--rubocop has been removed, use --linter=rubocop"
           "rubocop"
         else
-          Bundler::SharedHelpers.major_deprecation 2, "--no-rubocop is deprecated, use --linter"
+          Bundler::SharedHelpers.major_deprecation 2,
+            "--no-rubocop is deprecated, use --linter",
+            removed_message: "--no-rubocop has been removed, use --linter"
           false
         end
       elsif !Bundler.settings["gem.rubocop"].nil?
         Bundler::SharedHelpers.major_deprecation 2,
-          "config gem.rubocop is deprecated; we've updated your config to use gem.linter instead"
+          "config gem.rubocop is deprecated; we've updated your config to use gem.linter instead",
+          removed_message: "config gem.rubocop has been removed; we've updated your config to use gem.linter instead"
         Bundler.settings["gem.rubocop"] ? "rubocop" : false
       end
     end
@@ -431,7 +446,7 @@ module Bundler
     end
 
     def required_ruby_version
-      "2.6.0"
+      "3.0.0"
     end
 
     def rubocop_version
@@ -442,19 +457,6 @@ module Bundler
       "1.3"
     end
 
-    # TODO: remove at next minor release
-    def travis_removal_info
-      if options[:ci] == "travis"
-        Bundler.ui.error "Support for Travis CI was removed from gem skeleton generator."
-        exit 1
-      end
-
-      if Bundler.settings["gem.ci"] == "travis"
-        Bundler.ui.error "Support for Travis CI was removed from gem skeleton generator, but it is present in bundle config. Please configure another provider using `bundle config set gem.ci SERVICE` (where SERVICE is one of github/gitlab/circle) or unset configuration using `bundle config unset gem.ci`."
-        exit 1
-      end
-    end
-
     def validate_rust_builder_rubygems_version
       if Gem::Version.new(rust_builder_required_rubygems_version) > Gem.rubygems_version
         Bundler.ui.error "Your RubyGems version (#{Gem.rubygems_version}) is too old to build Rust extension. Please update your RubyGems using `gem update --system` or any other way and try again."

data/bundler/lib/bundler/cli/info.rb

@@ -25,19 +25,8 @@ module Bundler
 
     private
 
-    def spec_for_gem(gem_name)
-      spec = Bundler.definition.specs.find {|s| s.name == gem_name }
-      spec || default_gem_spec(gem_name) || Bundler::CLI::Common.select_spec(gem_name, :regex_match)
-    end
-
-    def default_gem_spec(gem_name)
-      return unless Gem::Specification.respond_to?(:find_all_by_name)
-      gem_spec = Gem::Specification.find_all_by_name(gem_name).last
-      return gem_spec if gem_spec && gem_spec.respond_to?(:default_gem?) && gem_spec.default_gem?
-    end
-
-    def spec_not_found(gem_name)
-      raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(gem_name, Bundler.definition.dependencies)
+    def spec_for_gem(name)
+      Bundler::CLI::Common.select_spec(name, :regex_match)
     end
 
     def print_gem_version(spec)

data/bundler/lib/bundler/cli/install.rb

@@ -12,9 +12,13 @@ module Bundler
 
       warn_if_root
 
-      Bundler.self_manager.install_locked_bundler_and_restart_with_it_if_needed
+      if options[:local]
+        Bundler.self_manager.restart_with_locked_bundler_if_needed
+      else
+        Bundler.self_manager.install_locked_bundler_and_restart_with_it_if_needed
+      end
 
-      Bundler::SharedHelpers.set_env "RB_USER_INSTALL", "1" if Bundler::FREEBSD
+      Bundler::SharedHelpers.set_env "RB_USER_INSTALL", "1" if Gem.freebsd_platform?
 
       # Disable color in deployment mode
       Bundler.ui.shell = Thor::Shell::Basic.new if options[:deployment]
@@ -25,11 +29,12 @@ module Bundler
 
       if options[:deployment] || options[:frozen] || Bundler.frozen_bundle?
         unless Bundler.default_lockfile.exist?
-          flag   = "--deployment flag" if options[:deployment]
-          flag ||= "--frozen flag"     if options[:frozen]
-          flag ||= "deployment setting"
-          raise ProductionError, "The #{flag} requires a #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}. Please make " \
-                                 "sure you have checked your #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} into version control " \
+          flag = "--deployment flag" if options[:deployment]
+          flag ||= "--frozen flag" if options[:frozen]
+          flag ||= "deployment setting" if Bundler.settings[:deployment]
+          flag ||= "frozen setting" if Bundler.settings[:frozen]
+          raise ProductionError, "The #{flag} requires a lockfile. Please make " \
+                                 "sure you have checked your #{SharedHelpers.relative_lockfile_path} into version control " \
                                  "before deploying."
         end
 
@@ -51,7 +56,8 @@ module Bundler
 
       if options["binstubs"]
         Bundler::SharedHelpers.major_deprecation 2,
-          "The --binstubs option will be removed in favor of `bundle binstubs --all`"
+          "The --binstubs option will be removed in favor of `bundle binstubs --all`",
+          removed_message: "The --binstubs option have been removed in favor of `bundle binstubs --all`"
       end
 
       Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
@@ -61,7 +67,7 @@ module Bundler
 
       installer = Installer.install(Bundler.root, definition, options)
 
-      Bundler.settings.temporary(:cache_all_platforms => options[:local] ? false : Bundler.settings[:cache_all_platforms]) do
+      Bundler.settings.temporary(cache_all_platforms: options[:local] ? false : Bundler.settings[:cache_all_platforms]) do
         Bundler.load.cache(nil, options[:local]) if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.frozen_bundle?
       end
 
@@ -95,7 +101,7 @@ module Bundler
     def warn_if_root
       return if Bundler.settings[:silence_root_warning] || Gem.win_platform? || !Process.uid.zero?
       Bundler.ui.warn "Don't run Bundler as root. Installing your bundle as root " \
-                      "will break this application for all non-root users on this machine.", :wrap => true
+                      "will break this application for all non-root users on this machine.", wrap: true
     end
 
     def dependencies_count_for(definition)
@@ -148,13 +154,13 @@ module Bundler
       Bundler.settings.set_command_option_if_given :path, options[:path]
 
       if options["standalone"] && Bundler.settings[:path].nil? && !options["local"]
-        Bundler.settings.temporary(:path_relative_to_cwd => false) do
+        Bundler.settings.temporary(path_relative_to_cwd: false) do
           Bundler.settings.set_command_option :path, "bundle"
         end
       end
 
       bin_option = options["binstubs"]
-      bin_option = nil if bin_option && bin_option.empty?
+      bin_option = nil if bin_option&.empty?
       Bundler.settings.set_command_option :bin, bin_option if options["binstubs"]
 
       Bundler.settings.set_command_option_if_given :shebang, options["shebang"]

data/bundler/lib/bundler/cli/issue.rb

@@ -5,7 +5,7 @@ require "rbconfig"
 module Bundler
   class CLI::Issue
     def run
-      Bundler.ui.info <<-EOS.gsub(/^ {8}/, "")
+      Bundler.ui.info <<~EOS
         Did you find an issue with Bundler? Before filing a new issue,
         be sure to check out these resources:
 

data/bundler/lib/bundler/cli/lock.rb

@@ -15,8 +15,8 @@ module Bundler
       end
 
       print = options[:print]
-      previous_ui_level = Bundler.ui.level
-      Bundler.ui.level = "silent" if print
+      previous_output_stream = Bundler.ui.output_stream
+      Bundler.ui.output_stream = :stderr if print
 
       Bundler::Fetcher.disable_endpoint = options["full-index"]
 
@@ -26,45 +26,49 @@ module Bundler
 
       if update.is_a?(Array) # unlocking specific gems
         Bundler::CLI::Common.ensure_all_gems_in_lockfile!(update)
-        update = { :gems => update, :conservative => conservative }
+        update = { gems: update, conservative: conservative }
       elsif update && conservative
-        update = { :conservative => conservative }
+        update = { conservative: conservative }
       elsif update && bundler
-        update = { :bundler => bundler }
+        update = { bundler: bundler }
       end
-      definition = Bundler.definition(update)
 
-      Bundler::CLI::Common.configure_gem_version_promoter(Bundler.definition, options) if options[:update]
+      file = options[:lockfile]
+      file = file ? Pathname.new(file).expand_path : Bundler.default_lockfile
 
-      options["remove-platform"].each do |platform|
-        definition.remove_platform(platform)
-      end
+      Bundler.settings.temporary(frozen: false) do
+        definition = Bundler.definition(update, file)
+
+        Bundler::CLI::Common.configure_gem_version_promoter(definition, options) if options[:update]
 
-      options["add-platform"].each do |platform_string|
-        platform = Gem::Platform.new(platform_string)
-        if platform.to_s == "unknown"
-          Bundler.ui.warn "The platform `#{platform_string}` is unknown to RubyGems " \
-            "and adding it will likely lead to resolution errors"
+        options["remove-platform"].each do |platform|
+          definition.remove_platform(platform)
         end
-        definition.add_platform(platform)
-      end
 
-      if definition.platforms.empty?
-        raise InvalidOption, "Removing all platforms from the bundle is not allowed"
-      end
+        options["add-platform"].each do |platform_string|
+          platform = Gem::Platform.new(platform_string)
+          if platform.to_s == "unknown"
+            Bundler.ui.error "The platform `#{platform_string}` is unknown to RubyGems and can't be added to the lockfile."
+            exit 1
+          end
+          definition.add_platform(platform)
+        end
+
+        if definition.platforms.empty?
+          raise InvalidOption, "Removing all platforms from the bundle is not allowed"
+        end
 
-      definition.resolve_remotely! unless options[:local]
+        definition.resolve_remotely! unless options[:local]
 
-      if print
-        puts definition.to_lock
-      else
-        file = options[:lockfile]
-        file = file ? File.expand_path(file) : Bundler.default_lockfile
-        puts "Writing lockfile to #{file}"
-        definition.lock(file)
+        if print
+          puts definition.to_lock
+        else
+          puts "Writing lockfile to #{file}"
+          definition.lock
+        end
       end
 
-      Bundler.ui.level = previous_ui_level
+      Bundler.ui.output_stream = previous_output_stream
     end
   end
 end

data/bundler/lib/bundler/cli/open.rb

@@ -18,13 +18,11 @@ module Bundler
         Bundler.ui.info "Unable to open #{name} because it's a default gem, so the directory it would normally be installed to does not exist."
       else
         root_path = spec.full_gem_path
-        Dir.chdir(root_path) do
-          require "shellwords"
-          command = Shellwords.split(editor) << File.join([root_path, path].compact)
-          Bundler.with_original_env do
-            system(*command)
-          end || Bundler.ui.info("Could not run '#{command.join(" ")}'")
-        end
+        require "shellwords"
+        command = Shellwords.split(editor) << File.join([root_path, path].compact)
+        Bundler.with_original_env do
+          system(*command, { chdir: root_path })
+        end || Bundler.ui.info("Could not run '#{command.join(" ")}'")
       end
     end
   end

data/bundler/lib/bundler/cli/outdated.rb

@@ -41,12 +41,12 @@ module Bundler
         # We're doing a full update
         Bundler.definition(true)
       else
-        Bundler.definition(:gems => gems, :sources => sources)
+        Bundler.definition(gems: gems, sources: sources)
       end
 
       Bundler::CLI::Common.configure_gem_version_promoter(
         Bundler.definition,
-        options.merge(:strict => @strict)
+        options.merge(strict: @strict)
       )
 
       definition_resolution = proc do
@@ -54,7 +54,7 @@ module Bundler
       end
 
       if options[:parseable]
-        Bundler.ui.silence(&definition_resolution)
+        Bundler.ui.progress(&definition_resolution)
       else
         definition_resolution.call
       end
@@ -90,35 +90,33 @@ module Bundler
         end
 
         outdated_gems << {
-          :active_spec => active_spec,
-          :current_spec => current_spec,
-          :dependency => dependency,
-          :groups => groups,
+          active_spec: active_spec,
+          current_spec: current_spec,
+          dependency: dependency,
+          groups: groups,
         }
       end
 
-      if outdated_gems.empty?
+      relevant_outdated_gems = if options_include_groups
+        outdated_gems.group_by {|g| g[:groups] }.sort.flat_map do |groups, gems|
+          contains_group = groups.split(", ").include?(options[:group])
+          next unless options[:groups] || contains_group
+
+          gems
+        end.compact
+      else
+        outdated_gems
+      end
+
+      if relevant_outdated_gems.empty?
         unless options[:parseable]
           Bundler.ui.info(nothing_outdated_message)
         end
       else
-        if options_include_groups
-          relevant_outdated_gems = outdated_gems.group_by {|g| g[:groups] }.sort.flat_map do |groups, gems|
-            contains_group = groups.split(", ").include?(options[:group])
-            next unless options[:groups] || contains_group
-
-            gems
-          end.compact
-
-          if options[:parseable]
-            print_gems(relevant_outdated_gems)
-          else
-            print_gems_table(relevant_outdated_gems)
-          end
-        elsif options[:parseable]
-          print_gems(outdated_gems)
+        if options[:parseable]
+          print_gems(relevant_outdated_gems)
         else
-          print_gems_table(outdated_gems)
+          print_gems_table(relevant_outdated_gems)
         end
 
         exit 1
@@ -194,7 +192,7 @@ module Bundler
       end
       current_version = "#{current_spec.version}#{current_spec.git_version}"
 
-      if dependency && dependency.specific?
+      if dependency&.specific?
         dependency_version = %(, requested #{dependency.requirement})
       end
 

data/bundler/lib/bundler/cli/platform.rb

@@ -8,12 +8,12 @@ module Bundler
     end
 
     def run
-      platforms, ruby_version = Bundler.ui.silence do
-        locked_ruby_version = Bundler.locked_gems && Bundler.locked_gems.ruby_version&.gsub(/p\d+\Z/, "")
-        gemfile_ruby_version = Bundler.definition.ruby_version && Bundler.definition.ruby_version.single_version_string
-        [Bundler.definition.platforms.map {|p| "* #{p}" },
-         locked_ruby_version || gemfile_ruby_version]
+      ruby_version = if Bundler.locked_gems
+        Bundler.locked_gems.ruby_version&.gsub(/p\d+\Z/, "")
+      else
+        Bundler.definition.ruby_version&.single_version_string
       end
+
       output = []
 
       if options[:ruby]
@@ -23,6 +23,8 @@ module Bundler
           output << "No ruby version specified"
         end
       else
+        platforms = Bundler.definition.platforms.map {|p| "* #{p}" }
+
         output << "Your platform is: #{Gem::Platform.local}"
         output << "Your app has gems that work on these platforms:\n#{platforms.join("\n")}"
 

data/bundler/lib/bundler/cli/plugin.rb

@@ -5,20 +5,15 @@ module Bundler
   class CLI::Plugin < Thor
     desc "install PLUGINS", "Install the plugin from the source"
     long_desc <<-D
-      Install plugins either from the rubygems source provided (with --source option) or from a git source provided with --git (for remote repos) or --local_git (for local repos). If no sources are provided, it uses Gem.sources
+      Install plugins either from the rubygems source provided (with --source option), from a git source provided with --git, or a local path provided with --path. If no sources are provided, it uses Gem.sources
    D
-    method_option "source", :type => :string, :default => nil, :banner =>
-      "URL of the RubyGems source to fetch the plugin from"
-    method_option "version", :type => :string, :default => nil, :banner =>
-      "The version of the plugin to fetch"
-    method_option "git", :type => :string, :default => nil, :banner =>
-      "URL of the git repo to fetch from"
-    method_option "local_git", :type => :string, :default => nil, :banner =>
-      "Path of the local git repo to fetch from"
-    method_option "branch", :type => :string, :default => nil, :banner =>
-      "The git branch to checkout"
-    method_option "ref", :type => :string, :default => nil, :banner =>
-      "The git revision to check out"
+    method_option "source", type: :string, default: nil, banner: "URL of the RubyGems source to fetch the plugin from"
+    method_option "version", type: :string, default: nil, banner: "The version of the plugin to fetch"
+    method_option "git", type: :string, default: nil, banner: "URL of the git repo to fetch from"
+    method_option "local_git", type: :string, default: nil, banner: "Path of the local git repo to fetch from (deprecated)"
+    method_option "branch", type: :string, default: nil, banner: "The git branch to checkout"
+    method_option "ref", type: :string, default: nil, banner: "The git revision to check out"
+    method_option "path", type: :string, default: nil, banner: "Path of a local gem to directly use"
     def install(*plugins)
       Bundler::Plugin.install(plugins, options)
     end
@@ -27,8 +22,7 @@ module Bundler
     long_desc <<-D
       Uninstall given list of plugins. To uninstall all the plugins, use -all option.
     D
-    method_option "all", :type => :boolean, :default => nil, :banner =>
-      "Uninstall all the installed plugins. If no plugin is installed, then it does nothing."
+    method_option "all", type: :boolean, default: nil, banner: "Uninstall all the installed plugins. If no plugin is installed, then it does nothing."
     def uninstall(*plugins)
       Bundler::Plugin.uninstall(plugins, options)
     end

data/bundler/lib/bundler/cli/pristine.rb

@@ -12,40 +12,48 @@ module Bundler
       definition.validate_runtime!
       installer = Bundler::Installer.new(Bundler.root, definition)
 
-      Bundler.load.specs.each do |spec|
-        next if spec.name == "bundler" # Source::Rubygems doesn't install bundler
-        next if !@gems.empty? && !@gems.include?(spec.name)
-
-        gem_name = "#{spec.name} (#{spec.version}#{spec.git_version})"
-        gem_name += " (#{spec.platform})" if !spec.platform.nil? && spec.platform != Gem::Platform::RUBY
-
-        case source = spec.source
-        when Source::Rubygems
-          cached_gem = spec.cache_file
-          unless File.exist?(cached_gem)
-            Bundler.ui.error("Failed to pristine #{gem_name}. Cached gem #{cached_gem} does not exist.")
+      ProcessLock.lock do
+        installed_specs = definition.specs.reject do |spec|
+          next if spec.name == "bundler" # Source::Rubygems doesn't install bundler
+          next if !@gems.empty? && !@gems.include?(spec.name)
+
+          gem_name = "#{spec.name} (#{spec.version}#{spec.git_version})"
+          gem_name += " (#{spec.platform})" if !spec.platform.nil? && spec.platform != Gem::Platform::RUBY
+
+          case source = spec.source
+          when Source::Rubygems
+            cached_gem = spec.cache_file
+            unless File.exist?(cached_gem)
+              Bundler.ui.error("Failed to pristine #{gem_name}. Cached gem #{cached_gem} does not exist.")
+              next
+            end
+
+            FileUtils.rm_rf spec.full_gem_path
+          when Source::Git
+            if source.local?
+              Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is locally overridden.")
+              next
+            end
+
+            source.remote!
+            if extension_cache_path = source.extension_cache_path(spec)
+              FileUtils.rm_rf extension_cache_path
+            end
+            FileUtils.rm_rf spec.extension_dir
+            FileUtils.rm_rf spec.full_gem_path
+          else
+            Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is sourced from local path.")
             next
           end
 
-          FileUtils.rm_rf spec.full_gem_path
-        when Source::Git
-          if source.local?
-            Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is locally overridden.")
-            next
-          end
+          true
+        end.map(&:name)
 
-          source.remote!
-          if extension_cache_path = source.extension_cache_path(spec)
-            FileUtils.rm_rf extension_cache_path
-          end
-          FileUtils.rm_rf spec.extension_dir
-          FileUtils.rm_rf spec.full_gem_path
-        else
-          Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is sourced from local path.")
-          next
-        end
-
-        Bundler::GemInstaller.new(spec, installer, false, 0, true).install_from_spec
+        jobs = installer.send(:installation_parallelization, {})
+        pristine_count = definition.specs.count - installed_specs.count
+        # allow a pristining a single gem to skip the parallel worker
+        jobs = [jobs, pristine_count].min
+        ParallelInstaller.call(installer, definition.specs, jobs, false, true, skip: installed_specs)
       end
     end
   end

data/bundler/lib/bundler/cli/show.rb

@@ -40,8 +40,8 @@ module Bundler
           desc = "  * #{s.name} (#{s.version}#{s.git_version})"
           if @verbose
             latest = latest_specs.find {|l| l.name == s.name }
-            Bundler.ui.info <<-END.gsub(/^ +/, "")
-              #{desc}
+            Bundler.ui.info <<~END
+              #{desc.lstrip}
               \tSummary:  #{s.summary || "No description available."}
               \tHomepage: #{s.homepage || "No website available."}
               \tStatus:   #{outdated?(s, latest) ? "Outdated - #{s.version} < #{latest.version}" : "Up to date"}