rubygems-update 3.0.3 → 3.4.12

data/bundler/lib/bundler.rb

@@ -1,77 +1,103 @@
 # frozen_string_literal: true
 
-require "bundler/compatibility_guard"
-
-require "bundler/vendored_fileutils"
+require_relative "bundler/vendored_fileutils"
 require "pathname"
 require "rbconfig"
-require "thread"
-
-require "bundler/errors"
-require "bundler/environment_preserver"
-require "bundler/plugin"
-require "bundler/rubygems_ext"
-require "bundler/rubygems_integration"
-require "bundler/version"
-require "bundler/constants"
-require "bundler/current_ruby"
-require "bundler/build_metadata"
 
+require_relative "bundler/errors"
+require_relative "bundler/environment_preserver"
+require_relative "bundler/plugin"
+require_relative "bundler/rubygems_ext"
+require_relative "bundler/rubygems_integration"
+require_relative "bundler/version"
+require_relative "bundler/constants"
+require_relative "bundler/current_ruby"
+require_relative "bundler/build_metadata"
+
+# Bundler provides a consistent environment for Ruby projects by
+# tracking and installing the exact gems and versions that are needed.
+#
+# Since Ruby 2.6, Bundler is a part of Ruby's standard library.
+#
+# Bundler is used by creating _gemfiles_ listing all the project dependencies
+# and (optionally) their versions and then using
+#
+#   require 'bundler/setup'
+#
+# or Bundler.setup to setup environment where only specified gems and their
+# specified versions could be used.
+#
+# See {Bundler website}[https://bundler.io/docs.html] for extensive documentation
+# on gemfiles creation and Bundler usage.
+#
+# As a standard library inside project, Bundler could be used for introspection
+# of loaded and required modules.
+#
 module Bundler
-  environment_preserver = EnvironmentPreserver.new(ENV, EnvironmentPreserver::BUNDLER_KEYS)
+  environment_preserver = EnvironmentPreserver.from_env
   ORIGINAL_ENV = environment_preserver.restore
