rubygems-update 4.0.21 → 4.1.0.beta1

data/lib/rubygems/credential_store.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+# Skip reloading when an identical copy (e.g. the one shipped inside the Bundler
+# gem) was already required from a different path, to avoid redefinition warnings.
+return if defined?(Gem::CredentialStore::SERVICE_NAME)
+
+##
+# Gem::CredentialStore is opt-in storage for authentication secrets (API
+# keys, host credentials) in the operating system's native secret store
+# instead of a plain text file:
+#
+# * macOS: Keychain, via the +security+ command line tool.
+# * Linux: the Secret Service API (GNOME Keyring, KWallet, ...), via
+#   +secret-tool+.
+# * Windows: Credential Manager, via the +Windows.Security.Credentials.PasswordVault+
+#   API from PowerShell.
+#
+# A third party can add another backend (1Password, pass, HashiCorp Vault,
+# ...) by shipping a gem that provides
+# <tt>rubygems/credential_store/backends/<name></tt> and calls
+# .register_backend from it. Users then select it by name instead of +true+
+# (see .resolve_backend).
+#
+# Every public method traps all errors and returns +nil+/+false+ instead of
+# raising, so that callers can transparently fall back to their existing
+# file-based storage when the native store is unavailable or fails (a
+# locked keychain over SSH, a headless Linux session without a keyring
+# daemon, ...).
+
+class Gem::CredentialStore
+  SERVICE_NAME = "rubygems"
+
+  ##
+  # Returns the store to use for +spec+, or +nil+ when the credential store
+  # is off. +spec+ is either +true+ (use this platform's native backend) or
+  # the name of a registered backend such as "1password". +service+ names
+  # the account namespace within the backend, so RubyGems and Bundler keep
+  # separate credentials in one native store. The store is memoized per
+  # +spec+ and +service+ for the life of the process, so the read cache and
+  # any expensive backend startup are shared across callers. A test may
+  # install a stand-in via #instance= that is returned here for any enabled
+  # +spec+, or inject a shared backend via #backend=.
+
+  def self.for(spec, service: SERVICE_NAME)
+    return nil unless spec
+    return @override if defined?(@override) && @override
+
+    backend = defined?(@override_backend) && @override_backend ? @override_backend : backend_for(spec)
+    (@instances ||= {})[[spec, service]] ||= new(backend: backend, service: service)
+  end
+
+  ##
+  # The default-backed store for this platform, i.e. <tt>for(true)</tt>.
+  # Kept for callers and tests that only care about the native backend.
+
+  def self.instance
+    self.for(true)
+  end
+
+  ##
+  # Installs a stand-in store that .for returns for any enabled setting.
+  # Intended for tests that inject a fake backend.
+
+  def self.instance=(store)
+    @override = store
+  end
+
+  ##
+  # Installs a shared backend that .for wraps for every spec and service.
+  # Intended for tests that need RubyGems and Bundler credentials to land in
+  # one backend under their own service names.
+
+  def self.backend=(backend)
+    @override_backend = backend
+  end
+
+  ##
+  # Clears the memoized stores, the injected overrides, and the warned
+  # messages. Intended for tests only.
+
+  def self.reset!
+    @override = nil
+    @override_backend = nil
+    @instances = nil
+    @warned = nil
+    @warn_handler = nil
+  end
+
+  ##
+  # Warns once per distinct message. A single flag for every message would
+  # let an early warning about, say, a misspelled backend name suppress the
+  # later warning that a secret was written in plain text.
+
+  def self.warn_once(message)
+    @warned ||= {}
+    return if @warned.key?(message)
+
+    @warned[message] = true
+
+    if defined?(@warn_handler) && @warn_handler
+      @warn_handler.call(message)
+    else
+      Gem.ui.alert_warning message
+    end
+  end
+
+  ##
+  # Sends warnings to +handler+ (anything responding to #call) instead of
+  # Gem.ui. Bundler sets this because it replaces Gem.ui with a subclass of
+  # Gem::SilentUI, which discards alert_warning entirely, so a credential
+  # store failure would otherwise be silent for the whole bundle command.
+
+  def self.warn_handler=(handler)
+    @warn_handler = handler
+  end
+
+  ##
+  # Registers +backend+ under +name+ so it can be selected with
+  # <tt>credential_store = <name></tt>. A third-party backend gem calls this
+  # from the file RubyGems loads for that name (see .resolve_backend).
+
+  def self.register_backend(name, backend)
+    (@backends ||= {})[name.to_s] = backend
+  end
+
+  BACKEND_NAME = /\A[a-z0-9_-]+\z/
+
+  ##
+  # Resolves a registered backend by +name+, requiring
+  # <tt>rubygems/credential_store/backends/<name></tt> on first use so a
+  # backend shipped as its own gem loads only when actually selected.
+  # Returns +nil+ (warning once) when the name is malformed or no gem
+  # provides it, which makes callers fall back to file storage. The fixed
+  # require prefix and the restricted name charset keep the setting a piece
+  # of data, never a path or a command.
+
+  def self.resolve_backend(name)
+    # The setting can carry bytes Regexp#match? would reject. A name that gets
+    # past the match is ASCII only, so the require path it builds stays sound.
+    name = name.to_s.b
+    unless BACKEND_NAME.match?(name)
+      warn_once "Ignoring invalid credential store backend name #{name.inspect}."
+      return nil
+    end
+
+    return @backends[name] if @backends&.key?(name)
+
+    begin
+      require "rubygems/credential_store/backends/#{name}"
+    rescue LoadError
+      warn_once "Credential store backend #{name.inspect} is not installed. " \
+                "Install a gem that provides rubygems/credential_store/backends/#{name}, " \
+                "or unset the credential_store setting. Falling back to file storage."
+      return nil
+    end
+
+    @backends && @backends[name]
+  end
+
+  def self.backend_for(spec)
+    spec == true ? default_backend : resolve_backend(spec)
+  end
+  private_class_method :backend_for
+
+  def self.default_backend
+    if Gem.win_platform?
+      require_relative "credential_store/native/windows"
+      WindowsBackend
+    elsif RUBY_PLATFORM.include?("darwin")
+      require_relative "credential_store/native/macos"
+      MacOSBackend
+    elsif RUBY_PLATFORM.include?("linux")
+      require_relative "credential_store/native/linux"
+      LinuxBackend if LinuxBackend.available?
+    end
+  end
+
+  ##
+  # +backend+ is only used by tests to inject a fake backend regardless of
+  # the platform the test suite happens to run on. +service+ is the account
+  # namespace this store reads and writes under.
+
+  def initialize(backend: self.class.default_backend, service: SERVICE_NAME)
+    @backend = backend
+    @service = service
+    @cache = {}
+  end
+
+  ##
+  # True if a native credential backend is usable on this platform.
+
+  def available?
+    !@backend.nil?
+  end
+
+  ##
+  # Returns the secret stored for +account+, or +nil+ if there is none or
+  # the backend is unavailable/fails.
+
+  def get(account)
+    return nil unless @backend
+    return @cache[account] if @cache.key?(account)
+
+    @cache[account] = @backend.get(@service, account)
+  rescue StandardError => e
+    warn_failure(:read, e)
+    # Retrying means another subprocess and, on some platforms, another
+    # authorization prompt. #read_failed? keeps this apart from an absent one.
+    (@failed ||= {})[account] = true
+    @cache[account] = nil
+  end
+
+  ##
+  # True when #get returned +nil+ for +account+ because the backend could not
+  # answer, rather than because nothing is stored under it. Callers that would
+  # otherwise fall back to a different credential need the difference: a
+  # missing entry means "use something else", an unreadable one does not.
+
+  def read_failed?(account)
+    return false unless defined?(@failed) && @failed
+
+    @failed.key?(account)
+  end
+
+  ##
+  # Stores +secret+ for +account+. Returns +true+ on success.
+
+  def set(account, secret)
+    return false unless @backend
+
+    validate_credential(account, secret)
+
+    if @backend.set(@service, account, secret)
+      @cache[account] = secret
+      @failed&.delete(account)
+      invalidate_list
+      true
+    else
+      false
+    end
+  rescue StandardError => e
+    warn_failure(:write, e)
+    false
+  end
+
+  ##
+  # Removes the secret stored for +account+. Returns +true+ if the entry is
+  # gone, whether or not it existed beforehand.
+
+  def delete(account)
+    return false unless @backend
+
+    result = @backend.delete(@service, account)
+    @cache.delete(account)
+    @failed&.delete(account)
+    invalidate_list
+    result
+  rescue StandardError => e
+    warn_failure(:remove, e)
+    false
+  end
+
+  ##
+  # The accounts this store holds, or +nil+ when the backend cannot
+  # enumerate them. Listing is optional in the backend protocol: the native
+  # backends implement it, but a third-party backend that only resolves
+  # credentials on demand has nothing to enumerate. Callers must treat +nil+
+  # as "unknown", not as "empty". Secrets are never returned.
+
+  def list
+    return nil unless @backend.respond_to?(:list)
+    return @list if defined?(@list)
+
+    @list = @backend.list(@service)
+  rescue StandardError => e
+    warn_failure(:list, e)
+    # Remembered for the same reason #get remembers a failed read.
+    @list = nil
+  end
+
+  ##
+  # Removes every entry this store owns (all accounts under its service).
+  # Returns +true+ when the store is now clear. Used by +gem signout+ to end
+  # every session at once, mirroring deletion of the whole credentials file.
+
+  def delete_all
+    return false unless @backend
+
+    result = @backend.delete_all(@service)
+    @cache.clear
+    @failed = nil
+    invalidate_list
+    result
+  rescue StandardError => e
+    warn_failure(:remove, e)
+    false
+  end
+
+  private
+
+  # The listing is memoized, so a write has to drop it.
+  def invalidate_list
+    remove_instance_variable(:@list) if defined?(@list)
+  end
+
+  # The macOS keychain hands non-printable bytes back as hex through the only
+  # read-back its CLI offers. Applied to every backend so the same value is
+  # stored, or refused for the same reason, everywhere.
+  PRINTABLE_ASCII = /\A[\x20-\x7e]*\z/
+
+  # What happens after a failure depends on the operation, so the warning has
+  # to say the right thing for each.
+  OUTCOMES = {
+    read: "any copy left in the config file will be used instead",
+    write: "falling back to file storage",
+    remove: "the credential is still in the store",
+    list: "stored credentials will not be listed",
+  }.freeze
+
+  # A newline in an account would start a second command in the macOS batch
+  # input. #set turns the raise back into a warning and a false.
+  def validate_credential(account, secret)
+    raise ArgumentError, "credential secret must be printable ASCII" unless secret.to_s.b.match?(PRINTABLE_ASCII)
+    raise ArgumentError, "credential account must not contain a newline" if account.to_s.include?("\n")
+    raise ArgumentError, "credential service must not contain a newline" if @service.to_s.include?("\n")
+  end
+
+  def warn_failure(operation, error)
+    self.class.warn_once "Credential store #{operation} failed for #{@service}" \
+                         " (#{error.class}: #{error.message}); #{OUTCOMES[operation]}."
+  end
+end

