rubygems-update 3.0.3 → 3.4.7

data/lib/rubygems/commands/setup_command.rb

@@ -1,95 +1,105 @@
 # frozen_string_literal: true
-require 'rubygems/command'
+require_relative "../command"
 
 ##
 # Installs RubyGems itself.  This command is ordinarily only available from a
 # RubyGems checkout or tarball.
 
 class Gem::Commands::SetupCommand < Gem::Command
-  HISTORY_HEADER = /^===\s*[\d.a-zA-Z]+\s*\/\s*\d{4}-\d{2}-\d{2}\s*$/.freeze
-  VERSION_MATCHER = /^===\s*([\d.a-zA-Z]+)\s*\/\s*\d{4}-\d{2}-\d{2}\s*$/.freeze
+  HISTORY_HEADER = /^#\s*[\d.a-zA-Z]+\s*\/\s*\d{4}-\d{2}-\d{2}\s*$/.freeze
+  VERSION_MATCHER = /^#\s*([\d.a-zA-Z]+)\s*\/\s*\d{4}-\d{2}-\d{2}\s*$/.freeze
 
   ENV_PATHS = %w[/usr/bin/env /bin/env].freeze
 
   def initialize
-    require 'tmpdir'
-
-    super 'setup', 'Install RubyGems',
-          :format_executable => true, :document => %w[ri],
-          :site_or_vendor => 'sitelibdir',
-          :destdir => '', :prefix => '', :previous_version => '',
-          :regenerate_binstubs => true
-
-    add_option '--previous-version=VERSION',
-               'Previous version of RubyGems',
-               'Used for changelog processing' do |version, options|
+    super "setup", "Install RubyGems",
+          :format_executable => false, :document => %w[ri],
+          :force => true,
+          :site_or_vendor => "sitelibdir",
+          :destdir => "", :prefix => "", :previous_version => "",
+          :regenerate_binstubs => true,
+          :regenerate_plugins => true
+
+    add_option "--previous-version=VERSION",
+               "Previous version of RubyGems",
+               "Used for changelog processing" do |version, options|
       options[:previous_version] = version
     end
 
-    add_option '--prefix=PREFIX',
-               'Prefix path for installing RubyGems',
-               'Will not affect gem repository location' do |prefix, options|
+    add_option "--prefix=PREFIX",
+               "Prefix path for installing RubyGems",
+               "Will not affect gem repository location" do |prefix, options|
       options[:prefix] = File.expand_path prefix
     end
 
-    add_option '--destdir=DESTDIR',
-               'Root directory to install RubyGems into',
-               'Mainly used for packaging RubyGems' do |destdir, options|
+    add_option "--destdir=DESTDIR",
+               "Root directory to install RubyGems into",
+               "Mainly used for packaging RubyGems" do |destdir, options|
       options[:destdir] = File.expand_path destdir
     end
 
-    add_option '--[no-]vendor',
-               'Install into vendorlibdir not sitelibdir' do |vendor, options|
-      options[:site_or_vendor] = vendor ? 'vendorlibdir' : 'sitelibdir'
+    add_option "--[no-]vendor",
+               "Install into vendorlibdir not sitelibdir" do |vendor, options|
+      options[:site_or_vendor] = vendor ? "vendorlibdir" : "sitelibdir"
     end
 
-    add_option '--[no-]format-executable',
-               'Makes `gem` match ruby',
-               'If Ruby is ruby18, gem will be gem18' do |value, options|
+    add_option "--[no-]format-executable",
+               "Makes `gem` match ruby",
+               "If Ruby is ruby18, gem will be gem18" do |value, options|
       options[:format_executable] = value
     end
 
-    add_option '--[no-]document [TYPES]', Array,
-               'Generate documentation for RubyGems',
-               'List the documentation types you wish to',
-               'generate.  For example: rdoc,ri' do |value, options|
+    add_option "--[no-]document [TYPES]", Array,
+               "Generate documentation for RubyGems",
+               "List the documentation types you wish to",
+               "generate.  For example: rdoc,ri" do |value, options|
       options[:document] = case value
