bundler 2.1.4 → 2.2.17

data/lib/bundler/runtime.rb

@@ -43,14 +43,6 @@ module Bundler
       self
     end
 
-    REQUIRE_ERRORS = [
-      /^no such file to load -- (.+)$/i,
-      /^Missing \w+ (?:file\s*)?([^\s]+.rb)$/i,
-      /^Missing API definition file in (.+)$/i,
-      /^cannot load such file -- (.+)$/i,
-      /^dlopen\([^)]*\): Library not loaded: (.+)$/i,
-    ].freeze
-
     def require(*groups)
       groups.map!(&:to_sym)
       groups = [:default] if groups.empty?
@@ -79,16 +71,14 @@ module Bundler
             end
           end
         rescue LoadError => e
-          REQUIRE_ERRORS.find {|r| r =~ e.message }
-          raise if dep.autorequire || $1 != required_file
+          raise if dep.autorequire || e.path != required_file
 
           if dep.autorequire.nil? && dep.name.include?("-")
             begin
               namespaced_file = dep.name.tr("-", "/")
               Kernel.require namespaced_file
             rescue LoadError => e
-              REQUIRE_ERRORS.find {|r| r =~ e.message }
-              raise if $1 != namespaced_file
+              raise if e.path != namespaced_file
             end
           end
         end
@@ -165,7 +155,7 @@ module Bundler
       spec_cache_paths     = []
       spec_gemspec_paths   = []
       spec_extension_paths = []
-      specs.each do |spec|
+      Bundler.rubygems.add_default_gems_to(specs).values.each do |spec|
         spec_gem_paths << spec.full_gem_path
         # need to check here in case gems are nested like for the rails git repo
         md = %r{(.+bundler/gems/.+-[a-f0-9]{7,12})}.match(spec.full_gem_path)
@@ -213,7 +203,7 @@ module Bundler
       output
     end
 
-  private
+    private
 
     def prune_gem_cache(resolve, cache_path)
       cached = Dir["#{cache_path}/*.gem"]

data/lib/bundler/settings.rb

@@ -7,35 +7,36 @@ module Bundler
     autoload :Validator, File.expand_path("settings/validator", __dir__)
 
     BOOL_KEYS = %w[
-      allow_bundler_dependency_conflicts
       allow_deployment_source_credential_changes
       allow_offline_install
       auto_clean_without_path
       auto_install
-      auto_config_jobs
       cache_all
       cache_all_platforms
+      clean
       default_install_uses_path
       deployment
       deployment_means_frozen
       disable_checksum_validation
       disable_exec_load
       disable_local_branch_check
+      disable_local_revision_check
       disable_multisource
-      disable_platform_warnings
       disable_shared_gems
       disable_version_check
       force_ruby_platform
       forget_cli_options
       frozen
+      gem.changelog
       gem.coc
       gem.mit
+      git.allow_insecure
       global_gem_cache
       ignore_messages
       init_gems_rb
+      inline
       no_install
       no_prune
-      only_update_to_newer_versions
       path_relative_to_cwd
       path.system
       plugins
@@ -44,8 +45,6 @@ module Bundler
       setup_makes_kernel_gem_public
       silence_deprecations
       silence_root_warning
-      skip_default_git_sources
-      specific_platform
       suppress_install_using_messages
       unlock_source_unlocks_spec
       update_requires_all_flag
@@ -65,31 +64,42 @@ module Bundler
       without
     ].freeze
 
+    STRING_KEYS = %w[
+      bin
+      cache_path
+      console
+      gem.ci
+      gem.github_username
+      gem.linter
+      gem.rubocop
+      gem.test
+      gemfile
+      path
+      shebang
+      system_bindir
+      trust-policy
+    ].freeze
+
     DEFAULT_CONFIG = {
-      :silence_deprecations => false,
-      :disable_version_check => true,
-      :prefer_patch => false,
-      :redirect => 5,
-      :retry => 3,
-      :timeout => 10,
+      "BUNDLE_SILENCE_DEPRECATIONS" => false,
+      "BUNDLE_DISABLE_VERSION_CHECK" => true,
+      "BUNDLE_PREFER_PATCH" => false,
+      "BUNDLE_REDIRECT" => 5,
+      "BUNDLE_RETRY" => 3,
+      "BUNDLE_TIMEOUT" => 10,
     }.freeze
 
     def initialize(root = nil)
       @root            = root
       @local_config    = load_config(local_config_file)