data/lib/rubygems/defaults.rb

@@ -148,6 +148,15 @@ module Gem
     @cache_home ||= ENV["XDG_CACHE_HOME"] || File.join(Gem.user_home, ".cache")
   end
 
+  ##
+  # The path to the global gem cache directory.
+  # This is used when global_gem_cache is enabled to share .gem files
+  # across all Ruby installations.
+
+  def self.global_gem_cache_path
+    File.join(cache_home, "gem", "gems")
+  end
+
   ##
   # The path to standard location of the user's data directory.
 

data/lib/rubygems/dependency_installer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../rubygems"
+require_relative "cooldown"
 require_relative "dependency_list"
 require_relative "package"
 require_relative "installer"
@@ -43,6 +44,12 @@ class Gem::DependencyInstaller
 
   attr_reader :installed_gems
 
+  ##
+  # Per-gem summary entries for the newest versions the cooldown kept out
+  # of the last resolution.  See Gem::Cooldown.output_skipped_summary.
+
+  attr_reader :cooldown_skipped
+
   ##
   # Creates a new installer instance.
   #
@@ -88,6 +95,10 @@ class Gem::DependencyInstaller
     @dir_mode = options[:dir_mode]
     @data_mode = options[:data_mode]
     @prog_mode = options[:prog_mode]