-  ENV.replace(environment_preserver.backup)
-  SUDO_MUTEX = Mutex.new
-
-  autoload :Definition,             "bundler/definition"
-  autoload :Dependency,             "bundler/dependency"
-  autoload :DepProxy,               "bundler/dep_proxy"
-  autoload :Deprecate,              "bundler/deprecate"
-  autoload :Dsl,                    "bundler/dsl"
-  autoload :EndpointSpecification,  "bundler/endpoint_specification"
-  autoload :Env,                    "bundler/env"
-  autoload :Fetcher,                "bundler/fetcher"
-  autoload :FeatureFlag,            "bundler/feature_flag"
-  autoload :GemHelper,              "bundler/gem_helper"
-  autoload :GemHelpers,             "bundler/gem_helpers"
-  autoload :GemRemoteFetcher,       "bundler/gem_remote_fetcher"
-  autoload :GemVersionPromoter,     "bundler/gem_version_promoter"
-  autoload :Graph,                  "bundler/graph"
-  autoload :Index,                  "bundler/index"
-  autoload :Injector,               "bundler/injector"
-  autoload :Installer,              "bundler/installer"
-  autoload :LazySpecification,      "bundler/lazy_specification"
-  autoload :LockfileParser,         "bundler/lockfile_parser"
-  autoload :MatchPlatform,          "bundler/match_platform"
-  autoload :ProcessLock,            "bundler/process_lock"
-  autoload :RemoteSpecification,    "bundler/remote_specification"
-  autoload :Resolver,               "bundler/resolver"
-  autoload :Retry,                  "bundler/retry"
-  autoload :RubyDsl,                "bundler/ruby_dsl"
-  autoload :RubyGemsGemInstaller,   "bundler/rubygems_gem_installer"
-  autoload :RubyVersion,            "bundler/ruby_version"
-  autoload :Runtime,                "bundler/runtime"
-  autoload :Settings,               "bundler/settings"
-  autoload :SharedHelpers,          "bundler/shared_helpers"
-  autoload :Source,                 "bundler/source"
-  autoload :SourceList,             "bundler/source_list"
-  autoload :SpecSet,                "bundler/spec_set"
-  autoload :StubSpecification,      "bundler/stub_specification"
-  autoload :UI,                     "bundler/ui"
-  autoload :URICredentialsFilter,   "bundler/uri_credentials_filter"
-  autoload :VersionRanges,          "bundler/version_ranges"
+  environment_preserver.replace_with_backup
+  SUDO_MUTEX = Thread::Mutex.new
+
+  SAFE_MARSHAL_CLASSES = [Symbol, TrueClass, String, Array, Hash, Gem::Version, Gem::Specification].freeze
+  SAFE_MARSHAL_ERROR = "Unexpected class %s present in marshaled data. Only %s are allowed."
+  SAFE_MARSHAL_PROC = proc do |object|
+    object.tap do
+      unless SAFE_MARSHAL_CLASSES.include?(object.class)
+        raise TypeError, format(SAFE_MARSHAL_ERROR, object.class, SAFE_MARSHAL_CLASSES.join(", "))
+      end
+    end
+  end
+
+  autoload :Definition,             File.expand_path("bundler/definition", __dir__)
+  autoload :Dependency,             File.expand_path("bundler/dependency", __dir__)
+  autoload :Deprecate,              File.expand_path("bundler/deprecate", __dir__)
+  autoload :Digest,                 File.expand_path("bundler/digest", __dir__)
+  autoload :Dsl,                    File.expand_path("bundler/dsl", __dir__)
+  autoload :EndpointSpecification,  File.expand_path("bundler/endpoint_specification", __dir__)
+  autoload :Env,                    File.expand_path("bundler/env", __dir__)
+  autoload :Fetcher,                File.expand_path("bundler/fetcher", __dir__)
+  autoload :FeatureFlag,            File.expand_path("bundler/feature_flag", __dir__)
+  autoload :GemHelper,              File.expand_path("bundler/gem_helper", __dir__)
+  autoload :GemHelpers,             File.expand_path("bundler/gem_helpers", __dir__)
+  autoload :GemVersionPromoter,     File.expand_path("bundler/gem_version_promoter", __dir__)
+  autoload :Graph,                  File.expand_path("bundler/graph", __dir__)
+  autoload :Index,                  File.expand_path("bundler/index", __dir__)
+  autoload :Injector,               File.expand_path("bundler/injector", __dir__)
+  autoload :Installer,              File.expand_path("bundler/installer", __dir__)
+  autoload :LazySpecification,      File.expand_path("bundler/lazy_specification", __dir__)
+  autoload :LockfileParser,         File.expand_path("bundler/lockfile_parser", __dir__)
+  autoload :MatchRemoteMetadata,    File.expand_path("bundler/match_remote_metadata", __dir__)
+  autoload :ProcessLock,            File.expand_path("bundler/process_lock", __dir__)
+  autoload :RemoteSpecification,    File.expand_path("bundler/remote_specification", __dir__)
+  autoload :Resolver,               File.expand_path("bundler/resolver", __dir__)
+  autoload :Retry,                  File.expand_path("bundler/retry", __dir__)
+  autoload :RubyDsl,                File.expand_path("bundler/ruby_dsl", __dir__)
+  autoload :RubyVersion,            File.expand_path("bundler/ruby_version", __dir__)
+  autoload :Runtime,                File.expand_path("bundler/runtime", __dir__)
+  autoload :SelfManager,            File.expand_path("bundler/self_manager", __dir__)
+  autoload :Settings,               File.expand_path("bundler/settings", __dir__)
+  autoload :SharedHelpers,          File.expand_path("bundler/shared_helpers", __dir__)
+  autoload :Source,                 File.expand_path("bundler/source", __dir__)
+  autoload :SourceList,             File.expand_path("bundler/source_list", __dir__)
+  autoload :SourceMap,              File.expand_path("bundler/source_map", __dir__)
+  autoload :SpecSet,                File.expand_path("bundler/spec_set", __dir__)
+  autoload :StubSpecification,      File.expand_path("bundler/stub_specification", __dir__)
+  autoload :UI,                     File.expand_path("bundler/ui", __dir__)
+  autoload :URICredentialsFilter,   File.expand_path("bundler/uri_credentials_filter", __dir__)
+  autoload :URINormalizer,          File.expand_path("bundler/uri_normalizer", __dir__)
 
   class << self
     def configure
