bundler 4.0.21 → 4.1.0.beta1

data/lib/rubygems/compact_index_client.rb

@@ -0,0 +1,111 @@
+# 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::CompactIndexClient::INFO_REQS)
+
+##
+# The CompactIndexClient fetches and parses the compact index files
+# (names, versions and info/[gem]) served by a gem server, keeping a
+# local cache so subsequent fetches only transfer what changed.
+#
+# This is the single shared client: Bundler ships a copy of it and uses
+# it underneath its own fetcher orchestration, injecting its fetcher and
+# filesystem access hook.
+
+class Gem::CompactIndexClient
+  SUPPORTED_DIGESTS = { "sha-256" => :SHA256 }.freeze
+  DEBUG_MUTEX = Thread::Mutex.new
+
+  # info returns an Array of INFO Arrays. Each INFO Array has the following indices:
+  INFO_NAME = 0
+  INFO_VERSION = 1
+  INFO_SUFFIX = 2
+  INFO_DEPS = 3
+  INFO_REQS = 4
+
+  INFO_PLATFORM = INFO_SUFFIX
+  deprecate_constant :INFO_PLATFORM
+
+  def self.debug
+    return unless ENV["DEBUG_COMPACT_INDEX"]
+    DEBUG_MUTEX.synchronize { warn("[#{self}] #{yield}") }
+  end
+
+  class Error < StandardError; end
+
+  # Filesystem reads and writes funnel through this hook so that a host
+  # (e.g. Bundler) can translate low-level Errno exceptions into its own
+  # friendlier errors. The default just yields the path.
+  def self.filesystem_access(path, action = :write, &block)
+    if @filesystem_access
+      @filesystem_access.call(path, action, &block)
+    else
+      yield path
+    end
+  end
+
+  def self.filesystem_access=(hook)
+    @filesystem_access = hook
+  end
+
+  require_relative "compact_index_client/cache"
+  require_relative "compact_index_client/cache_file"
+  require_relative "compact_index_client/http_fetcher"
+  require_relative "compact_index_client/parser"
+  require_relative "compact_index_client/updater"
+
+  # The client is instantiated with:
+  # - `directory`: the root directory where the cache files are stored.
+  # - `fetcher`: (optional) an object that responds to #call(uri_path, headers)
+  #   and returns a Gem::Net::HTTP response. When the fetcher is not provided,
+  #   the client only reads cached files from disk.
+  def initialize(directory, fetcher = nil)
+    @cache = Cache.new(directory, fetcher)
+    @parser = Parser.new(@cache)
+  end
+
+  def names
+    Gem::CompactIndexClient.debug { "names" }
+    @parser.names
+  end
+
+  def versions
+    Gem::CompactIndexClient.debug { "versions" }
+    @parser.versions
+  end
+
+  def dependencies(names)
+    Gem::CompactIndexClient.debug { "dependencies(#{names})" }
+    names.map {|name| info(name) }
+  end
+
+  def info(name)
+    Gem::CompactIndexClient.debug { "info(#{name})" }
+    @parser.info(name)
+  end
+
+  # Fetches a single gem's info without consulting the versions index,
+  # using a conditional request to refresh the cached file. Useful when
+  # only a few gems are needed and the versions index download would
+  # dominate, as in gem install.
+  def fetch_info(name)
+    Gem::CompactIndexClient.debug { "fetch_info(#{name})" }
+    @parser.parse_info(@cache.fetch_info(name), name)
+  end
+
+  def latest_version(name)
+    Gem::CompactIndexClient.debug { "latest_version(#{name})" }
+    @parser.info(name).map {|d| Gem::Version.new(d[INFO_VERSION]) }.max
+  end
+
+  def available?
+    Gem::CompactIndexClient.debug { "available?" }
+    @parser.available?
+  end
+
+  def reset!
+    Gem::CompactIndexClient.debug { "reset!" }
+    @cache.reset!
+  end
+end

data/lib/rubygems/cooldown_settings.rb