+    @build_extension = options[:build_extension]
+    @install_plugin = options[:install_plugin]
+    @cooldown = Gem::Cooldown.from_options options
+    @cooldown_skipped = []
 
     # Indicates that we should not try to update any deps unless
     # we absolutely must.
@@ -169,6 +180,8 @@ class Gem::DependencyInstaller
       dir_mode: @dir_mode,
       data_mode: @data_mode,
       prog_mode: @prog_mode,
+      build_extension: @build_extension,
+      install_plugin: @install_plugin,
     }
     options[:install_dir] = @install_dir if @only_install_dir
 
@@ -206,6 +219,7 @@ class Gem::DependencyInstaller
     request_set.development_shallow = @dev_shallow
     request_set.soft_missing = @force
     request_set.prerelease = @prerelease
+    request_set.cooldown = @cooldown
 
     installer_set = Gem::Resolver::InstallerSet.new @domain
     installer_set.ignore_installed = (@minimal_deps == false) || @only_install_dir
@@ -254,6 +268,7 @@ class Gem::DependencyInstaller
     request_set.resolve installer_set
 
     @errors.concat request_set.errors
+    @cooldown_skipped = request_set.resolver&.cooldown_skipped || []
 
     request_set
   end

data/lib/rubygems/doctor.rb