-      @configured ||= configure_gem_home_and_path
+      @configure ||= configure_gem_home_and_path
     end
 
     def ui
-      (defined?(@ui) && @ui) || (self.ui = UI::Silent.new)
+      (defined?(@ui) && @ui) || (self.ui = UI::Shell.new)
     end
 
     def ui=(ui)
-      Bundler.rubygems.ui = ui ? UI::RGProxy.new(ui) : nil
+      Bundler.rubygems.ui = UI::RGProxy.new(ui)
       @ui = ui
     end
 
@@ -80,6 +106,17 @@ module Bundler
       @bundle_path ||= Pathname.new(configured_bundle_path.path).expand_path(root)
     end
 
+    def create_bundle_path
+      SharedHelpers.filesystem_access(bundle_path.to_s) do |p|
+        mkdir_p(p)
+      end unless bundle_path.exist?
+
+      @bundle_path = bundle_path.realpath
+    rescue Errno::EEXIST
+      raise PathError, "Could not install to path `#{bundle_path}` " \
+        "because a file already exists at that path. Either remove or rename the file so the directory can be created."
+    end
+
     def configured_bundle_path
       @configured_bundle_path ||= settings.path.tap(&:validate!)
     end
@@ -94,6 +131,33 @@ module Bundler
       end
     end
 
+    # Turns on the Bundler runtime. After +Bundler.setup+ call, all +load+ or
+    # +require+ of the gems would be allowed only if they are part of
+    # the Gemfile or Ruby's standard library. If the versions specified
+    # in Gemfile, only those versions would be loaded.
+    #
+    # Assuming Gemfile
+    #
+    #    gem 'first_gem', '= 1.0'
+    #    group :test do
+    #      gem 'second_gem', '= 1.0'
+    #    end
+    #
+    # The code using Bundler.setup works as follows:
+    #
+    #    require 'third_gem' # allowed, required from global gems
+    #    require 'first_gem' # allowed, loads the last installed version
+    #    Bundler.setup
+    #    require 'fourth_gem' # fails with LoadError
+    #    require 'second_gem' # loads exactly version 1.0
+    #
+    # +Bundler.setup+ can be called only once, all subsequent calls are no-op.
+    #
+    # If _groups_ list is provided, only gems from specified groups would
+    # be allowed (gems specified outside groups belong to special +:default+ group).
+    #
+    # To require all gems from Gemfile (or only some groups), see Bundler.require.
+    #
     def setup(*groups)
       # Return if all groups are already loaded
       return @setup if defined?(@setup) && @setup
@@ -110,6 +174,24 @@ module Bundler
       end
     end
 
+    # Setups Bundler environment (see Bundler.setup) if it is not already set,
+    # and loads all gems from groups specified. Unlike ::setup, can be called
+    # multiple times with different groups (if they were allowed by setup).
+    #
+    # Assuming Gemfile
+    #
+    #    gem 'first_gem', '= 1.0'
+    #    group :test do
+    #      gem 'second_gem', '= 1.0'
+    #    end
+    #
+    # The code will work as follows:
+    #
+    #    Bundler.setup # allow all groups
+    #    Bundler.require(:default) # requires only first_gem
+    #    # ...later
+    #    Bundler.require(:test)   # requires second_gem
+    #
     def require(*groups)
       setup(*groups).require(*groups)
     end
@@ -119,7 +201,7 @@ module Bundler
     end
 
     def environment
-      SharedHelpers.major_deprecation 2, "Bundler.environment has been removed in favor of Bundler.load"
+      SharedHelpers.major_deprecation 2, "Bundler.environment has been removed in favor of Bundler.load", :print_caller_location => true
       load
     end
 
@@ -138,7 +220,7 @@ module Bundler
 
     def frozen_bundle?
       frozen = settings[:deployment]
-      frozen ||= settings[:frozen] unless feature_flag.deployment_means_frozen?
+      frozen ||= settings[:frozen]
       frozen
     end
 
@@ -152,8 +234,14 @@ module Bundler
         end
     end
 
+    def most_specific_locked_platform?(platform)
+      return false unless defined?(@definition) && @definition
+
+      definition.most_specific_locked_platform == platform
+    end
+
     def ruby_scope