+      @env_config      = ENV.to_h.select {|key, _value| key =~ /\ABUNDLE_.+/ }
       @global_config   = load_config(global_config_file)
       @temporary       = {}
     end
 
     def [](name)
       key = key_for(name)
-      value = @temporary.fetch(key) do
-              @local_config.fetch(key) do
-              ENV.fetch(key) do
-              @global_config.fetch(key) do
-              DEFAULT_CONFIG.fetch(name) do
-                nil
-              end end end end end
+      value = configs.values.map {|config| config[key] }.compact.first
 
       converted_value(value, name)
     end
@@ -132,13 +142,11 @@ module Bundler
     end
 
     def all
-      env_keys = ENV.keys.grep(/\ABUNDLE_.+/)
-
-      keys = @temporary.keys | @global_config.keys | @local_config.keys | env_keys
+      keys = @temporary.keys | @global_config.keys | @local_config.keys | @env_config.keys
 
       keys.map do |key|
-        key.sub(/^BUNDLE_/, "").gsub(/__/, ".").downcase
-      end
+        key.sub(/^BUNDLE_/, "").gsub(/___/, "-").gsub(/__/, ".").downcase
+      end.sort
     end
 
     def local_overrides
@@ -171,13 +179,11 @@ module Bundler
 
     def locations(key)
       key = key_for(key)
-      locations = {}
-      locations[:temporary] = @temporary[key] if @temporary.key?(key)
-      locations[:local]  = @local_config[key] if @local_config.key?(key)
-      locations[:env]    = ENV[key] if ENV[key]
-      locations[:global] = @global_config[key] if @global_config.key?(key)
-      locations[:default] = DEFAULT_CONFIG[key] if DEFAULT_CONFIG.key?(key)
-      locations
+      configs.keys.inject({}) do |partial_locations, level|
+        value_on_level = configs[level][key]
+        partial_locations[level] = value_on_level unless value_on_level.nil?
+        partial_locations
+      end
     end
 
     def pretty_values_for(exposed_key)
@@ -185,20 +191,20 @@ module Bundler
 
       locations = []
 
-      if @temporary.key?(key)
-        locations << "Set for the current command: #{converted_value(@temporary[key], exposed_key).inspect}"
+      if value = @temporary[key]
+        locations << "Set for the current command: #{printable_value(value, exposed_key).inspect}"
       end
 
-      if @local_config.key?(key)
-        locations << "Set for your local app (#{local_config_file}): #{converted_value(@local_config[key], exposed_key).inspect}"
+      if value = @local_config[key]
+        locations << "Set for your local app (#{local_config_file}): #{printable_value(value, exposed_key).inspect}"
       end
 
-      if value = ENV[key]
-        locations << "Set via #{key}: #{converted_value(value, exposed_key).inspect}"
+      if value = @env_config[key]
+        locations << "Set via #{key}: #{printable_value(value, exposed_key).inspect}"
       end
 
-      if @global_config.key?(key)
-        locations << "Set for the current user (#{global_config_file}): #{converted_value(@global_config[key], exposed_key).inspect}"
+      if value = @global_config[key]
+        locations << "Set for the current user (#{global_config_file}): #{printable_value(value, exposed_key).inspect}"
       end
 
       return ["You have not configured a value for `#{exposed_key}`"] if locations.empty?
@@ -207,17 +213,19 @@ module Bundler
 
     # for legacy reasons, in Bundler 2, we do not respect :disable_shared_gems
     def path
-      key  = key_for(:path)
-      path = ENV[key] || @global_config[key]
-      if path && !@temporary.key?(key) && !@local_config.key?(key)
-        return Path.new(path, false, false)
+      configs.each do |_level, settings|
+        path = value_for("path", settings)
+        path_system = value_for("path.system", settings)
+        disabled_shared_gems = value_for("disable_shared_gems", settings)
+        next if path.nil? && path_system.nil? && disabled_shared_gems.nil?
+        system_path = path_system || (disabled_shared_gems == false)
+        return Path.new(path, system_path)
       end
 