@@ -21,7 +21,7 @@ class Gem::Doctor
 
   REPOSITORY_EXTENSION_MAP = [ # :nodoc:
     ["specifications", ".gemspec"],
-    ["build_info",     ".info"],
+    ["build_info",     ".info", ".mkmf.log", ".gem_make.out"],
     ["cache",          ".gem"],
     ["doc",            ""],
     ["extensions",     ""],
@@ -92,15 +92,15 @@ class Gem::Doctor
   # Cleans up children of this gem repository
 
   def doctor_children # :nodoc:
-    REPOSITORY_EXTENSION_MAP.each do |sub_directory, extension|
-      doctor_child sub_directory, extension
+    REPOSITORY_EXTENSION_MAP.each do |sub_directory, *extensions|
+      doctor_child sub_directory, *extensions
     end
   end
 
   ##
-  # Removes files in +sub_directory+ with +extension+
+  # Removes files in +sub_directory+ with any of +extensions+
 
-  def doctor_child(sub_directory, extension) # :nodoc:
+  def doctor_child(sub_directory, *extensions) # :nodoc:
     directory = File.join(@gem_repository, sub_directory)
 
     Dir.entries(directory).sort.each do |ent|
@@ -109,12 +109,18 @@ class Gem::Doctor
       child = File.join(directory, ent)
       next unless File.exist?(child)
 
-      basename = File.basename(child, extension)
+      basename = strip_extension File.basename(child), extensions
       next if installed_specs.include? basename
       next if /^rubygems-\d/.match?(basename)
       next if sub_directory == "specifications" && basename == "default"
       next if sub_directory == "plugins" && Gem.plugin_suffix_regexp =~ basename
 
+      if sub_directory == "specifications" && File.directory?(child) &&
+         Gem::ContentAddress.valid_ruby_abi?(ent)
+        doctor_child(File.join(sub_directory, ent), *extensions) if ent == Gem.ruby_abi && !File.symlink?(child)
+        next
+      end
+
       type = File.directory?(child) ? "directory" : "file"
 
       action = if @dry_run
@@ -129,4 +135,15 @@ class Gem::Doctor
   rescue Errno::ENOENT
     # ignore
   end
+
+  ##
+  # Removes the first of +extensions+ that +name+ ends with
+
+  def strip_extension(name, extensions) # :nodoc:
+    extension = extensions.find do |ext|
+      !ext.empty? && name.end_with?(ext)
+    end
+
+    extension ? name.delete_suffix(extension) : name
+  end
 end

data/lib/rubygems/exceptions.rb

@@ -33,22 +33,24 @@ class Gem::DependencyError < Gem::Exception; end
 class Gem::DependencyRemovalException < Gem::Exception; end
 
 ##
-# Raised by Gem::Resolver when a Gem::Dependency::Conflict reaches the
-# toplevel.  Indicates which dependencies were incompatible through #conflict
-# and #conflicting_dependencies
+# Raised by Gem::Resolver when dependency resolution fails.
 
 class Gem::DependencyResolutionError < Gem::DependencyError
-  attr_reader :conflict
-
   def initialize(conflict)
-    @conflict = conflict
-    a, b = conflicting_dependencies
+    @explanation = conflict.explanation
+    super @explanation
+  end
 
-    super "conflicting dependencies #{a} and #{b}\n#{@conflict.explanation}"
+  def explanation
+    @explanation
+  end
+
+  def conflict
+    nil
   end
 
   def conflicting_dependencies
-    @conflict.conflicting_dependencies
+    []
   end
 end
 
@@ -126,40 +128,6 @@ end
 
 Gem.deprecate_constant :SpecificGemNotFoundException
 
-##
-# Raised by Gem::Resolver when dependencies conflict and create the
-# inability to find a valid possible spec for a request.
-
-class Gem::ImpossibleDependenciesError < Gem::Exception
-  attr_reader :conflicts
-  attr_reader :request
-
-  def initialize(request, conflicts)
-    @request   = request
-    @conflicts = conflicts
-
-    super build_message
-  end
-
-  def build_message # :nodoc:
-    requester  = @request.requester
-    requester  = requester ? requester.spec.full_name : "The user"
-    dependency = @request.dependency
-
-    message = "#{requester} requires #{dependency} but it conflicted:\n".dup
-
-    @conflicts.each do |_, conflict|
-      message << conflict.explanation
-    end
-
-    message
-  end
-
-  def dependency
-    @request.dependency
-  end
-end
-
 class Gem::InstallError < Gem::Exception; end
 
 class Gem::RuntimeRequirementNotMetError < Gem::InstallError

data/lib/rubygems/ext/builder.rb

@@ -220,9 +220,11 @@ ERROR: Failed to build gem native extension.
     #{output}
 
 Gem files will remain installed in #{@gem_dir} for inspection.
-Results logged to #{gem_make_out}
 EOF
 
+    # Losing the log must not cost the user the build error itself.
+    message += "Results logged to #{gem_make_out}\n" if gem_make_out
+
     raise Gem::Ext::BuildError, message, backtrace
   end
 
@@ -243,13 +245,72 @@ EOF
 
       verbose { results.join("\n") }
 
-      write_gem_make_out results.join "\n"
+      # Build logs are noisy, non-reproducible artifacts that are not meant to
+      # be installed. Drop the ones this build left behind, plus any written
+      # into the extension directory by a RubyGems old enough to put them there.
+      FileUtils.rm_f mkmf_log_candidates(extension_dir, dest_path)
+      FileUtils.rm_f File.join(dest_path, "gem_make.out")
+      FileUtils.rm_f [build_log_path("mkmf.log"), build_log_path("gem_make.out")]
+    rescue Gem::Ext::Builder::NoMakefileError => e
+      # extconf ran fine but produced no Makefile, so the extension was skipped
+      # rather than built and installing carries on. Keep the log that says why
+      # it was skipped, out of the installation tree but still reachable.
+      results << e.message
+      results << "Skipping make for #{extension} as no Makefile was found."
+
+      verbose { results.join("\n") }
+
+      preserve_mkmf_log extension_dir, dest_path
+      write_gem_make_out results.join("\n")
     rescue StandardError => e
       results << e.message
+
+      mkmf_log_dest = preserve_mkmf_log(extension_dir, dest_path)
+      if mkmf_log_dest
+        results << "To see why this extension failed to compile, please check the mkmf.log which can be found here:"
+        results << "  #{mkmf_log_dest}"
+      end
+
       build_error(results.join("\n"), $@)
     end
   end
 
+  ##
+  # Where a build log of +kind+ for this gem lives in the build_info directory.
+
+  def build_log_path(kind) # :nodoc:
+    File.join @spec.build_info_dir, "#{@spec.full_name}.#{kind}"
+  end
+
+  ##
+  # Moves the mkmf.log this build left behind into the build_info directory and
+  # returns its new path, or nil when there is none or it cannot be kept.
+  # Keeping a log must never replace the build error the caller is reporting,
+  # so a filesystem failure here is swallowed.
+
+  def preserve_mkmf_log(extension_dir, dest_path) # :nodoc:
+    mkmf_log = mkmf_log_candidates(extension_dir, dest_path).find {|log| File.exist?(log) }
+    return unless mkmf_log
+
+    destination = build_log_path "mkmf.log"
+
+    FileUtils.mkdir_p @spec.build_info_dir
+    FileUtils.mv mkmf_log, destination
+
+    destination
+  rescue SystemCallError
+    nil
+  end
+
+  ##
+  # Places a completed build may have left an mkmf.log, most specific first.
+  # Gem::Ext::ExtConfBuilder parks it in +dest_path+ so that the "clean" target
+  # cannot delete it; the other builders leave it where extconf ran.
+
+  def mkmf_log_candidates(extension_dir, dest_path) # :nodoc:
+    [File.join(dest_path, "mkmf.log"), File.join(extension_dir, "mkmf.log")]
+  end
+
   ##
   # Builds extensions.  Valid types of extensions are extconf.rb files,
   # configure scripts and rakefiles or mkrf_conf files.
@@ -277,17 +338,21 @@ EOF
   end
 
   ##
-  # Writes +output+ to gem_make.out in the extension install directory.
+  # Writes +output+ to gem_make.out in the build_info directory and returns its
+  # path, or nil when it cannot be written. Only called when the extension was
+  # not built, to keep build logs out of the installation tree.
 
   def write_gem_make_out(output) # :nodoc:
-    destination = File.join @spec.extension_dir, "gem_make.out"
+    destination = build_log_path "gem_make.out"
 
-    FileUtils.mkdir_p @spec.extension_dir
+    FileUtils.mkdir_p @spec.build_info_dir
 
     File.open destination, "wb" do |io|
       io.puts output
     end
 
     destination
+  rescue SystemCallError
+    nil
   end
 end

data/lib/rubygems/ext/cargo_builder.rb

@@ -269,10 +269,6 @@ EOF
     LinkFlagConverter.convert(arg)
   end
 
-  def msvc_target?
-    makefile_config("target_os").include?("msvc")
-  end
-
   def darwin_target?
     makefile_config("target_os").include?("darwin")
   end
@@ -281,11 +277,6 @@ EOF
     makefile_config("target_os").include?("mingw")
   end
 
-  def win_target?
-    target_platform = RbConfig::CONFIG["target_os"]
-    !!Gem::WIN_PATTERNS.find {|r| target_platform =~ r }
-  end
-
   # Interpolate substitution vars in the arg (i.e. $(DEFFILE))
   def maybe_resolve_ldflag_variable(input_arg, dest_dir, crate_name)
     var_matches = input_arg.match(/\$\((\w+)\)/)