rubygems-update 2.6.1 → 3.5.0

data/lib/rubygems/uninstaller.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
 # See LICENSE.txt for permissions.
 #++
 
-require 'fileutils'
-require 'rubygems'
-require 'rubygems/dependency_list'
-require 'rubygems/rdoc'
-require 'rubygems/user_interaction'
+require "fileutils"
+require_relative "../rubygems"
+require_relative "installer_uninstaller_utils"
+require_relative "dependency_list"
+require_relative "rdoc"
+require_relative "user_interaction"
 
 ##
 # An Uninstaller.
@@ -20,9 +22,10 @@ require 'rubygems/user_interaction'
 # file.  See Gem.pre_uninstall and Gem.post_uninstall for details.
 
 class Gem::Uninstaller
-
   include Gem::UserInteraction
 
+  include Gem::InstallerUninstallerUtils
+
   ##
   # The directory a gem's executables will be installed into
 
@@ -43,10 +46,11 @@ class Gem::Uninstaller
   # Constructs an uninstaller that will uninstall +gem+
 
   def initialize(gem, options = {})
-    # TODO document the valid options
+    # TODO: document the valid options
     @gem                = gem
     @version            = options[:version] || Gem::Requirement.default
-    @gem_home           = File.expand_path(options[:install_dir] || Gem.dir)
+    @gem_home           = File.realpath(options[:install_dir] || Gem.dir)
+    @plugins_dir        = Gem.plugindir(@gem_home)
     @force_executables  = options[:executables]
     @force_all          = options[:all]
     @force_ignore       = options[:ignore]
@@ -57,7 +61,7 @@ class Gem::Uninstaller
     # Indicate if development dependencies should be checked when
     # uninstalling. (default: false)
     #
-    @check_dev         = options[:check_dev]
+    @check_dev = options[:check_dev]
 
     if options[:force]
       @force_all = true
@@ -67,6 +71,9 @@ class Gem::Uninstaller
     # only add user directory if install_dir is not set
     @user_install = false
     @user_install = options[:user_install] unless options[:install_dir]
+
+    # Optimization: populated during #uninstall
+    @default_specs_matching_uninstall_params = []
   end
 
   ##
@@ -80,7 +87,7 @@ class Gem::Uninstaller
 
     dirs =
       Gem::Specification.dirs +
-      [Gem::Specification.default_specifications_dir]
+      [Gem.default_specifications_dir]
 
     Gem::Specification.each_spec dirs do |spec|
       next unless dependency.matches_spec? spec
@@ -88,53 +95,48 @@ class Gem::Uninstaller
       list << spec
     end
 
-    default_specs, list = list.partition do |spec|
-      spec.default_gem?
+    if list.empty?
+      raise Gem::InstallError, "gem #{@gem.inspect} is not installed"
     end
 
+    default_specs, list = list.partition(&:default_gem?)
+    warn_cannot_uninstall_default_gems(default_specs - list)
+    @default_specs_matching_uninstall_params = default_specs
+
     list, other_repo_specs = list.partition do |spec|
-      @gem_home == spec.base_dir or
-        (@user_install and spec.base_dir == Gem.user_dir)
+      @gem_home == spec.base_dir ||
+        (@user_install && spec.base_dir == Gem.user_dir)
     end
 
     list.sort!
 
-    if list.empty? then
-      if other_repo_specs.empty?
-        if default_specs.empty?
-          raise Gem::InstallError, "gem #{@gem.inspect} is not installed"
-        else
-          message =
-            "gem #{@gem.inspect} cannot be uninstalled " +
-            "because it is a default gem"
-          raise Gem::InstallError, message
-        end
-      end
+    if list.empty?
+      return unless other_repo_specs.any?
 
-      other_repos = other_repo_specs.map { |spec| spec.base_dir }.uniq
+      other_repos = other_repo_specs.map(&:base_dir).uniq
 
       message = ["#{@gem} is not installed in GEM_HOME, try:"]
