bundler 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/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/assignment.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class Assignment
     attr_reader :term, :cause, :decision_level, :index
     def initialize(term, cause, decision_level, index)

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/basic_package_source.rb

@@ -1,10 +1,10 @@
 require_relative 'version_constraint'
 require_relative 'incompatibility'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   # Types:
   #
-  # Where possible, Bundler::PubGrub will accept user-defined types, so long as they quack.
+  # Where possible, Gem::PubGrub will accept user-defined types, so long as they quack.
   #
   # ## "Package":
   #
@@ -32,7 +32,7 @@ module Bundler::PubGrub
   #
   # This class represents the requirement one package has on another. It is
   # returned by dependencies_for(package, version) and will be passed to
-  # parse_dependency to convert it to a format Bundler::PubGrub understands.
+  # parse_dependency to convert it to a format Gem::PubGrub understands.
   #
   # It must also have a reasonable definition of #==
   #
@@ -59,13 +59,13 @@ module Bundler::PubGrub
 
     # Override me!
     #
-    # Convert a (user-defined) dependency into a format Bundler::PubGrub understands.
+    # Convert a (user-defined) dependency into a format Gem::PubGrub understands.
     #
     # Package is passed to this method but for many implementations is not
     # needed.
     #
-    # Returns: either a Bundler::PubGrub::VersionRange, Bundler::PubGrub::VersionUnion, or a
-    #   Bundler::PubGrub::VersionConstraint
+    # Returns: either a Gem::PubGrub::VersionRange, Gem::PubGrub::VersionUnion, or a
+    #   Gem::PubGrub::VersionConstraint
     def parse_dependency(package, dependency)
       raise NotImplementedError
     end
@@ -155,7 +155,7 @@ module Bundler::PubGrub
         dep_constraint = parse_dependency(dep_package, dep_constraint_name)
         if !dep_constraint
           # falsey indicates this dependency was invalid
-          cause = Bundler::PubGrub::Incompatibility::InvalidDependency.new(dep_package, dep_constraint_name)
+          cause = Gem::PubGrub::Incompatibility::InvalidDependency.new(dep_package, dep_constraint_name)
           return [Incompatibility.new([Term.new(self_constraint, true)], cause: cause)]
         elsif !dep_constraint.is_a?(VersionConstraint)
           # Upgrade range/union to VersionConstraint

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/failure_writer.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class FailureWriter
     def initialize(root)
       @root = root

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/incompatibility.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class Incompatibility
     ConflictCause = Struct.new(:incompatibility, :satisfier) do
       alias_method :conflict, :incompatibility
@@ -61,11 +61,11 @@ module Bundler::PubGrub
         "(root dependency)"
       when :dependency
         "#{terms[0].to_s(allow_every: true)} depends on #{terms[1].invert}"
-      when Bundler::PubGrub::Incompatibility::InvalidDependency
+      when Gem::PubGrub::Incompatibility::InvalidDependency
         "#{terms[0].to_s(allow_every: true)} depends on unknown package #{cause.package}"
-      when Bundler::PubGrub::Incompatibility::NoVersions
+      when Gem::PubGrub::Incompatibility::NoVersions
         "no versions satisfy #{cause.constraint}"
-      when Bundler::PubGrub::Incompatibility::ConflictCause
+      when Gem::PubGrub::Incompatibility::ConflictCause
         if failure?
           "version solving has failed"
         elsif terms.length == 1

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/package.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class Package
 
     attr_reader :name

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/partial_solution.rb

@@ -1,6 +1,6 @@
 require_relative 'assignment'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class PartialSolution
     attr_reader :assignments, :decisions
     attr_reader :attempted_solutions

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/rubygems.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   module RubyGems
     extend self
 
@@ -30,7 +30,7 @@ module Bundler::PubGrub
     end
 
     def requirement_to_constraint(package, requirement)
-      Bundler::PubGrub::VersionConstraint.new(package, range: requirement_to_range(requirement))
+      Gem::PubGrub::VersionConstraint.new(package, range: requirement_to_range(requirement))
     end
 
     def parse_range(dep)
@@ -39,7 +39,7 @@ module Bundler::PubGrub
 
     def parse_constraint(package, dep)
       range = parse_range(dep)
-      Bundler::PubGrub::VersionConstraint.new(package, range: range)
+      Gem::PubGrub::VersionConstraint.new(package, range: range)
     end
   end
 end

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/solve_failure.rb

@@ -1,6 +1,6 @@
 require_relative 'failure_writer'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class SolveFailure < StandardError
     attr_reader :incompatibility
 

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/static_package_source.rb

@@ -4,7 +4,7 @@ require_relative 'version_constraint'
 require_relative 'incompatibility'
 require_relative 'basic_package_source'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class StaticPackageSource < BasicPackageSource
     class DSL
       def initialize(packages, root_deps)
@@ -27,7 +27,7 @@ module Bundler::PubGrub
 
       # Exclude redundant self-referencing dependencies
       def clean_deps(name, version, deps)
-        deps.reject {|dep_name, req| name == dep_name && Bundler::PubGrub::RubyGems.parse_range(req).include?(version) }
+        deps.reject {|dep_name, req| name == dep_name && Gem::PubGrub::RubyGems.parse_range(req).include?(version) }
       end
     end
 