@@ -0,0 +1,57 @@
+# 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::CooldownSettings)
+
+##
+# The rules RubyGems and Bundler share for reading a configured cooldown
+# period.  Bundler ships a copy of this file, so it deliberately has no
+# requires: none of the rest of RubyGems is guaranteed to be around it.
+
+module Gem::CooldownSettings
+  ##
+  # +value+ read as a number of days, or nil when it is absent or cannot be
+  # read as a non-negative integer.  A gemrc entry and a Bundler config entry
+  # are both arbitrary YAML, so either can be any type at all.
+
+  def self.days(value)
+    return if value.nil?
+
+    # Base 10 explicitly: a leading zero is how a user writes a small number
+    # of days, not a request for octal.
+    days = Integer(value.to_s, 10, exception: false)
+
+    days if days && !days.negative?
+  end
+
+  ##
+  # True when +value+ is configured but cannot be read as a number of days.
+
+  def self.invalid?(value)
+    !value.nil? && days(value).nil?
+  end
+
+  ##
+  # The cooldown that applies when RubyGems and Bundler are configured
+  # separately: the longest of +values+, so a cooldown configured for only
+  # one of the two tools protects both.  Returns nil when none of them is
+  # usable.
+  #
+  # A configured 0 takes part like any other value rather than switching the
+  # cooldown off, which leaves <tt>--cooldown 0</tt> as the way to bypass a
+  # cooldown that the other tool configures.
+
+  def self.combine(*values)
+    values.filter_map {|value| days(value) }.max
+  end
+
+  # +source+ names where the value came from, since RubyGems and Bundler now
+  # each read the other's setting and the same complaint from either of them
+  # is otherwise impossible to trace back to a file.
+
+  def self.invalid_message(value, source) # :nodoc:
+    "Invalid cooldown value #{value.inspect} in #{source}, so it is ignored. " \
+      "Expected a non-negative integer number of days."
+  end
+end

data/lib/rubygems/credential_store/native/linux.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "open3"
+
+class Gem::CredentialStore; end unless defined?(Gem::CredentialStore)
+
+##
+# Stores credentials in the Secret Service API (GNOME Keyring, KWallet,
+# ...) via the +secret-tool+ command line tool from libsecret.
+
+class Gem::CredentialStore::LinuxBackend
+  # secret-tool prints an item's attributes to stderr, one per line.
+  ACCOUNT_ATTRIBUTE = /^attribute\.account = (.*)$/
+  def self.available?
+    return @available if defined?(@available)
+
+    @available = ENV["PATH"].to_s.split(File::PATH_SEPARATOR).any? do |dir|
+      File.executable?(File.join(dir, "secret-tool"))
+    end
+  end
+
+  ##
+  # Clears the memoized #available? result. Intended for tests only.
+
+  def self.reset!
+    remove_instance_variable(:@available) if defined?(@available)
+  end
+
+  def self.get(service, account)
+    out, err, status = Open3.capture3(
+      "secret-tool", "lookup", "service", service, "account", account
+    )
+    # secret-tool exits 1 with nothing on stderr when the entry is simply
+    # absent. Anything else is a real failure.
+    unless status.success?
+      return nil if status.exitstatus == 1 && err.to_s.strip.empty?
+
+      raise "secret-tool exited with #{status.exitstatus}: #{err.strip}"
+    end
+
+    secret = out.chomp
+    secret.empty? ? nil : secret
+  end
+
+  def self.set(service, account, secret)
+    _out, status = Open3.capture2(
+      "secret-tool", "store", "--label=RubyGems", "service", service, "account", account,
+      stdin_data: secret
+    )
+    status.success?
+  end
+
+  # secret-tool writes attributes to stderr and secrets to stdout, so accounts
+  # are read from stderr. Discarding stdout also keeps a secret containing a
+  # newline from being mistaken for an attribute line.
+  def self.list(service)
+    _out, err, status = Open3.capture3(
+      "secret-tool", "search", "--all", "service", service
+    )
+    return [] unless status.success?
+
+    err.scan(ACCOUNT_ATTRIBUTE).flatten.uniq
+  end
+
+  def self.delete(service, account)
+    _out, err, status = Open3.capture3(
+      "secret-tool", "clear", "service", service, "account", account
+    )
+    return cleared?(service, account) if status.success?
+
+    # secret-tool clear exits 1 with no stderr when nothing matched.
+    status.exitstatus == 1 && err.to_s.strip.empty?
+  end
+
+  def self.delete_all(service)
+    _out, err, status = Open3.capture3(
+      "secret-tool", "clear", "service", service
+    )
+    return cleared?(service) if status.success?
+
+    status.exitstatus == 1 && err.to_s.strip.empty?
+  end
+
+  # libsecret clears only unlocked items and reports no error for the ones it
+  # skipped, so a locked keyring answers a clear with success while keeping
+  # every secret. search exits zero either way, so its output is the answer.
+  def self.cleared?(service, account = nil)
+    _out, err, status = Open3.capture3(
+      "secret-tool", "search", "--all", "service", service
+    )
+    return false unless status.success?
+
+    remaining = err.scan(ACCOUNT_ATTRIBUTE).flatten
+    account ? !remaining.include?(account) : remaining.empty?
+  end
+  private_class_method :cleared?
+end