-      system_path = self["path.system"] || (self[:disable_shared_gems] == false)
-      Path.new(self[:path], system_path, Bundler.feature_flag.default_install_uses_path?)
+      Path.new(nil, false)
     end
 
-    Path = Struct.new(:explicit_path, :system_path, :default_install_uses_path) do
+    Path = Struct.new(:explicit_path, :system_path) do
       def path
         path = base_path
         path = File.join(path, Bundler.ruby_scope) unless use_system_gems?
@@ -227,7 +235,7 @@ module Bundler
       def use_system_gems?
         return true if system_path
         return false if explicit_path
-        !default_install_uses_path
+        !Bundler.feature_flag.default_install_uses_path?
       end
 
       def base_path
@@ -280,20 +288,32 @@ module Bundler
 
     def validate!
       all.each do |raw_key|
-        [@local_config, ENV, @global_config].each do |settings|
-          value = converted_value(settings[key_for(raw_key)], raw_key)
-          Validator.validate!(raw_key, value, settings.to_hash.dup)
+        [@local_config, @env_config, @global_config].each do |settings|
+          value = value_for(raw_key, settings)
+          Validator.validate!(raw_key, value, settings.dup)
         end
       end
     end
 
     def key_for(key)
-      key = Settings.normalize_uri(key).to_s if key.is_a?(String) && /https?:/ =~ key
-      key = key.to_s.gsub(".", "__").upcase
-      "BUNDLE_#{key}"
+      self.class.key_for(key)
     end
 
-  private
+    private
+
+    def configs
+      {
+        :temporary => @temporary,
+        :local => @local_config,
+        :env => @env_config,
+        :global => @global_config,
+        :default => DEFAULT_CONFIG,
+      }
+    end
+
+    def value_for(name, config)
+      converted_value(config[key_for(name)], name)
+    end
 
     def parent_setting_for(name)
       split_specific_setting_for(name)[0]
@@ -311,6 +331,10 @@ module Bundler
       BOOL_KEYS.include?(name.to_s) || BOOL_KEYS.include?(parent_setting_for(name.to_s))
     end
 
+    def is_string(name)
+      STRING_KEYS.include?(name.to_s) || name.to_s.start_with?("local.") || name.to_s.start_with?("mirror.") || name.to_s.start_with?("build.")
+    end
+
     def to_bool(value)
       case value
       when nil, /\A(false|f|no|n|0|)\z/i, false
@@ -328,6 +352,14 @@ module Bundler
       ARRAY_KEYS.include?(key.to_s)
     end
 
+    def is_credential(key)
+      key == "gem.push_key"
+    end
+
+    def is_userinfo(value)
+      value.include?(":")
+    end
+
     def to_array(value)
       return [] unless value
       value.split(":").map(&:to_sym)
@@ -374,6 +406,21 @@ module Bundler
       end
     end
 
+    def printable_value(value, key)
+      converted = converted_value(value, key)
+      return converted unless converted.is_a?(String)
+
+      if is_string(key)
+        converted
+      elsif is_credential(key)
+        "[REDACTED]"
+      elsif is_userinfo(converted)
+        converted.gsub(/:.*$/, ":[REDACTED]")
+      else
+        converted
+      end
+    end
+
     def global_config_file
       if ENV["BUNDLE_CONFIG"] && !ENV["BUNDLE_CONFIG"].empty?
         Pathname.new(ENV["BUNDLE_CONFIG"])
@@ -413,6 +460,12 @@ module Bundler
         \z
       /ix.freeze
 
+    def self.key_for(key)
+      key = normalize_uri(key).to_s if key.is_a?(String) && /https?:/ =~ key
+      key = key.to_s.gsub(".", "__").gsub("-", "___").upcase
+      "BUNDLE_#{key}"
+    end
+
     # TODO: duplicates Rubygems#normalize_uri
     # TODO: is this the correct place to validate mirror URIs?
     def self.normalize_uri(uri)

data/lib/bundler/shared_helpers.rb

@@ -194,11 +194,11 @@ module Bundler
       return @md5_available if defined?(@md5_available)
       @md5_available = begin
         require "openssl"