@@ -55,7 +55,7 @@ module Bundler::PubGrub
     def parse_dependency(package, dependency)
       return false unless @packages.key?(package)
 
-      Bundler::PubGrub::RubyGems.parse_constraint(package, dependency)
+      Gem::PubGrub::RubyGems.parse_constraint(package, dependency)
     end
   end
 end

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/strategy.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class Strategy
     def initialize(source)
       @source = source
@@ -27,7 +27,7 @@ module Bundler::PubGrub
       versions = @source.versions_for(package, range)
 
       indexes = @version_indexes[package]
-      versions.min_by { |version| indexes[version] }
+      versions.min_by { |version| indexes[version] || Float::INFINITY }
     end
 
     def next_term_to_try_from(unsatisfied)

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/term.rb

@@ -1,4 +1,4 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   class Term
     attr_reader :package, :constraint, :positive
 

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/version.rb

@@ -1,3 +1,3 @@
-module Bundler::PubGrub
+module Gem::PubGrub
   VERSION = "0.5.0"
 end

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/version_constraint.rb

@@ -1,11 +1,11 @@
 require_relative 'version_range'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class VersionConstraint
     attr_reader :package, :range
 
-    # @param package [Bundler::PubGrub::Package]
-    # @param range [Bundler::PubGrub::VersionRange]
+    # @param package [Gem::PubGrub::Package]
+    # @param range [Gem::PubGrub::VersionRange]
     def initialize(package, range: nil)
       @package = package
       @range = range

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/version_range.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class VersionRange
     attr_reader :min, :max, :include_min, :include_max
 

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/version_solver.rb

@@ -4,14 +4,14 @@ require_relative 'incompatibility'
 require_relative 'solve_failure'
 require_relative 'strategy'
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class VersionSolver
     attr_reader :logger
     attr_reader :source
     attr_reader :solution
     attr_reader :strategy
 
-    def initialize(source:, root: Package.root, strategy: Strategy.new(source), logger: Bundler::PubGrub.logger)
+    def initialize(source:, root: Package.root, strategy: Strategy.new(source), logger: Gem::PubGrub.logger)
       @logger = logger
 
       @source = source

data/lib/{bundler → rubygems}/vendor/pub_grub/lib/pub_grub/version_union.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Bundler::PubGrub
+module Gem::PubGrub
   class VersionUnion
     attr_reader :ranges
 

data/lib/rubygems/vendor/pub_grub/lib/pub_grub.rb

@@ -0,0 +1,57 @@
+# 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::PubGrub::VERSION)
+
+require_relative "pub_grub/package"
+require_relative "pub_grub/static_package_source"
+require_relative "pub_grub/term"
+require_relative "pub_grub/version_range"
+require_relative "pub_grub/version_constraint"
+require_relative "pub_grub/version_union"
+require_relative "pub_grub/version_solver"
+require_relative "pub_grub/incompatibility"
+require_relative 'pub_grub/solve_failure'
+require_relative 'pub_grub/failure_writer'
+require_relative 'pub_grub/version'
+
+module Gem::PubGrub
+  # Minimal logger that doesn't require the 'logger' gem
+  class NullLogger
+    def info(&block); end
+    def debug(&block); end
+    def warn(&block); end
+    def error(&block); end
+  end
+
+  class StderrLogger
+    def info(&block)
+      $stderr.puts "INFO: #{block.call}" if block
+    end
+
+    def debug(&block)
+      $stderr.puts "DEBUG: #{block.call}" if block
+    end
+
+    def warn(&block)
+      $stderr.puts "WARN: #{block.call}" if block
+    end
+
+    def error(&block)
+      $stderr.puts "ERROR: #{block.call}" if block
+    end
+  end
+
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger || default_logger
+    end
+
+    private
+
+    def default_logger
+      @logger = $DEBUG ? StderrLogger.new : NullLogger.new
+    end
+  end
+end

data/lib/{bundler → rubygems}/vendor/securerandom/lib/securerandom.rb

@@ -10,7 +10,7 @@ require 'random/formatter'
 #
 # You can use this library in your application by requiring it:
 #
-#   require 'bundler/vendor/securerandom/lib/securerandom'
+#   require 'rubygems/vendor/securerandom/lib/securerandom'
 #
 # It supports the following secure random number generators:
 #
@@ -18,7 +18,7 @@ require 'random/formatter'
 # * /dev/urandom
 # * Win32
 #
-# Bundler::SecureRandom is extended by the Random::Formatter module which
+# Gem::SecureRandom is extended by the Random::Formatter module which
 # defines the following methods:
 #
 # * alphanumeric
@@ -32,13 +32,17 @@ require 'random/formatter'
 # * urlsafe_base64
 # * uuid
 #
-# These methods are usable as class methods of Bundler::SecureRandom such as
-# +Bundler::SecureRandom.hex+.
+# These methods are usable as class methods of Gem::SecureRandom such as
+# +Gem::SecureRandom.hex+.
 #
 # If a secure random number generator is not available,
 # +NotImplementedError+ is raised.
 
-module Bundler::SecureRandom
+# 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::SecureRandom::VERSION)
+
+module Gem::SecureRandom
 
   # The version
   VERSION = "0.4.1"
@@ -99,4 +103,4 @@ module Bundler::SecureRandom
   end
 end
 
-Bundler::SecureRandom.extend(Random::Formatter)
+Gem::SecureRandom.extend(Random::Formatter)