-      "#{Bundler.rubygems.ruby_engine}/#{Bundler.rubygems.config_map[:ruby_version]}"
+      "#{Bundler.rubygems.ruby_engine}/#{RbConfig::CONFIG["ruby_version"]}"
     end
 
     def user_home
@@ -170,9 +258,9 @@ module Bundler
         end
 
         if warning
-          Kernel.send(:require, "etc")
-          user_home = tmp_home_path(Etc.getlogin, warning)
-          Bundler.ui.warn "#{warning}\nBundler will use `#{user_home}' as your home directory temporarily.\n"
+          Bundler.ui.warn "#{warning}\n"
+          user_home = tmp_home_path
+          Bundler.ui.warn "Bundler will use `#{user_home}' as your home directory temporarily.\n"
           user_home
         else
           Pathname.new(home)
@@ -180,37 +268,22 @@ module Bundler
       end
     end
 
-    def tmp_home_path(login, warning)
-      login ||= "unknown"
-      Kernel.send(:require, "tmpdir")
-      path = Pathname.new(Dir.tmpdir).join("bundler", "home")
-      SharedHelpers.filesystem_access(path) do |tmp_home_path|
-        unless tmp_home_path.exist?
-          tmp_home_path.mkpath
-          tmp_home_path.chmod(0o777)
-        end
-        tmp_home_path.join(login).tap(&:mkpath)
-      end
-    rescue RuntimeError => e
-      raise e.exception("#{warning}\nBundler also failed to create a temporary home directory at `#{path}':\n#{e}")
-    end
-
     def user_bundle_path(dir = "home")
       env_var, fallback = case dir
                           when "home"
-                            ["BUNDLE_USER_HOME", Pathname.new(user_home).join(".bundle")]
+                            ["BUNDLE_USER_HOME", proc { Pathname.new(user_home).join(".bundle") }]
                           when "cache"
-                            ["BUNDLE_USER_CACHE", user_bundle_path.join("cache")]
+                            ["BUNDLE_USER_CACHE", proc { user_bundle_path.join("cache") }]
                           when "config"
-                            ["BUNDLE_USER_CONFIG", user_bundle_path.join("config")]
+                            ["BUNDLE_USER_CONFIG", proc { user_bundle_path.join("config") }]
                           when "plugin"
-                            ["BUNDLE_USER_PLUGIN", user_bundle_path.join("plugin")]
+                            ["BUNDLE_USER_PLUGIN", proc { user_bundle_path.join("plugin") }]
                           else
                             raise BundlerError, "Unknown user path requested: #{dir}"
       end
       # `fallback` will already be a Pathname, but Pathname.new() is
       # idempotent so it's OK
-      Pathname.new(ENV.fetch(env_var, fallback))
+      Pathname.new(ENV.fetch(env_var, &fallback))
     end
 
     def user_cache
@@ -241,7 +314,13 @@ module Bundler
 
     def app_config_path
       if app_config = ENV["BUNDLE_APP_CONFIG"]
-        Pathname.new(app_config).expand_path(root)
+        app_config_pathname = Pathname.new(app_config)
+
+        if app_config_pathname.absolute?
+          app_config_pathname
+        else
+          app_config_pathname.expand_path(root)
+        end
       else
         root.join(".bundle")
       end
@@ -261,9 +340,9 @@ module Bundler
       FileUtils.remove_entry_secure(path) if path && File.exist?(path)
     rescue ArgumentError
       message = <<EOF
-It is a security vulnerability to allow your home directory to be world-writable, and bundler can not continue.
+It is a security vulnerability to allow your home directory to be world-writable, and bundler cannot continue.
 You should probably consider fixing this issue by running `chmod o-w ~` on *nix.
-Please refer to http://ruby-doc.org/stdlib-2.1.2/libdoc/fileutils/rdoc/FileUtils.html#method-c-remove_entry_secure for details.
+Please refer to https://ruby-doc.org/stdlib-3.1.2/libdoc/fileutils/rdoc/FileUtils.html#method-c-remove_entry_secure for details.
 EOF
       File.world_writable?(path) ? Bundler.ui.warn(message) : raise
       raise PathError, "Please fix the world-writable issue with your #{path} directory"
@@ -280,10 +359,20 @@ EOF
       ORIGINAL_ENV.clone
     end
 