-                           when nil   then %w[rdoc ri]
-                           when false then []
-                           else            value
-                           end
+      when nil   then %w[rdoc ri]
+      when false then []
+      else            value
+      end
     end
 
-    add_option '--[no-]rdoc',
-               'Generate RDoc documentation for RubyGems' do |value, options|
+    add_option "--[no-]rdoc",
+               "Generate RDoc documentation for RubyGems" do |value, options|
       if value
-        options[:document] << 'rdoc'
+        options[:document] << "rdoc"
       else
-        options[:document].delete 'rdoc'
+        options[:document].delete "rdoc"
       end
 
       options[:document].uniq!
     end
 
-    add_option '--[no-]ri',
-               'Generate RI documentation for RubyGems' do |value, options|
+    add_option "--[no-]ri",
+               "Generate RI documentation for RubyGems" do |value, options|
       if value
-        options[:document] << 'ri'
+        options[:document] << "ri"
       else
-        options[:document].delete 'ri'
+        options[:document].delete "ri"
       end
 
       options[:document].uniq!
     end
 
-    add_option '--[no-]regenerate-binstubs',
-               'Regenerate gem binstubs' do |value, options|
+    add_option "--[no-]regenerate-binstubs",
+               "Regenerate gem binstubs" do |value, options|
       options[:regenerate_binstubs] = value
     end
 
-    add_option('-E', '--[no-]env-shebang',
-               'Rewrite executables with a shebang',
-               'of /usr/bin/env') do |value, options|
+    add_option "--[no-]regenerate-plugins",
+               "Regenerate gem plugins" do |value, options|
+      options[:regenerate_plugins] = value
+    end
+
+    add_option "-f", "--[no-]force",
+               "Forcefully overwrite binstubs" do |value, options|
+      options[:force] = value
+    end
+
+    add_option("-E", "--[no-]env-shebang",
+               "Rewrite executables with a shebang",
+               "of /usr/bin/env") do |value, options|
       options[:env_shebang] = value
     end
 
@@ -97,7 +107,7 @@ class Gem::Commands::SetupCommand < Gem::Command
   end
 
   def check_ruby_version
-    required_version = Gem::Requirement.new '>= 1.8.7'
+    required_version = Gem::Requirement.new ">= 2.6.0"
 
     unless required_version.satisfied_by? Gem.ruby_version
       alert_error "Expected Ruby version #{required_version}, is #{Gem.ruby_version}"
@@ -128,7 +138,7 @@ By default, this RubyGems will install gem as:
   end
 
   module MakeDirs
-    def mkdir_p(path, *opts)
+    def mkdir_p(path, **opts)
       super
       (@mkdirs ||= []) << path
     end
@@ -137,16 +147,9 @@ By default, this RubyGems will install gem as:
   def execute
     @verbose = Gem.configuration.really_verbose
 
-    install_destdir = options[:destdir]
-
-    unless install_destdir.empty?
-      ENV['GEM_HOME'] ||= File.join(install_destdir,
-                                    Gem.default_dir.gsub(/^[a-zA-Z]:/, ''))
-    end
-
     check_ruby_version
 
-    require 'fileutils'
+    require "fileutils"
     if Gem.configuration.really_verbose
       extend FileUtils::Verbose
     else
@@ -154,7 +157,8 @@ By default, this RubyGems will install gem as:
     end
     extend MakeDirs
 
-    lib_dir, bin_dir = make_destination_dirs install_destdir
+    lib_dir, bin_dir = make_destination_dirs
+    man_dir = generate_default_man_dir
 
     install_lib lib_dir
 
@@ -164,7 +168,10 @@ By default, this RubyGems will install gem as:
 
     remove_old_lib_files lib_dir
 
-    install_default_bundler_gem
+    # Can be removed one we drop support for bundler 2.2.3 (the last version installing man files to man_dir)
+    remove_old_man_files man_dir if man_dir && File.exist?(man_dir)
+
+    install_default_bundler_gem bin_dir
 
     if mode = options[:dir_mode]
       @mkdirs.uniq!