data/lib/rubygems/credential_store/native/macos.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "open3"
+
+class Gem::CredentialStore; end unless defined?(Gem::CredentialStore)
+
+##
+# Stores credentials in the macOS Keychain via the +security+ command line
+# tool. +security+ has no way to read a password from stdin as raw bytes
+# for +add-generic-password+, so #set uses +security -i+ (batch/interactive
+# mode, one tokenized command per stdin line) to keep the secret off argv
+# and out of +ps+ output.
+#
+# A newline would start a second command in the +security -i+ batch, and
+# +security find-generic-password -w+ prints any non-printable byte back as a
+# hex string rather than the original value, so a non-ASCII secret would
+# round-trip corrupted. Those are the limits Gem::CredentialStore#set enforces
+# for every backend, so the caller falls back to file storage rather than
+# storing something that cannot be read back.
+
+class Gem::CredentialStore::MacOSBackend
+  NOT_FOUND_STATUS = 44
+
+  def self.get(service, account)
+    out, err, status = Open3.capture3(
+      "security", "find-generic-password", "-a", account, "-s", service, "-w"
+    )
+    # A locked keychain and an absent entry both yield no secret, but only the
+    # second one is ordinary.
+    unless status.success?
+      return nil if status.exitstatus == NOT_FOUND_STATUS
+
+      raise "security exited with #{status.exitstatus}: #{err.strip}"
+    end
+
+    secret = out.chomp
+    secret.empty? ? nil : secret
+  end
+
+  def self.set(service, account, secret)
+    command = "add-generic-password -U -a #{quote(account)} -s #{quote(service)} -w #{quote(secret)}\n"
+    _out, err, status = Open3.capture3("security", "-i", stdin_data: command)
+    return true if status.success?
+
+    # Raise rather than return false so the reason reaches the user. The
+    # wrapper turns it back into false after reporting it.
+    raise "security exited with #{status.exitstatus}: #{err.strip}"
+  end
+
+  # security has no "list by service" subcommand, so this reads the dump, which
+  # never reports the secrets.
+  def self.list(service)
+    out, status = Open3.capture2("security", "dump-keychain", err: File::NULL)
+    return [] unless status.success?
+
+    out.split(/^keychain: /).filter_map do |entry|
+      next unless entry[/^\s*"svce"<blob>="(.*)"$/, 1] == service
+
+      entry[/^\s*"acct"<blob>="(.*)"$/, 1]
+    end.uniq
+  end
+
+  def self.delete(service, account)
+    _out, status = Open3.capture2(
+      "security", "delete-generic-password", "-a", account, "-s", service,
+      err: File::NULL
+    )
+    status.success? || status.exitstatus == NOT_FOUND_STATUS
+  end
+
+  # security deletes one entry per call, so keep going until it reports there
+  # is nothing left (exit 44). Other services are untouched.
+  def self.delete_all(service)
+    loop do
+      _out, status = Open3.capture2(
+        "security", "delete-generic-password", "-s", service,
+        err: File::NULL
+      )
+      return true if status.exitstatus == NOT_FOUND_STATUS
+      return false unless status.success?
+    end
+  end
+
+  def self.quote(value)
+    %("#{value.gsub("\\", "\\\\\\\\").gsub('"', '\\"')}")
+  end
+  private_class_method :quote
+end