-    # @deprecated Use `original_env` instead
-    # @return [Hash] Environment with all bundler-related variables removed
+    # @deprecated Use `unbundled_env` instead
     def clean_env
-      Bundler::SharedHelpers.major_deprecation(2, "`Bundler.clean_env` has weird edge cases, use `.original_env` instead")
+      Bundler::SharedHelpers.major_deprecation(
+        2,
+        "`Bundler.clean_env` has been deprecated in favor of `Bundler.unbundled_env`. " \
+        "If you instead want the environment before bundler was originally loaded, use `Bundler.original_env`",
+        :print_caller_location => true
+      )
+
+      unbundled_env
+    end
+
+    # @return [Hash] Environment with all bundler-related variables removed
+    def unbundled_env
       env = original_env
 
       if env.key?("BUNDLER_ORIG_MANPATH")
@@ -293,32 +382,85 @@ EOF
       env.delete_if {|k, _| k[0, 7] == "BUNDLE_" }
 
       if env.key?("RUBYOPT")
-        env["RUBYOPT"] = env["RUBYOPT"].sub "-rbundler/setup", ""
+        rubyopt = env["RUBYOPT"].split(" ")
+        rubyopt.delete("-r#{File.expand_path("bundler/setup", __dir__)}")
+        rubyopt.delete("-rbundler/setup")
+        env["RUBYOPT"] = rubyopt.join(" ")
       end
 
       if env.key?("RUBYLIB")
         rubylib = env["RUBYLIB"].split(File::PATH_SEPARATOR)
-        rubylib.delete(File.expand_path("..", __FILE__))
+        rubylib.delete(__dir__)
         env["RUBYLIB"] = rubylib.join(File::PATH_SEPARATOR)
       end
 
       env
     end
 
+    # Run block with environment present before Bundler was activated
     def with_original_env
       with_env(original_env) { yield }
     end
 
+    # @deprecated Use `with_unbundled_env` instead
     def with_clean_env
-      with_env(clean_env) { yield }
+      Bundler::SharedHelpers.major_deprecation(
+        2,
+        "`Bundler.with_clean_env` has been deprecated in favor of `Bundler.with_unbundled_env`. " \
+        "If you instead want the environment before bundler was originally loaded, use `Bundler.with_original_env`",
+        :print_caller_location => true
+      )
+
+      with_env(unbundled_env) { yield }
+    end
+
+    # Run block with all bundler-related variables removed
+    def with_unbundled_env
+      with_env(unbundled_env) { yield }
     end
 
+    # Run subcommand with the environment present before Bundler was activated
+    def original_system(*args)
+      with_original_env { Kernel.system(*args) }
+    end
+
+    # @deprecated Use `unbundled_system` instead
     def clean_system(*args)
-      with_clean_env { Kernel.system(*args) }
+      Bundler::SharedHelpers.major_deprecation(
+        2,
+        "`Bundler.clean_system` has been deprecated in favor of `Bundler.unbundled_system`. " \
+        "If you instead want to run the command in the environment before bundler was originally loaded, use `Bundler.original_system`",
+        :print_caller_location => true
+      )
+
+      with_env(unbundled_env) { Kernel.system(*args) }
     end
 
+    # Run subcommand in an environment with all bundler related variables removed
+    def unbundled_system(*args)
+      with_unbundled_env { Kernel.system(*args) }
+    end
+
+    # Run a `Kernel.exec` to a subcommand with the environment present before Bundler was activated
+    def original_exec(*args)
+      with_original_env { Kernel.exec(*args) }
+    end
+
+    # @deprecated Use `unbundled_exec` instead
     def clean_exec(*args)
-      with_clean_env { Kernel.exec(*args) }
+      Bundler::SharedHelpers.major_deprecation(
+        2,
+        "`Bundler.clean_exec` has been deprecated in favor of `Bundler.unbundled_exec`. " \
+        "If you instead want to exec to a command in the environment before bundler was originally loaded, use `Bundler.original_exec`",
+        :print_caller_location => true
+      )
+
+      with_env(unbundled_env) { Kernel.exec(*args) }
+    end
+
+    # Run a `Kernel.exec` to a subcommand in an environment with all bundler related variables removed
+    def unbundled_exec(*args)
+      with_env(unbundled_env) { Kernel.exec(*args) }
     end
 
     def local_platform