@@ -173,7 +180,8 @@ By default, this RubyGems will install gem as:
 
     say "RubyGems #{Gem::VERSION} installed"
 
-    regenerate_binstubs if options[:regenerate_binstubs]
+    regenerate_binstubs(bin_dir) if options[:regenerate_binstubs]
+    regenerate_plugins(bin_dir) if options[:regenerate_plugins]
 
     uninstall_old_gemcutter
 
@@ -186,7 +194,7 @@ By default, this RubyGems will install gem as:
     end
 
     if options[:previous_version].empty?
-      options[:previous_version] = Gem::VERSION.sub(/[0-9]+$/, '0')
+      options[:previous_version] = Gem::VERSION.sub(/[0-9]+$/, "0")
     end
 
     options[:previous_version] = Gem::Version.new(options[:previous_version])
@@ -198,17 +206,17 @@ By default, this RubyGems will install gem as:
     say
 
     say "RubyGems installed the following executables:"
-    say @bin_file_names.map { |name| "\t#{name}\n" }
+    say bin_file_names.map {|name| "\t#{name}\n" }
     say
 
-    unless @bin_file_names.grep(/#{File::SEPARATOR}gem$/)
+    unless bin_file_names.grep(/#{File::SEPARATOR}gem$/)
       say "If `gem` was installed by a previous RubyGems installation, you may need"
       say "to remove it by hand."
       say
     end
 
     if documentation_success
-      if options[:document].include? 'rdoc'
+      if options[:document].include? "rdoc"
         say "Rdoc documentation was installed. You may now invoke:"
         say "  gem server"
         say "and then peruse beautifully formatted documentation for your gems"
@@ -219,7 +227,7 @@ By default, this RubyGems will install gem as:
         say
       end
 
-      if options[:document].include? 'ri'
+      if options[:document].include? "ri"
         say "Ruby Interactive (ri) documentation was installed. ri is kind of like man "
         say "pages for Ruby libraries. You may access it like this:"
         say "  ri Classname"
@@ -233,53 +241,42 @@ By default, this RubyGems will install gem as:
     end
   end
 
-
   def install_executables(bin_dir)
-    @bin_file_names = []
-
     prog_mode = options[:prog_mode] || 0755
 
-    executables = { 'gem' => 'bin' }
-    executables['bundler'] = 'bundler/exe' if Gem::USE_BUNDLER_FOR_GEMDEPS
+    executables = { "gem" => "bin" }
     executables.each do |tool, path|
       say "Installing #{tool} executable" if @verbose
 
       Dir.chdir path do
-        bin_files = Dir['*']
-
-        bin_files -= %w[update_rubygems bundler bundle_ruby]
+        bin_file = "gem"
 
-        bin_files.each do |bin_file|
-          bin_file_formatted = if options[:format_executable]
-                                 Gem.default_exec_format % bin_file
-                               else
-                                 bin_file
-                               end
+        require "tmpdir"
 
-          dest_file = File.join bin_dir, bin_file_formatted
-          bin_tmp_file = File.join Dir.tmpdir, "#{bin_file}.#{$$}"
+        dest_file = target_bin_path(bin_dir, bin_file)
+        bin_tmp_file = File.join Dir.tmpdir, "#{bin_file}.#{$$}"
 
-          begin
-            bin = File.readlines bin_file
-            bin[0] = shebang
+        begin
+          bin = File.readlines bin_file
+          bin[0] = shebang
 
-            File.open bin_tmp_file, 'w' do |fp|
-              fp.puts bin.join
-            end
-
-            install bin_tmp_file, dest_file, :mode => prog_mode
-            @bin_file_names << dest_file
-          ensure
-            rm bin_tmp_file
+          File.open bin_tmp_file, "w" do |fp|
+            fp.puts bin.join
           end
 
-          next unless Gem.win_platform?
+          install bin_tmp_file, dest_file, :mode => prog_mode
+          bin_file_names << dest_file
+        ensure
+          rm bin_tmp_file
+        end
+
+        next unless Gem.win_platform?
 
-          begin
-            bin_cmd_file = File.join Dir.tmpdir, "#{bin_file}.bat"
+        begin
+          bin_cmd_file = File.join Dir.tmpdir, "#{bin_file}.bat"
 
-            File.open bin_cmd_file, 'w' do |file|
-              file.puts <<-TEXT
+          File.open bin_cmd_file, "w" do |file|
+            file.puts <<-TEXT
   @ECHO OFF
   IF NOT "%~f0" == "~f0" GOTO :WinNT
   @"#{File.basename(Gem.ruby).chomp('"')}" "#{dest_file}" %1 %2 %3 %4 %5 %6 %7 %8 %9
@@ -287,12 +284,11 @@ By default, this RubyGems will install gem as:
   :WinNT
   @"#{File.basename(Gem.ruby).chomp('"')}" "%~dpn0" %*
   TEXT
-            end
-
-            install bin_cmd_file, "#{dest_file}.bat", :mode => prog_mode
-          ensure
-            rm bin_cmd_file
           end
+
+          install bin_cmd_file, "#{dest_file}.bat", :mode => prog_mode
+        ensure
+          rm bin_cmd_file
         end
       end
     end
@@ -300,7 +296,7 @@ By default, this RubyGems will install gem as:
 
   def shebang
     if options[:env_shebang]
-      ruby_name = RbConfig::CONFIG['ruby_install_name']
+      ruby_name = RbConfig::CONFIG["ruby_install_name"]
       @env_path ||= ENV_PATHS.find {|env_path| File.executable? env_path }
       "#!#{@env_path} #{ruby_name}\n"
     else
@@ -308,41 +304,22 @@ By default, this RubyGems will install gem as:
     end
   end
 
-  def install_file(file, dest_dir)
-    dest_file = File.join dest_dir, file
-    dest_dir = File.dirname dest_file
-    unless File.directory? dest_dir
-      mkdir_p dest_dir, :mode => 0755
-    end
-
-    install file, dest_file, :mode => options[:data_mode] || 0644
-  end
-
   def install_lib(lib_dir)
-    libs = { 'RubyGems' => 'lib' }
-    libs['Bundler'] = 'bundler/lib' if Gem::USE_BUNDLER_FOR_GEMDEPS
+    libs = { "RubyGems" => "lib" }
+    libs["Bundler"] = "bundler/lib"
     libs.each do |tool, path|
       say "Installing #{tool}" if @verbose
 
-      lib_files = rb_files_in path
-      lib_files.concat(template_files) if tool == 'Bundler'
-
-      pem_files = pem_files_in path
+      lib_files = files_in path
 
       Dir.chdir path do
-        lib_files.each do |lib_file|
-          install_file lib_file, lib_dir
-        end
-
-        pem_files.each do |pem_file|
-          install_file pem_file, lib_dir
-        end
+        install_file_list(lib_files, lib_dir)
       end
     end
   end
 
   def install_rdoc
-    gem_doc_dir = File.join Gem.dir, 'doc'
+    gem_doc_dir = File.join Gem.dir, "doc"
     rubygems_name = "rubygems-#{Gem::VERSION}"
     rubygems_doc_dir = File.join gem_doc_dir, rubygems_name
 
@@ -352,23 +329,23 @@ By default, this RubyGems will install gem as:
       # ignore
     end
 
-    if File.writable? gem_doc_dir and
-       (not File.exist? rubygems_doc_dir or
-        File.writable? rubygems_doc_dir)
+    if File.writable?(gem_doc_dir) &&
+       (!File.exist?(rubygems_doc_dir) ||
+        File.writable?(rubygems_doc_dir))
       say "Removing old RubyGems RDoc and ri" if @verbose
-      Dir[File.join(Gem.dir, 'doc', 'rubygems-[0-9]*')].each do |dir|
+      Dir[File.join(Gem.dir, "doc", "rubygems-[0-9]*")].each do |dir|
         rm_rf dir
       end
 
-      require 'rubygems/rdoc'
+      require_relative "../rdoc"
 
-      fake_spec = Gem::Specification.new 'rubygems', Gem::VERSION
+      fake_spec = Gem::Specification.new "rubygems", Gem::VERSION
       def fake_spec.full_gem_path
-        File.expand_path '../../../..', __FILE__
+        File.expand_path "../../..", __dir__
       end
 
-      generate_ri   = options[:document].include? 'ri'
-      generate_rdoc = options[:document].include? 'rdoc'
+      generate_ri   = options[:document].include? "ri"
+      generate_rdoc = options[:document].include? "rdoc"
 
       rdoc = Gem::RDoc.new fake_spec, generate_rdoc, generate_ri
       rdoc.generate
@@ -382,33 +359,27 @@ By default, this RubyGems will install gem as:
     return false
   end
 
-  def install_default_bundler_gem
-    return unless Gem::USE_BUNDLER_FOR_GEMDEPS
-
-    specs_dir = Gem::Specification.default_specifications_dir
-    specs_dir = File.join(options[:destdir], specs_dir) unless Gem.win_platform?
-    mkdir_p specs_dir, :mode => 0755
-
-    # Workaround for non-git environment.
-    gemspec = File.open('bundler/bundler.gemspec', 'rb'){|f| f.read.gsub(/`git ls-files -z`/, "''") }
-    File.open('bundler/bundler.gemspec', 'w'){|f| f.write gemspec }
-
-    bundler_spec = Gem::Specification.load("bundler/bundler.gemspec")
-    bundler_spec.files = Dir.chdir("bundler") { Dir["{*.md,{lib,exe,man}/**/*}"] }
-    bundler_spec.executables -= %w[bundler bundle_ruby]
-
-    # Remove bundler-*.gemspec in default specification directory.
-    Dir.entries(specs_dir).
-      select {|gs| gs.start_with?("bundler-") }.
-      each {|gs| File.delete(File.join(specs_dir, gs)) }
+  def install_default_bundler_gem(bin_dir)
+    current_default_spec = Gem::Specification.default_stubs.find {|s| s.name == "bundler" }
+    specs_dir = if current_default_spec && default_dir == Gem.default_dir
+      Gem::Specification.remove_spec current_default_spec
+      loaded_from = current_default_spec.loaded_from
+      File.delete(loaded_from)
+      File.dirname(loaded_from)
+    else
+      target_specs_dir = File.join(default_dir, "specifications", "default")
+      mkdir_p target_specs_dir, :mode => 0755
+      target_specs_dir
+    end
 
+    bundler_spec = Dir.chdir("bundler") { Gem::Specification.load("bundler.gemspec") }
     default_spec_path = File.join(specs_dir, "#{bundler_spec.full_name}.gemspec")
     Gem.write_binary(default_spec_path, bundler_spec.to_ruby)
 
     bundler_spec = Gem::Specification.load(default_spec_path)
 
     # Remove gemspec that was same version of vendored bundler.
-    normal_gemspec = File.join(Gem.default_dir, "specifications", "bundler-#{bundler_spec.version}.gemspec")
+    normal_gemspec = File.join(default_dir, "specifications", "bundler-#{bundler_spec.version}.gemspec")
     if File.file? normal_gemspec
       File.delete normal_gemspec
     end
@@ -421,29 +392,41 @@ By default, this RubyGems will install gem as:
     end
 
     bundler_bin_dir = bundler_spec.bin_dir
-    bundler_bin_dir = File.join(options[:destdir], bundler_bin_dir) unless Gem.win_platform?
     mkdir_p bundler_bin_dir, :mode => 0755
     bundler_spec.executables.each do |e|
       cp File.join("bundler", bundler_spec.bindir, e), File.join(bundler_bin_dir, e)
     end
 
-    if Gem.win_platform?
-      require 'rubygems/installer'
-
-      installer = Gem::Installer.for_spec bundler_spec
-      bundler_spec.executables.each do |e|
-        installer.generate_windows_script e, bundler_spec.bin_dir
+    require_relative "../installer"
+
+    Dir.chdir("bundler") do
+      built_gem = Gem::Package.build(bundler_spec)
+      begin
+        Gem::Installer.at(
+          built_gem,
+          env_shebang: options[:env_shebang],
+          format_executable: options[:format_executable],
+          force: options[:force],
+          install_as_default: true,
+          bin_dir: bin_dir,
+          install_dir: default_dir,
+          wrappers: true
+        ).install
+      ensure
+        FileUtils.rm_f built_gem
       end
     end
 
+    bundler_spec.executables.each {|executable| bin_file_names << target_bin_path(bin_dir, executable) }
+
     say "Bundler #{bundler_spec.version} installed"
   end
 
-  def make_destination_dirs(install_destdir)
+  def make_destination_dirs
     lib_dir, bin_dir = Gem.default_rubygems_dirs
 
     unless lib_dir
-      lib_dir, bin_dir = generate_default_dirs(install_destdir)
+      lib_dir, bin_dir = generate_default_dirs
     end
 
     mkdir_p lib_dir, :mode => 0755
@@ -452,74 +435,49 @@ By default, this RubyGems will install gem as:
     return lib_dir, bin_dir
   end
 
-  def generate_default_dirs(install_destdir)
+  def generate_default_man_dir
     prefix = options[:prefix]
-    site_or_vendor = options[:site_or_vendor]
 
     if prefix.empty?
-      lib_dir = RbConfig::CONFIG[site_or_vendor]
-      bin_dir = RbConfig::CONFIG['bindir']
+      man_dir = RbConfig::CONFIG["mandir"]
+      return unless man_dir
     else
-      # Apple installed RubyGems into libdir, and RubyGems <= 1.1.0 gets
-      # confused about installation location, so switch back to
-      # sitelibdir/vendorlibdir.
-      if defined?(APPLE_GEM_HOME) and
-        # just in case Apple and RubyGems don't get this patched up proper.
-        (prefix == RbConfig::CONFIG['libdir'] or
-         # this one is important
-         prefix == File.join(RbConfig::CONFIG['libdir'], 'ruby'))
-        lib_dir = RbConfig::CONFIG[site_or_vendor]
-        bin_dir = RbConfig::CONFIG['bindir']
-      else
-        lib_dir = File.join prefix, 'lib'
-        bin_dir = File.join prefix, 'bin'
-      end
+      man_dir = File.join prefix, "man"
     end
 
-    unless install_destdir.empty?
-      lib_dir = File.join install_destdir, lib_dir.gsub(/^[a-zA-Z]:/, '')
-      bin_dir = File.join install_destdir, bin_dir.gsub(/^[a-zA-Z]:/, '')
-    end
-
-    [lib_dir, bin_dir]
+    prepend_destdir_if_present(man_dir)
   end
 
-  def pem_files_in(dir)
-    Dir.chdir dir do
-      Dir[File.join('**', '*pem')]
-    end
-  end
+  def generate_default_dirs
+    prefix = options[:prefix]
+    site_or_vendor = options[:site_or_vendor]
 
-  def rb_files_in(dir)
-    Dir.chdir dir do
-      Dir[File.join('**', '*rb')]
+    if prefix.empty?
+      lib_dir = RbConfig::CONFIG[site_or_vendor]
+      bin_dir = RbConfig::CONFIG["bindir"]
+    else
+      lib_dir = File.join prefix, "lib"
+      bin_dir = File.join prefix, "bin"
     end
-  end
 
-  # for installation of bundler as default gems
-  def template_files
-    Dir.chdir "bundler/lib" do
-      (Dir[File.join('bundler', 'templates', '**', '{*,.*}')]).
-        select{|f| !File.directory?(f)}
-    end
+    [prepend_destdir_if_present(lib_dir), prepend_destdir_if_present(bin_dir)]
   end
 
-  # for cleanup old bundler files
-  def template_files_in(dir)
+  def files_in(dir)
     Dir.chdir dir do
-      (Dir[File.join('templates', '**', '{*,.*}')]).
-        select{|f| !File.directory?(f)}
+      Dir.glob(File.join("**", "*"), File::FNM_DOTMATCH).
+        select {|f| !File.directory?(f) }
     end
   end
 
   def remove_old_bin_files(bin_dir)
     old_bin_files = {
-      'gem_mirror' => 'gem mirror',
-      'gem_server' => 'gem server',
-      'gemlock' => 'gem lock',
-      'gemri' => 'ri',
-      'gemwhich' => 'gem which',
-      'index_gem_repository.rb' => 'gem generate_index',
+      "gem_mirror" => "gem mirror",
+      "gem_server" => "gem server",
+      "gemlock" => "gem lock",
+      "gemri" => "ri",
+      "gemwhich" => "gem which",
+      "index_gem_repository.rb" => "gem generate_index",
     }
 
     old_bin_files.each do |old_bin_file, new_name|
@@ -528,7 +486,7 @@ By default, this RubyGems will install gem as:
 
       deprecation_message = "`#{old_bin_file}` has been deprecated. Use `#{new_name}` instead."
 
-      File.open old_bin_path, 'w' do |fp|
+      File.open old_bin_path, "w" do |fp|
         fp.write <<-EOF
 #!#{Gem.ruby}
 
@@ -538,41 +496,53 @@ abort "#{deprecation_message}"
 
       next unless Gem.win_platform?
 
-      File.open "#{old_bin_path}.bat", 'w' do |fp|
-        fp.puts %{@ECHO.#{deprecation_message}}
+      File.open "#{old_bin_path}.bat", "w" do |fp|
+        fp.puts %(@ECHO.#{deprecation_message})
       end
     end
   end
 
   def remove_old_lib_files(lib_dir)
-    lib_dirs = { File.join(lib_dir, 'rubygems') => 'lib/rubygems' }
-    lib_dirs[File.join(lib_dir, 'bundler')] = 'bundler/lib/bundler' if Gem::USE_BUNDLER_FOR_GEMDEPS
+    lib_dirs = { File.join(lib_dir, "rubygems") => "lib/rubygems" }
+    lib_dirs[File.join(lib_dir, "bundler")] = "bundler/lib/bundler"
     lib_dirs.each do |old_lib_dir, new_lib_dir|
-      lib_files = rb_files_in(new_lib_dir)
-      lib_files.concat(template_files_in(new_lib_dir)) if new_lib_dir =~ /bundler/
+      lib_files = files_in(new_lib_dir)
 
-      old_lib_files = rb_files_in(old_lib_dir)
-      old_lib_files.concat(template_files_in(old_lib_dir)) if old_lib_dir =~ /bundler/
+      old_lib_files = files_in(old_lib_dir)
 
       to_remove = old_lib_files - lib_files
 
+      gauntlet_rubygems = File.join(lib_dir, "gauntlet_rubygems.rb")
+      to_remove << gauntlet_rubygems if File.exist? gauntlet_rubygems
+
       to_remove.delete_if do |file|
-        file.start_with? 'defaults'
+        file.start_with? "defaults"
       end
 
-      Dir.chdir old_lib_dir do
-        to_remove.each do |file|
-          FileUtils.rm_f file
+      remove_file_list(to_remove, old_lib_dir)
+    end
+  end
 
-          warn "unable to remove old file #{file} please remove it by hand" if
-            File.exist? file
-        end
-      end
+  def remove_old_man_files(old_man_dir)
+    old_man1_dir = "#{old_man_dir}/man1"
+
+    if File.exist?(old_man1_dir)
+      man1_to_remove = Dir.chdir(old_man1_dir) { Dir["bundle*.1{,.txt,.ronn}"] }
+
+      remove_file_list(man1_to_remove, old_man1_dir)
+    end
+
+    old_man5_dir = "#{old_man_dir}/man5"
+
+    if File.exist?(old_man5_dir)
+      man5_to_remove = Dir.chdir(old_man5_dir) { Dir["gemfile.5{,.txt,.ronn}"] }
+
+      remove_file_list(man5_to_remove, old_man5_dir)
     end
   end
 
   def show_release_notes
-    release_notes = File.join Dir.pwd, 'History.txt'
+    release_notes = File.join Dir.pwd, "CHANGELOG.md"
 
     release_notes =
       if File.exist? release_notes
@@ -580,8 +550,6 @@ abort "#{deprecation_message}"
 
         history.force_encoding Encoding::UTF_8
 
-        history = history.sub(/^# coding:.*?(?=^=)/m, '')
-
         text = history.split(HISTORY_HEADER)
         text.shift # correct an off-by-one generated by split
         version_lines = history.scan(HISTORY_HEADER)
@@ -591,8 +559,8 @@ abort "#{deprecation_message}"
 
         history_string = ""
 
-        until versions.length == 0 or
-              versions.shift < options[:previous_version] do
+        until versions.length == 0 ||
+              versions.shift <= options[:previous_version] do
           history_string += version_lines.shift + text.shift
         end
 
@@ -605,19 +573,20 @@ abort "#{deprecation_message}"
   end
 
   def uninstall_old_gemcutter
-    require 'rubygems/uninstaller'
+    require_relative "../uninstaller"
 
-    ui = Gem::Uninstaller.new('gemcutter', :all => true, :ignore => true,
-                              :version => '< 0.4')
+    ui = Gem::Uninstaller.new("gemcutter", :all => true, :ignore => true,
+                                           :version => "< 0.4")
     ui.uninstall
   rescue Gem::InstallError
   end
 
-  def regenerate_binstubs
-    require "rubygems/commands/pristine_command"
+  def regenerate_binstubs(bindir)
+    require_relative "pristine_command"
     say "Regenerating binstubs"
 
     args = %w[--all --only-executables --silent]
+    args << "--bindir=#{bindir}"
     if options[:env_shebang]
       args << "--env-shebang"
     end
@@ -626,4 +595,76 @@ abort "#{deprecation_message}"
     command.invoke(*args)
   end
 
+  def regenerate_plugins(bindir)
+    require_relative "pristine_command"
+    say "Regenerating plugins"
+
+    args = %w[--all --only-plugins --silent]
+    args << "--bindir=#{bindir}"
+    args << "--install-dir=#{default_dir}"
+
+    command = Gem::Commands::PristineCommand.new
+    command.invoke(*args)
+  end
+
+  private
+
+  def default_dir
+    prefix = options[:prefix]
+
+    if prefix.empty?
+      dir = Gem.default_dir
+    else
+      dir = prefix
+    end
+
+    prepend_destdir_if_present(dir)
+  end
+
+  def prepend_destdir_if_present(path)
+    destdir = options[:destdir]
+    return path if destdir.empty?
+
+    File.join(options[:destdir], path.gsub(/^[a-zA-Z]:/, ""))
+  end
+
+  def install_file_list(files, dest_dir)
+    files.each do |file|
+      install_file file, dest_dir
+    end
+  end
+
+  def install_file(file, dest_dir)
+    dest_file = File.join dest_dir, file
+    dest_dir = File.dirname dest_file
+    unless File.directory? dest_dir
+      mkdir_p dest_dir, :mode => 0755
+    end
+
+    install file, dest_file, :mode => options[:data_mode] || 0644
+  end
+
+  def remove_file_list(files, dir)
+    Dir.chdir dir do
+      files.each do |file|
+        FileUtils.rm_f file
+
+        warn "unable to remove old file #{file} please remove it by hand" if
+          File.exist? file
+      end
+    end
+  end
+
+  def target_bin_path(bin_dir, bin_file)
+    bin_file_formatted = if options[:format_executable]
+      Gem.default_exec_format % bin_file
+    else
+      bin_file
+    end
+    File.join bin_dir, bin_file_formatted
+  end
+
+  def bin_file_names
+    @bin_file_names ||= []
+  end
 end