data/lib/rubygems/credential_store/native/windows.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "open3"
+
+class Gem::CredentialStore; end unless defined?(Gem::CredentialStore)
+
+##
+# Stores credentials in the Windows Credential Manager via the
+# +Windows.Security.Credentials.PasswordVault+ WinRT API, driven from
+# PowerShell. Account/service/secret values are passed as environment
+# variables rather than interpolated into the script text, so no quoting
+# scheme is needed and values cannot break out of the script.
+#
+# Windows PowerShell is used rather than PowerShell 7 (+pwsh+) because the
+# WinRT projection used here is not reliably available under pwsh. It is
+# spawned as +powershell+ rather than +powershell.exe+, the way this codebase
+# spawns +git+, so PATHEXT resolves it. That also lets the tests put a shim
+# ahead of it on Windows, where a file with a shebang is not executable.
+
+class Gem::CredentialStore::WindowsBackend
+  LOAD_VAULT_TYPE = <<~POWERSHELL
+    $ErrorActionPreference = 'Stop'
+    [void][Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime]
+  POWERSHELL
+  private_constant :LOAD_VAULT_TYPE
+
+  def self.get(service, account)
+    script = <<~POWERSHELL
+      #{LOAD_VAULT_TYPE}
+      $vault = New-Object Windows.Security.Credentials.PasswordVault
+      $credential = $vault.Retrieve($env:RUBYGEMS_CRED_SERVICE, $env:RUBYGEMS_CRED_ACCOUNT)
+      # Emitting into the pipeline would send the string through PowerShell's
+      # formatter, which wraps at the host width and would corrupt a secret.
+      [Console]::Out.Write($credential.Password)
+    POWERSHELL
+
+    out, err, status = run(script, service, account)
+    # An absent credential is ordinary. Any other failure is not, so raise and
+    # let the wrapper report why rather than authenticating without one.
+    unless status.success?
+      return nil if missing_credential?(err)
+
+      raise "powershell exited with #{status.exitstatus}: #{err.strip}"
+    end
+
+    secret = out.chomp
+    secret.empty? ? nil : secret
+  end
+
+  def self.set(service, account, secret)
+    script = <<~POWERSHELL
+      #{LOAD_VAULT_TYPE}
+      $vault = New-Object Windows.Security.Credentials.PasswordVault
+      try {
+        $existing = $vault.Retrieve($env:RUBYGEMS_CRED_SERVICE, $env:RUBYGEMS_CRED_ACCOUNT)
+        $vault.Remove($existing)
+      } catch {}
+      $credential = New-Object Windows.Security.Credentials.PasswordCredential($env:RUBYGEMS_CRED_SERVICE, $env:RUBYGEMS_CRED_ACCOUNT, $env:RUBYGEMS_CRED_SECRET)
+      $vault.Add($credential)
+    POWERSHELL
+
+    _out, err, status = run(script, service, account, secret)
+    return true if status.success?
+
+    # Raise so the reason reaches the user; see MacOSBackend.set.
+    raise "powershell exited with #{status.exitstatus}: #{err.strip}"
+  end
+
+  def self.delete(service, account)
+    script = <<~POWERSHELL
+      #{LOAD_VAULT_TYPE}
+      $vault = New-Object Windows.Security.Credentials.PasswordVault
+      $credential = $vault.Retrieve($env:RUBYGEMS_CRED_SERVICE, $env:RUBYGEMS_CRED_ACCOUNT)
+      $vault.Remove($credential)
+    POWERSHELL
+
+    _out, err, status = run(script, service, account)
+    status.success? || missing_credential?(err)
+  end
+
+  # FindAllByResource raises when the resource has no entries, which is an
+  # empty list rather than an error.
+  def self.list(service)
+    script = <<~POWERSHELL
+      #{LOAD_VAULT_TYPE}
+      $vault = New-Object Windows.Security.Credentials.PasswordVault
+      try {
+        $vault.FindAllByResource($env:RUBYGEMS_CRED_SERVICE) | ForEach-Object {
+          [Console]::Out.WriteLine($_.UserName)
+        }
+      } catch {
+        if (-not ($_.Exception.Message -match 'not found|0x80070490')) { throw }
+      }
+    POWERSHELL
+
+    out, _err, status = run(script, service, nil)
+    return [] unless status.success?
+
+    out.split("\n").map(&:chomp).reject(&:empty?).uniq
+  end
+
+  def self.delete_all(service)
+    script = <<~POWERSHELL
+      #{LOAD_VAULT_TYPE}
+      $vault = New-Object Windows.Security.Credentials.PasswordVault
+      try {
+        $vault.FindAllByResource($env:RUBYGEMS_CRED_SERVICE) | ForEach-Object { $vault.Remove($_) }
+      } catch {
+        if (-not ($_.Exception.Message -match 'not found|0x80070490')) { throw }
+      }
+    POWERSHELL
+
+    _out, err, status = run(script, service, nil)
+    status.success? || missing_credential?(err)
+  end
+
+  def self.run(script, service, account, secret = nil)
+    env = { "RUBYGEMS_CRED_SERVICE" => service, "RUBYGEMS_CRED_ACCOUNT" => account }
+    env["RUBYGEMS_CRED_SECRET"] = secret if secret
+
+    Open3.capture3(env, "powershell", "-NoProfile", "-NonInteractive", "-Command", "-", stdin_data: script)
+  end
+  private_class_method :run
+
+  def self.missing_credential?(message)
+    text = message.to_s.downcase
+    text.include?("element not found") || text.include?("0x80070490") || text.include?("could not be found")
+  end
+  private_class_method :missing_credential?
+end