@@ -343,49 +485,21 @@ EOF
       # system binaries. If you put '-n foo' in your .gemrc, RubyGems will
       # install binstubs there instead. Unfortunately, RubyGems doesn't expose
       # that directory at all, so rather than parse .gemrc ourselves, we allow
-      # the directory to be set as well, via `bundle config bindir foo`.
+      # the directory to be set as well, via `bundle config set --local bindir foo`.
       Bundler.settings[:system_bindir] || Bundler.rubygems.gem_bindir
     end
 
-    def use_system_gems?
-      configured_bundle_path.use_system_gems?
+    def preferred_gemfile_name
+      Bundler.settings[:init_gems_rb] ? "gems.rb" : "Gemfile"
     end
 
-    def requires_sudo?
-      return @requires_sudo if defined?(@requires_sudo_ran)
-
-      sudo_present = which "sudo" if settings.allow_sudo?
-
-      if sudo_present
-        # the bundle path and subdirectories need to be writable for RubyGems
-        # to be able to unpack and install gems without exploding
-        path = bundle_path
-        path = path.parent until path.exist?
-
-        # bins are written to a different location on OS X
-        bin_dir = Pathname.new(Bundler.system_bindir)
-        bin_dir = bin_dir.parent until bin_dir.exist?
-
-        # if any directory is not writable, we need sudo
-        files = [path, bin_dir] | Dir[bundle_path.join("build_info/*").to_s] | Dir[bundle_path.join("*").to_s]
-        unwritable_files = files.reject {|f| File.writable?(f) }
-        sudo_needed = !unwritable_files.empty?
-        if sudo_needed
-          Bundler.ui.warn "Following files may not be writable, so sudo is needed:\n  #{unwritable_files.map(&:to_s).sort.join("\n  ")}"
-        end
-      end
-
-      @requires_sudo_ran = true
-      @requires_sudo = settings.allow_sudo? && sudo_present && sudo_needed
+    def use_system_gems?
+      configured_bundle_path.use_system_gems?
     end
 
     def mkdir_p(path, options = {})
-      if requires_sudo? && !options[:no_sudo]
-        sudo "mkdir -p '#{path}'" unless File.exist?(path)
-      else
-        SharedHelpers.filesystem_access(path, :write) do |p|
-          FileUtils.mkdir_p(p)
-        end
+      SharedHelpers.filesystem_access(path, :write) do |p|
+        FileUtils.mkdir_p(p)
       end
     end
 
@@ -393,7 +507,7 @@ EOF
       if File.file?(executable) && File.executable?(executable)
         executable
       elsif paths = ENV["PATH"]
-        quote = '"'.freeze
+        quote = '"'
         paths.split(File::PATH_SEPARATOR).find do |path|
           path = path[1..-2] if path.start_with?(quote) && path.end_with?(quote)
           executable_path = File.expand_path(executable, path)
@@ -402,40 +516,14 @@ EOF
       end
     end
 
-    def sudo(str)
-      SUDO_MUTEX.synchronize do
-        prompt = "\n\n" + <<-PROMPT.gsub(/^ {6}/, "").strip + " "
-        Your user account isn't allowed to install to the system RubyGems.
-        You can cancel this installation and run:
-
-            bundle install --path vendor/bundle
-
-        to install the gems into ./vendor/bundle/, or you can enter your password
-        and install the bundled gems to RubyGems using sudo.
-
-        Password:
-        PROMPT
-
-        unless @prompted_for_sudo ||= system(%(sudo -k -p "#{prompt}" true))
-          raise SudoNotPermittedError,
-            "Bundler requires sudo access to install at the moment. " \
-            "Try installing again, granting Bundler sudo access when prompted, or installing into a different path."
-        end
-
-        `sudo -p "#{prompt}" #{str}`
-      end
-    end
-
     def read_file(file)
       SharedHelpers.filesystem_access(file, :read) do
         File.open(file, "r:UTF-8", &:read)
       end
     end
 