-      message.concat other_repos.map { |repo|
+      message.concat other_repos.map {|repo|
         "\tgem uninstall -i #{repo} #{@gem}"
       }
 
       raise Gem::InstallError, message.join("\n")
-    elsif @force_all then
+    elsif @force_all
       remove_all list
 
-    elsif list.size > 1 then
-      gem_names = list.map { |gem| gem.full_name }
+    elsif list.size > 1
+      gem_names = list.map(&:full_name)
       gem_names << "All versions"
 
       say
       _, index = choose_from_list "Select gem to uninstall:", gem_names
 
-      if index == list.size then
+      if index == list.size
         remove_all list
-      elsif index >= 0 && index < list.size then
+      elsif index && index >= 0 && index < list.size
         uninstall_gem list[index]
       else
-        say "Error: must enter a number [1-#{list.size+1}]"
+        say "Error: must enter a number [1-#{list.size + 1}]"
       end
     else
       uninstall_gem list.first
@@ -159,8 +161,11 @@ class Gem::Uninstaller
     end
 
     remove_executables @spec
+    remove_plugins @spec
     remove @spec
 
+    regenerate_plugins
+
     Gem.post_uninstall_hooks.each do |hook|
       hook.call self
     end
@@ -169,20 +174,19 @@ class Gem::Uninstaller
   end
 
   ##
-  # Removes installed executables and batch files (windows only) for
-  # +gemspec+.
+  # Removes installed executables and batch files (windows only) for +spec+.
 
   def remove_executables(spec)
-    return if spec.nil? or spec.executables.empty?
+    return if spec.executables.empty?
 
     executables = spec.executables.clone
 
     # Leave any executables created by other installed versions
     # of this gem installed.
 
-    list = Gem::Specification.find_all { |s|
+    list = Gem::Specification.find_all do |s|
       s.name == spec.name && s.version != spec.version
-    }
+    end
 
     list.each do |s|
       s.executables.each do |exe_name|
@@ -192,18 +196,18 @@ class Gem::Uninstaller
 
     return if executables.empty?
 
-    executables = executables.map { |exec| formatted_program_filename exec }
+    executables = executables.map {|exec| formatted_program_filename exec }
 
-    remove = if @force_executables.nil? then
-               ask_yes_no("Remove executables:\n" +
-                          "\t#{executables.join ', '}\n\n" +
-                          "in addition to the gem?",
-                          true)
-             else
-               @force_executables
-             end
+    remove = if @force_executables.nil?
+      ask_yes_no("Remove executables:\n" \
+                 "\t#{executables.join ", "}\n\n" \
+                 "in addition to the gem?",
+                 true)
+    else
+      @force_executables
+    end
 
-    if remove then
+    if remove
       bin_dir = @bin_dir || Gem.bindir(spec.base_dir)
 
       raise Gem::FilePermissionError, bin_dir unless File.writable? bin_dir
@@ -213,8 +217,8 @@ class Gem::Uninstaller
 
         exe_file = File.join bin_dir, exe_name
 
-        FileUtils.rm_f exe_file
-        FileUtils.rm_f "#{exe_file}.bat"
+        safe_delete { FileUtils.rm exe_file }
+        safe_delete { FileUtils.rm "#{exe_file}.bat" }
       end
     else
       say "Executables and scripts will remain installed."
@@ -227,21 +231,17 @@ class Gem::Uninstaller
   # NOTE: removes uninstalled gems from +list+.
 
   def remove_all(list)
-    list.each { |spec| uninstall_gem spec }
+    list.each {|spec| uninstall_gem spec }
   end
 
   ##
   # spec:: the spec of the gem to be uninstalled
-  # list:: the list of all such gems
-  #
-  # Warning: this method modifies the +list+ parameter.  Once it has
-  # uninstalled a gem, it is removed from that list.
 
   def remove(spec)
-    unless path_ok?(@gem_home, spec) or
-           (@user_install and path_ok?(Gem.user_dir, spec)) then
+    unless path_ok?(@gem_home, spec) ||
+           (@user_install && path_ok?(Gem.user_dir, spec))
       e = Gem::GemNotInHomeException.new \
-            "Gem '#{spec.full_name}' is not installed in directory #{@gem_home}"
+        "Gem '#{spec.full_name}' is not installed in directory #{@gem_home}"
       e.spec = spec
 
       raise e
@@ -250,37 +250,59 @@ class Gem::Uninstaller
     raise Gem::FilePermissionError, spec.base_dir unless
       File.writable?(spec.base_dir)
 
-    FileUtils.rm_rf spec.full_gem_path
-    FileUtils.rm_rf spec.extension_dir
+    safe_delete { FileUtils.rm_r spec.full_gem_path }
+    safe_delete { FileUtils.rm_r spec.extension_dir }
 
     old_platform_name = spec.original_name
-    gemspec           = spec.spec_file
-
-    unless File.exist? gemspec then
-      gemspec = File.join(File.dirname(gemspec), "#{old_platform_name}.gemspec")
-    end
-
-    FileUtils.rm_rf gemspec
 
     gem = spec.cache_file
     gem = File.join(spec.cache_dir, "#{old_platform_name}.gem") unless
       File.exist? gem
 
-    FileUtils.rm_rf gem
+    safe_delete { FileUtils.rm_r gem }
 
-    Gem::RDoc.new(spec).remove
+    begin
+      Gem::RDoc.new(spec).remove
+    rescue NameError
+    end
 
-    say "Successfully uninstalled #{spec.full_name}"
+    gemspec = spec.spec_file
+
+    unless File.exist? gemspec
+      gemspec = File.join(File.dirname(gemspec), "#{old_platform_name}.gemspec")
+    end
+
+    safe_delete { FileUtils.rm_r gemspec }
+    announce_deletion_of(spec)
 
     Gem::Specification.reset
   end
 
+  ##
+  # Remove any plugin wrappers for +spec+.
+
+  def remove_plugins(spec) # :nodoc:
+    return if spec.plugins.empty?
+
+    remove_plugins_for(spec, @plugins_dir)
+  end
+
+  ##
+  # Regenerates plugin wrappers after removal.
+
+  def regenerate_plugins
+    latest = Gem::Specification.latest_spec_for(@spec.name)
+    return if latest.nil?
+
+    regenerate_plugins_for(latest, @plugins_dir)
+  end
+
   ##
   # Is +spec+ in +gem_dir+?
 
   def path_ok?(gem_dir, spec)
-    full_path     = File.join gem_dir, 'gems', spec.full_name
-    original_path = File.join gem_dir, 'gems', spec.original_name
+    full_path     = File.join gem_dir, "gems", spec.full_name
+    original_path = File.join gem_dir, "gems", spec.original_name
 
     full_path == spec.full_gem_path || original_path == spec.full_gem_path
   end
@@ -289,7 +311,7 @@ class Gem::Uninstaller
   # Returns true if it is OK to remove +spec+ or this is a forced
   # uninstallation.
 
-  def dependencies_ok? spec # :nodoc:
+  def dependencies_ok?(spec) # :nodoc:
     return true if @force_ignore
 
     deplist = Gem::DependencyList.from_specs
@@ -308,39 +330,80 @@ class Gem::Uninstaller
   ##
   # Asks if it is OK to remove +spec+.  Returns true if it is OK.
 
-  def ask_if_ok spec # :nodoc:
-    msg = ['']
-    msg << 'You have requested to uninstall the gem:'
+  def ask_if_ok(spec) # :nodoc:
+    msg = [""]
+    msg << "You have requested to uninstall the gem:"
     msg << "\t#{spec.full_name}"
-    msg << ''
+    msg << ""
 
     siblings = Gem::Specification.select do |s|
-                 s.name == spec.name && s.full_name != spec.full_name
-               end
+      s.name == spec.name && s.full_name != spec.full_name
+    end
 
-    spec.dependent_gems.each do |dep_spec, dep, satlist|
-      unless siblings.any? { |s| s.satisfies_requirement? dep }
+    spec.dependent_gems(@check_dev).each do |dep_spec, dep, _satlist|
+      unless siblings.any? {|s| s.satisfies_requirement? dep }
         msg << "#{dep_spec.name}-#{dep_spec.version} depends on #{dep}"
       end
     end
 
-    msg << 'If you remove this gem, these dependencies will not be met.'
-    msg << 'Continue with Uninstall?'
-    return ask_yes_no(msg.join("\n"), false)
+    msg << "If you remove this gem, these dependencies will not be met."
+    msg << "Continue with Uninstall?"
+    ask_yes_no(msg.join("\n"), false)
   end
 
   ##
   # Returns the formatted version of the executable +filename+
 
-  def formatted_program_filename filename # :nodoc:
+  def formatted_program_filename(filename) # :nodoc:
     # TODO perhaps the installer should leave a small manifest
     # of what it did for us to find rather than trying to recreate
     # it again.
-    if @format_executable then
-      require 'rubygems/installer'
+    if @format_executable
+      require_relative "installer"
       Gem::Installer.exec_format % File.basename(filename)
     else
       filename
     end
   end
+
+  def safe_delete(&block)
+    block.call
+  rescue Errno::ENOENT
+    nil
+  rescue Errno::EPERM
+    e = Gem::UninstallError.new
+    e.spec = @spec
+
+    raise e
+  end
+
+  private
+
+  def announce_deletion_of(spec)
+    name = spec.full_name
+    say "Successfully uninstalled #{name}"
+    if default_spec_matches?(spec)
+      say(
+        "There was both a regular copy and a default copy of #{name}. The " \
+          "regular copy was successfully uninstalled, but the default copy " \
+          "was left around because default gems can't be removed."
+      )
+    end
+  end
+
+  # @return true if the specs of any default gems are `==` to the given `spec`.
+  def default_spec_matches?(spec)
+    !default_specs_that_match(spec).empty?
+  end
+
+  # @return [Array] specs of default gems that are `==` to the given `spec`.
+  def default_specs_that_match(spec)
+    @default_specs_matching_uninstall_params.select {|default_spec| spec == default_spec }
+  end
+
+  def warn_cannot_uninstall_default_gems(specs)
+    specs.each do |spec|
+      say "Gem #{spec.full_name} cannot be uninstalled because it is a default gem"
+    end
+  end
 end

data/lib/rubygems/unknown_command_spell_checker.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Gem::UnknownCommandSpellChecker
+  attr_reader :error
+
+  def initialize(error)
+    @error = error
+  end
+
+  def corrections
+    @corrections ||=
+      spell_checker.correct(error.unknown_command).map(&:inspect)
+  end
+
+  private
+
+  def spell_checker
+    dictionary = Gem::CommandManager.instance.command_names
+    DidYouMean::SpellChecker.new(dictionary: dictionary)
+  end
+end

data/lib/rubygems/update_suggestion.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+##
+# Mixin methods for Gem::Command to promote available RubyGems update
+
+module Gem::UpdateSuggestion
+  ONE_WEEK = 7 * 24 * 60 * 60
+
+  ##
+  # Message to promote available RubyGems update with related gem update command.
+
+  def update_suggestion
+    <<-MESSAGE
+
+A new release of RubyGems is available: #{Gem.rubygems_version} → #{Gem.latest_rubygems_version}!
+Run `gem update --system #{Gem.latest_rubygems_version}` to update your installation.
+
+    MESSAGE
+  end
+
+  ##
+  # Determines if current environment is eligible for update suggestion.
+
+  def eligible_for_update?
+    # explicit opt-out
+    return false if Gem.configuration[:prevent_update_suggestion]
+    return false if ENV["RUBYGEMS_PREVENT_UPDATE_SUGGESTION"]
+
+    # focus only on human usage of final RubyGems releases
+    return false unless Gem.ui.tty?
+    return false if Gem.rubygems_version.prerelease?
+    return false if Gem.disable_system_update_message
+    return false if Gem::CIDetector.ci?
+
+    # check makes sense only when we can store timestamp of last try
+    # otherwise we will not be able to prevent "annoying" update message
+    # on each command call
+    return unless Gem.configuration.state_file_writable?
+
+    # load time of last check, ensure the difference is enough to repeat the suggestion
+    check_time = Time.now.to_i
+    last_update_check = Gem.configuration.last_update_check
+    return false if (check_time - last_update_check) < ONE_WEEK
+
+    # compare current and latest version, this is the part where
+    # latest rubygems spec is fetched from remote
+    (Gem.rubygems_version < Gem.latest_rubygems_version).tap do |eligible|
+      # store the time of last successful check into state file
+      Gem.configuration.last_update_check = check_time
+
+      return eligible
+    end
+  rescue StandardError # don't block install command on any problem
+    false
+  end
+end

data/lib/rubygems/uri.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+##
+# The Uri handles rubygems source URIs.
+#
+
+class Gem::Uri
+  ##
+  # Parses and redacts uri
+
+  def self.redact(uri)
+    new(uri).redacted
+  end
+
+  ##
+  # Parses uri, raising if it's invalid
+
+  def self.parse!(uri)
+    require "uri"
+
+    raise URI::InvalidURIError unless uri
+
+    return uri unless uri.is_a?(String)
+
+    # Always escape URI's to deal with potential spaces and such
+    # It should also be considered that source_uri may already be
+    # a valid URI with escaped characters. e.g. "{DESede}" is encoded
+    # as "%7BDESede%7D". If this is escaped again the percentage
+    # symbols will be escaped.
+    begin
+      URI.parse(uri)
+    rescue URI::InvalidURIError
+      URI.parse(URI::DEFAULT_PARSER.escape(uri))
+    end
+  end
+
+  ##
+  # Parses uri, returning the original uri if it's invalid
+
+  def self.parse(uri)
+    parse!(uri)
+  rescue URI::InvalidURIError
+    uri
+  end
+
+  def initialize(source_uri)
+    @parsed_uri = parse(source_uri)
+  end
+
+  def redacted
+    return self unless valid_uri?
+
+    if token? || oauth_basic?
+      with_redacted_user
+    elsif password?
+      with_redacted_password
+    else
+      self
+    end
+  end
+
+  def to_s
+    @parsed_uri.to_s
+  end
+
+  def redact_credentials_from(text)
+    return text unless valid_uri? && password? && text.include?(to_s)
+
+    text.sub(password, "REDACTED")
+  end
+
+  def method_missing(method_name, *args, &blk)
+    if @parsed_uri.respond_to?(method_name)
+      @parsed_uri.send(method_name, *args, &blk)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @parsed_uri.respond_to?(method_name, include_private) || super
+  end
+
+  protected
+
+  # Add a protected reader for the cloned instance to access the original object's parsed uri
+  attr_reader :parsed_uri
+
+  private
+
+  def parse!(uri)
+    self.class.parse!(uri)
+  end
+
+  def parse(uri)
+    self.class.parse(uri)
+  end
+
+  def with_redacted_user
+    clone.tap {|uri| uri.user = "REDACTED" }
+  end
+
+  def with_redacted_password
+    clone.tap {|uri| uri.password = "REDACTED" }
+  end
+
+  def valid_uri?
+    !@parsed_uri.is_a?(String)
+  end
+
+  def password?
+    !!password
+  end
+
+  def oauth_basic?
+    password == "x-oauth-basic"
+  end
+
+  def token?
+    !user.nil? && password.nil?
+  end
+
+  def initialize_copy(original)
+    @parsed_uri = original.parsed_uri.clone
+  end
+end

data/lib/rubygems/uri_formatter.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
-require 'cgi'
-require 'uri'
 
 ##
 # The UriFormatter handles URIs from user-input and escaping.
@@ -10,7 +8,6 @@ require 'uri'
 #   p uf.normalize #=> 'http://example.com'
 
 class Gem::UriFormatter
-
   ##
   # The URI to be formatted.
 
@@ -19,7 +16,9 @@ class Gem::UriFormatter
   ##
   # Creates a new URI formatter for +uri+.
 
-  def initialize uri
+  def initialize(uri)
+    require "cgi"
+
     @uri = uri
   end
 
@@ -35,7 +34,7 @@ class Gem::UriFormatter
   # Normalize the URI by adding "http://" if it is missing.
 
   def normalize
-    (@uri =~ /^(https?|ftp|file):/i) ? @uri : "http://#{@uri}"
+    /^(https?|ftp|file):/i.match?(@uri) ? @uri : "http://#{@uri}"
   end
 
   ##
@@ -45,6 +44,4 @@ class Gem::UriFormatter
     return unless @uri
     CGI.unescape @uri
   end
-
 end
-