-        OpenSSL::Digest::MD5.digest("")
+        ::OpenSSL::Digest.digest("MD5", "")
         true
       rescue LoadError
         true
-      rescue OpenSSL::Digest::DigestError
+      rescue ::OpenSSL::Digest::DigestError
         false
       end
     end
@@ -212,7 +212,7 @@ module Bundler
       filesystem_access(gemfile_path) {|g| File.open(g, "w") {|file| file.puts contents } }
     end
 
-  private
+    private
 
     def validate_bundle_path
       path_separator = Bundler.rubygems.path_separator

data/lib/bundler/similarity_detector.rb

@@ -26,7 +26,7 @@ module Bundler
       end
     end
 
-  protected
+    protected
 
     # https://www.informit.com/articles/article.aspx?p=683059&seqNum=36
     def levenshtein_distance(this, that, ins = 2, del = 2, sub = 1)

data/lib/bundler/source.rb

@@ -33,6 +33,12 @@ module Bundler
       spec.source == self
     end
 
+    def local!; end
+
+    def cached!; end
+
+    def remote!; end
+
     # it's possible that gems from one source depend on gems from some
     # other source, so now we download gemspecs and iterate over those
     # dependencies, looking for gems we don't have info on yet.
@@ -63,7 +69,7 @@ module Bundler
       )
     end
 
-  private
+    private
 
     def version_color(spec_version, locked_spec_version)
       if Gem::Version.correct?(spec_version) && Gem::Version.correct?(locked_spec_version)

data/lib/bundler/source/git.rb

@@ -22,7 +22,7 @@ module Bundler
         @uri        = options["uri"] || ""
         @safe_uri   = URICredentialsFilter.credential_filtered_uri(@uri)
         @branch     = options["branch"]
-        @ref        = options["ref"] || options["branch"] || options["tag"] || "master"
+        @ref        = options["ref"] || options["branch"] || options["tag"]
         @submodules = options["submodules"]
         @name       = options["name"]
         @version    = options["version"].to_s.strip.gsub("-", ".pre.")
@@ -60,25 +60,27 @@ module Bundler
       alias_method :==, :eql?
 
       def to_s
-        at = if local?
-          path
-        elsif user_ref = options["ref"]
-          if ref =~ /\A[a-z0-9]{4,}\z/i
-            shortref_for_display(user_ref)
+        begin
+          at = if local?
+            path
+          elsif user_ref = options["ref"]
+            if ref =~ /\A[a-z0-9]{4,}\z/i
+              shortref_for_display(user_ref)
+            else
+              user_ref
+            end
+          elsif ref
+            ref
           else
-            user_ref
+            git_proxy.branch
           end
-        else
-          ref
-        end
 
-        rev = begin
-                "@#{shortref_for_display(revision)}"
-              rescue GitError
-                nil
-              end
+          rev = " (at #{at}@#{shortref_for_display(revision)})"
+        rescue GitError
+          ""
+        end
 
-        "#{@safe_uri} (at #{at}#{rev})"
+        "#{@safe_uri}#{rev}"
       end
 
       def name
@@ -146,7 +148,7 @@ module Bundler
 
         changed = cached_revision && cached_revision != git_proxy.revision
 
-        if changed && !@unlocked && !git_proxy.contains?(cached_revision)
+        if !Bundler.settings[:disable_local_revision_check] && changed && !@unlocked && !git_proxy.contains?(cached_revision)
           raise GitError, "The Gemfile lock is pointing to revision #{shortref_for_display(cached_revision)} " \
             "but the current branch in your local override for #{name} does not contain such commit. " \
             "Please make sure your branch is up to date."
@@ -230,7 +232,11 @@ module Bundler
         @allow_remote || @allow_cached
       end
 
-    private
+      def local?
+        @local
+      end
+
+      private
 
       def serialize_gemspecs_in(destination)
         destination = destination.expand_path(Bundler.root) if destination.relative?
@@ -256,10 +262,6 @@ module Bundler
         cached_revision && super
       end
 
-      def local?
-        @local
-      end
-
       def requires_checkout?
         allow_git_ops? && !local? && !cached_revision_checked_out?
       end