-    def load_marshal(data)
-      Marshal.load(data)
-    rescue StandardError => e
-      raise MarshalError, "#{e.class}: #{e.message}"
+    def safe_load_marshal(data)
+      load_marshal(data, :marshal_proc => SAFE_MARSHAL_PROC)
     end
 
     def load_gemspec(file, validate = false)
@@ -471,7 +559,7 @@ EOF
 
     def git_present?
       return @git_present if defined?(@git_present)
-      @git_present = Bundler.which("git") || Bundler.which("git.exe")
+      @git_present = Bundler.which("git#{RbConfig::CONFIG["EXEEXT"]}")
     end
 
     def feature_flag
@@ -484,11 +572,16 @@ EOF
       reset_rubygems!
     end
 
+    def reset_settings_and_root!
+      @settings = nil
+      @root = nil
+    end
+
     def reset_paths!
       @bin_path = nil
       @bundler_major_version = nil
       @bundle_path = nil
-      @configured = nil
+      @configure = nil
       @configured_bundle_path = nil
       @definition = nil
       @load = nil
@@ -506,15 +599,32 @@ EOF
       @rubygems = nil
     end
 
-  private
+    def configure_gem_home_and_path(path = bundle_path)
+      configure_gem_path
+      configure_gem_home(path)
+      Bundler.rubygems.clear_paths
+    end
+
+    def self_manager
+      @self_manager ||= begin
+                          require_relative "bundler/self_manager"
+                          Bundler::SelfManager.new
+                        end
+    end
+
+    private
+
+    def load_marshal(data, marshal_proc: nil)
+      Marshal.load(data, marshal_proc)
+    rescue TypeError => e
+      raise MarshalError, "#{e.class}: #{e.message}"
+    end
 
     def eval_yaml_gemspec(path, contents)
-      Kernel.send(:require, "bundler/psyched_yaml")
+      Kernel.require "psych"
 
-      # If the YAML is invalid, Syck raises an ArgumentError, and Psych
-      # raises a Psych::SyntaxError. See psyched_yaml.rb for more info.
       Gem::Specification.from_yaml(contents)
-    rescue YamlLibrarySyntaxError, ArgumentError, Gem::EndOfYAMLException, Gem::Exception
+    rescue ::Psych::SyntaxError, ArgumentError, Gem::EndOfYAMLException, Gem::Exception
       eval_gemspec(path, contents)
     end
 
@@ -523,36 +633,29 @@ EOF
     rescue ScriptError, StandardError => e
       msg = "There was an error while loading `#{path.basename}`: #{e.message}"
 
-      if e.is_a?(LoadError) && RUBY_VERSION >= "1.9"
-        msg += "\nDoes it try to require a relative path? That's been removed in Ruby 1.9"
-      end
-
       raise GemspecError, Dsl::DSLError.new(msg, path, e.backtrace, contents)
     end
 
-    def configure_gem_home_and_path
-      configure_gem_path
-      configure_gem_home
-      bundle_path
-    end
-
-    def configure_gem_path(env = ENV)
-      blank_home = env["GEM_HOME"].nil? || env["GEM_HOME"].empty?
-      if !use_system_gems?
+    def configure_gem_path
+      unless use_system_gems?
         # this needs to be empty string to cause
         # PathSupport.split_gem_path to only load up the
         # Bundler --path setting as the GEM_PATH.
-        env["GEM_PATH"] = ""
-      elsif blank_home
-        possibles = [Bundler.rubygems.gem_dir, Bundler.rubygems.gem_path]
-        paths = possibles.flatten.compact.uniq.reject(&:empty?)
-        env["GEM_PATH"] = paths.join(File::PATH_SEPARATOR)
+        Bundler::SharedHelpers.set_env "GEM_PATH", ""
       end
     end
 
-    def configure_gem_home
-      Bundler::SharedHelpers.set_env "GEM_HOME", File.expand_path(bundle_path, root)
-      Bundler.rubygems.clear_paths
+    def configure_gem_home(path)
+      Bundler::SharedHelpers.set_env "GEM_HOME", path.to_s
+    end
+
+    def tmp_home_path
+      Kernel.send(:require, "tmpdir")
+      SharedHelpers.filesystem_access(Dir.tmpdir) do
+        path = Bundler.tmp
+        at_exit { Bundler.rm_rf(path) }
+        path
+      end
     end
 
     # @param env [Hash]