rubygems-update 3.0.6 → 3.2.14

data/bundler/lib/bundler/runtime.rb

@@ -34,14 +34,7 @@ module Bundler
         spec.load_paths.reject {|path| $LOAD_PATH.include?(path) }
       end.reverse.flatten
 
-      # See Gem::Specification#add_self_to_load_path (since RubyGems 1.8)
-      if insert_index = Bundler.rubygems.load_path_insert_index
-        # Gem directories must come after -I and ENV['RUBYLIB']
-        $LOAD_PATH.insert(insert_index, *load_paths)
-      else
-        # We are probably testing in core, -I and RUBYLIB don't apply
-        $LOAD_PATH.unshift(*load_paths)
-      end
+      Bundler.rubygems.add_to_load_path(load_paths)
 
       setup_manpath
 
@@ -50,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?
@@ -86,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
@@ -163,7 +146,7 @@ module Bundler
       gem_dirs             = Dir["#{Gem.dir}/gems/*"]
       gem_files            = Dir["#{Gem.dir}/cache/*.gem"]
       gemspec_files        = Dir["#{Gem.dir}/specifications/*.gemspec"]
-      extension_dirs       = Dir["#{Gem.dir}/extensions/*/*/*"]
+      extension_dirs       = Dir["#{Gem.dir}/extensions/*/*/*"] + Dir["#{Gem.dir}/bundler/gems/extensions/*/*/*"]
       spec_gem_paths       = []
       # need to keep git sources around
       spec_git_paths       = @definition.spec_git_paths
@@ -172,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)
@@ -220,7 +203,7 @@ module Bundler
       output
     end
 
-  private
+    private
 
     def prune_gem_cache(resolve, cache_path)
       cached = Dir["#{cache_path}/*.gem"]

data/bundler/lib/bundler/settings.rb

@@ -1,64 +1,51 @@
 # frozen_string_literal: true
 
-require "uri"
-
 module Bundler
   class Settings
-    autoload :Mirror,  "bundler/mirror"
-    autoload :Mirrors, "bundler/mirror"
-    autoload :Validator, "bundler/settings/validator"
+    autoload :Mirror,  File.expand_path("mirror", __dir__)
+    autoload :Mirrors, File.expand_path("mirror", __dir__)
+    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
-      cache_command_is_package
-      console_command
       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
-      error_on_stderr
       force_ruby_platform
       forget_cli_options
       frozen
       gem.coc
       gem.mit
-      global_path_appends_ruby_scope
       global_gem_cache
       ignore_messages
       init_gems_rb
-      list_command
-      lockfile_uses_separate_rubygems_sources
-      major_deprecations
       no_install
       no_prune
       only_update_to_newer_versions
       path_relative_to_cwd
       path.system
       plugins
-      prefer_gems_rb
+      prefer_patch
       print_only_version_number
       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
       use_gem_version_promoter_for_major_updates
-      viz_command
     ].freeze
 
     NUMBER_KEYS = %w[
@@ -75,28 +62,25 @@ module Bundler
     ].freeze
 
     DEFAULT_CONFIG = {
-      :disable_version_check => true,
-      :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
@@ -106,18 +90,6 @@ module Bundler
         temporary(key => value)
         value
       else
-        command = if value.nil?
-          "bundle config --delete #{key}"
-        else
-          "bundle config #{key} #{Array(value).join(":")}"
-        end
-
-        Bundler::SharedHelpers.major_deprecation 2,\
-          "flags passed to commands " \
-          "will no longer be automatically remembered. Instead please set flags " \
-          "you want remembered between commands using `bundle config " \
-          "<setting name> <setting value>`, i.e. `#{command}`"
-
         set_local(key, value)
       end
     end
@@ -151,9 +123,7 @@ 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
@@ -169,7 +139,11 @@ module Bundler
     end
 
     def mirror_for(uri)
-      uri = URI(uri.to_s) unless uri.is_a?(URI)
+      if uri.is_a?(String)
+        require_relative "vendored_uri"
+        uri = Bundler::URI(uri)
+      end
+
       gem_mirrors.for(uri.to_s).uri
     end
 
@@ -186,13 +160,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)
@@ -200,50 +172,51 @@ 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: #{converted_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}): #{converted_value(value, exposed_key).inspect}"
       end
 
-      if value = ENV[key]
+      if value = @env_config[key]
         locations << "Set via #{key}: #{converted_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}): #{converted_value(value, exposed_key).inspect}"
       end
 
       return ["You have not configured a value for `#{exposed_key}`"] if locations.empty?
       locations
     end
 
-    # for legacy reasons, in Bundler 1, the ruby scope isnt appended when the setting comes from ENV or the global config,
-    # nor do we respect :disable_shared_gems
+    # 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, Bundler.feature_flag.global_path_appends_ruby_scope?, 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], true, system_path, Bundler.feature_flag.default_install_uses_path?)
+      Path.new(nil, false)
     end
 
-    Path = Struct.new(:explicit_path, :append_ruby_scope, :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) if append_ruby_scope && !use_system_gems?
+        path = File.join(path, Bundler.ruby_scope) unless use_system_gems?
         path
       end
 
       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
@@ -296,9 +269,9 @@ 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
@@ -309,7 +282,21 @@ module Bundler
       "BUNDLE_#{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]
@@ -371,7 +358,7 @@ module Bundler
       return unless file
       SharedHelpers.filesystem_access(file) do |p|
         FileUtils.mkdir_p(p.dirname)
-        require "bundler/yaml_serializer"
+        require_relative "yaml_serializer"
         p.open("w") {|f| f.write(YAMLSerializer.dump(hash)) }
       end
     end
@@ -406,26 +393,12 @@ module Bundler
       Pathname.new(@root).join("config") if @root
     end
 
-    CONFIG_REGEX = %r{ # rubocop:disable Style/RegexpLiteral
-      ^
-      (BUNDLE_.+):\s # the key
-      (?: !\s)? # optional exclamation mark found with ruby 1.9.3
-      (['"]?) # optional opening quote
-      (.* # contents of the value
-        (?: # optionally, up until the next key
-          (\n(?!BUNDLE).+)*
-        )
-      )
-      \2 # matching closing quote
-      $
-    }xo
-
     def load_config(config_file)
       return {} if !config_file || ignore_config?
       SharedHelpers.filesystem_access(config_file, :read) do |file|
         valid_file = file.exist? && !file.size.zero?
         return {} unless valid_file
-        require "bundler/yaml_serializer"
+        require_relative "yaml_serializer"
         YAMLSerializer.load file.read
       end
     end
@@ -441,7 +414,7 @@ module Bundler
         (https?.*?) # URI
         (\.#{Regexp.union(PER_URI_OPTIONS)})? # optional suffix key
         \z
-      /ix
+      /ix.freeze
 
     # TODO: duplicates Rubygems#normalize_uri
     # TODO: is this the correct place to validate mirror URIs?
@@ -453,7 +426,8 @@ module Bundler
         suffix = $3
       end
       uri = "#{uri}/" unless uri.end_with?("/")
-      uri = URI(uri)
+      require_relative "vendored_uri"
+      uri = Bundler::URI(uri)
       unless uri.absolute?
         raise ArgumentError, format("Gem sources must be absolute. You provided '%s'.", uri)
       end

data/bundler/lib/bundler/setup.rb

@@ -1,28 +1,27 @@
 # frozen_string_literal: true
 
-require "bundler/shared_helpers"
+require_relative "shared_helpers"
 
 if Bundler::SharedHelpers.in_bundle?
-  require "bundler"
+  require_relative "../bundler"
 
   if STDOUT.tty? || ENV["BUNDLER_FORCE_TTY"]
     begin
-      Bundler.setup
+      Bundler.ui.silence { Bundler.setup }
     rescue Bundler::BundlerError => e
-      puts "\e[31m#{e.message}\e[0m"
-      puts e.backtrace.join("\n") if ENV["DEBUG"]
+      Bundler.ui.warn "\e[31m#{e.message}\e[0m"
+      Bundler.ui.warn e.backtrace.join("\n") if ENV["DEBUG"]
       if e.is_a?(Bundler::GemNotFound)
-        puts "\e[33mRun `bundle install` to install missing gems.\e[0m"
+        Bundler.ui.warn "\e[33mRun `bundle install` to install missing gems.\e[0m"
       end
       exit e.status_code
     end
   else
-    Bundler.setup
+    Bundler.ui.silence { Bundler.setup }
   end
 
-  # Add bundler to the load path after disabling system gems
-  bundler_lib = File.expand_path("../..", __FILE__)
-  $LOAD_PATH.unshift(bundler_lib) unless $LOAD_PATH.include?(bundler_lib)
-
-  Bundler.ui = nil
+  # We might be in the middle of shelling out to rubygems
+  # (RUBYOPT=-rbundler/setup), so we need to give rubygems the opportunity of
+  # not being silent.
+  Gem::DefaultUserInteraction.ui = nil
 end

data/bundler/lib/bundler/shared_helpers.rb

@@ -1,38 +1,25 @@
 # frozen_string_literal: true
 
-require "bundler/compatibility_guard"
-
 require "pathname"
-require "rubygems"
-
-require "bundler/version"
-require "bundler/constants"
-require "bundler/rubygems_integration"
-require "bundler/current_ruby"
-
-module Gem
-  class Dependency
-    # This is only needed for RubyGems < 1.4
-    unless method_defined? :requirement
-      def requirement
-        version_requirements
-      end
-    end
-  end
-end
+require "rbconfig"
+
+require_relative "version"
+require_relative "constants"
+require_relative "rubygems_integration"
+require_relative "current_ruby"
 
 module Bundler
   module SharedHelpers
     def root
       gemfile = find_gemfile
       raise GemfileNotFound, "Could not locate Gemfile" unless gemfile
-      Pathname.new(gemfile).untaint.expand_path.parent
+      Pathname.new(gemfile).tap{|x| x.untaint if RUBY_VERSION < "2.7" }.expand_path.parent
     end
 
     def default_gemfile
-      gemfile = find_gemfile(:order_matters)
+      gemfile = find_gemfile
       raise GemfileNotFound, "Could not locate Gemfile" unless gemfile
-      Pathname.new(gemfile).untaint.expand_path
+      Pathname.new(gemfile).tap{|x| x.untaint if RUBY_VERSION < "2.7" }.expand_path
     end
 
     def default_lockfile
@@ -41,7 +28,7 @@ module Bundler
       case gemfile.basename.to_s
       when "gems.rb" then Pathname.new(gemfile.sub(/.rb$/, ".locked"))
       else Pathname.new("#{gemfile}.lock")
-      end.untaint
+      end.tap{|x| x.untaint if RUBY_VERSION < "2.7" }
     end
 
     def default_bundle_dir
@@ -113,9 +100,7 @@ module Bundler
     #
     # @see {Bundler::PermissionError}
     def filesystem_access(path, action = :write, &block)
-      # Use block.call instead of yield because of a bug in Ruby 2.2.2
-      # See https://github.com/bundler/bundler/issues/5341 for details
-      block.call(path.dup.untaint)
+      yield(path.dup.tap{|x| x.untaint if RUBY_VERSION < "2.7" })
     rescue Errno::EACCES
       raise PermissionError.new(path, action)
     rescue Errno::EAGAIN
@@ -139,34 +124,32 @@ module Bundler
       namespace.const_get(constant_name)
     end
 
-    def major_deprecation(major_version, message)
-      if Bundler.bundler_major_version >= major_version
-        require "bundler/errors"
-        raise DeprecatedError, "[REMOVED FROM #{major_version}.0] #{message}"
+    def major_deprecation(major_version, message, print_caller_location: false)
+      if print_caller_location
+        caller_location = caller_locations(2, 2).first
+        message = "#{message} (called at #{caller_location.path}:#{caller_location.lineno})"
+      end
+
+      bundler_major_version = Bundler.bundler_major_version
+      if bundler_major_version > major_version
+        require_relative "errors"
+        raise DeprecatedError, "[REMOVED] #{message}"
       end
 
-      return unless prints_major_deprecations?
-      @major_deprecation_ui ||= Bundler::UI::Shell.new("no-color" => true)
-      ui = Bundler.ui.is_a?(@major_deprecation_ui.class) ? Bundler.ui : @major_deprecation_ui
-      ui.warn("[DEPRECATED FOR #{major_version}.0] #{message}")
+      return unless bundler_major_version >= major_version && prints_major_deprecations?
+      Bundler.ui.warn("[DEPRECATED] #{message}")
     end
 
     def print_major_deprecations!
       multiple_gemfiles = search_up(".") do |dir|
         gemfiles = gemfile_names.select {|gf| File.file? File.expand_path(gf, dir) }
         next if gemfiles.empty?
-        break false if gemfiles.size == 1
+        break gemfiles.size != 1
       end
-      if multiple_gemfiles && Bundler.bundler_major_version == 1
-        Bundler::SharedHelpers.major_deprecation 2, \
-          "gems.rb and gems.locked will be preferred to Gemfile and Gemfile.lock."
-      end
-
-      if RUBY_VERSION < "2"
-        major_deprecation(2, "Bundler will only support ruby >= 2.0, you are running #{RUBY_VERSION}")
-      end
-      return if Bundler.rubygems.provides?(">= 2")
-      major_deprecation(2, "Bundler will only support rubygems >= 2.0, you are running #{Bundler.rubygems.version}")
+      return unless multiple_gemfiles
+      message = "Multiple gemfiles (gems.rb and Gemfile) detected. " \
+                "Make sure you remove Gemfile and Gemfile.lock since bundler is ignoring them in favor of gems.rb and gems.rb.locked."
+      Bundler.ui.warn message
     end
 
     def trap(signal, override = false, &block)
@@ -211,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
@@ -229,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
@@ -243,16 +226,14 @@ module Bundler
       raise Bundler::PathError, message
     end
 
-    def find_gemfile(order_matters = false)
+    def find_gemfile
       given = ENV["BUNDLE_GEMFILE"]
       return given if given && !given.empty?
-      names = gemfile_names
-      names.reverse! if order_matters && Bundler.feature_flag.prefer_gems_rb?
-      find_file(*names)
+      find_file(*gemfile_names)
     end
 
     def gemfile_names
-      ["Gemfile", "gems.rb"]
+      ["gems.rb", "Gemfile"]
     end
 
     def find_file(*names)
@@ -269,14 +250,14 @@ module Bundler
 
     def search_up(*names)
       previous = nil
-      current  = File.expand_path(SharedHelpers.pwd).untaint
+      current  = File.expand_path(SharedHelpers.pwd).tap{|x| x.untaint if RUBY_VERSION < "2.7" }
 
       until !File.directory?(current) || current == previous
         if ENV["BUNDLE_SPEC_RUN"]
           # avoid stepping above the tmp directory when testing
-          gemspec = if ENV["BUNDLE_RUBY"] && ENV["BUNDLE_GEM"]
+          gemspec = if ENV["GEM_COMMAND"]
             # for Ruby Core
-            "lib/bundler.gemspec"
+            "lib/bundler/bundler.gemspec"
           else
             "bundler.gemspec"
           end
@@ -306,21 +287,17 @@ module Bundler
     public :set_env
 
     def set_bundle_variables
-      begin
-        exe_file = Bundler.rubygems.bin_path("bundler", "bundle", VERSION)
-        unless File.exist?(exe_file)
-          exe_file = File.expand_path("../../../exe/bundle", __FILE__)
-        end
-        Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", exe_file
-      rescue Gem::GemNotFoundException
-        exe_file = File.expand_path("../../../exe/bundle", __FILE__)
-        # for Ruby core repository
-        exe_file = File.expand_path("../../../../bin/bundle", __FILE__) unless File.exist?(exe_file)
-        Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", exe_file
-      end
+      # bundler exe & lib folders have same root folder, typical gem installation
+      exe_file = File.expand_path("../../../exe/bundle", __FILE__)
+
+      # for Ruby core repository testing
+      exe_file = File.expand_path("../../../libexec/bundle", __FILE__) unless File.exist?(exe_file)
 
-      # Set BUNDLE_GEMFILE
-      Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", find_gemfile(:order_matters).to_s
+      # bundler is a default gem, exe path is separate
+      exe_file = Bundler.rubygems.bin_path("bundler", "bundle", VERSION) unless File.exist?(exe_file)
+
+      Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", exe_file
+      Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", find_gemfile.to_s
       Bundler::SharedHelpers.set_env "BUNDLER_VERSION", Bundler::VERSION
     end
 
@@ -333,14 +310,15 @@ module Bundler
 
     def set_rubyopt
       rubyopt = [ENV["RUBYOPT"]].compact
-      return if !rubyopt.empty? && rubyopt.first =~ %r{-rbundler/setup}
-      rubyopt.unshift %(-rbundler/setup)
+      setup_require = "-r#{File.expand_path("setup", __dir__)}"
+      return if !rubyopt.empty? && rubyopt.first =~ /#{setup_require}/
+      rubyopt.unshift setup_require
       Bundler::SharedHelpers.set_env "RUBYOPT", rubyopt.join(" ")
     end
 
     def set_rubylib
       rubylib = (ENV["RUBYLIB"] || "").split(File::PATH_SEPARATOR)
-      rubylib.unshift bundler_ruby_lib
+      rubylib.unshift bundler_ruby_lib unless RbConfig::CONFIG["rubylibdir"] == bundler_ruby_lib
       Bundler::SharedHelpers.set_env "RUBYLIB", rubylib.uniq.join(File::PATH_SEPARATOR)
     end
 
@@ -349,9 +327,6 @@ module Bundler
     end
 
     def clean_load_path
-      # handle 1.9 where system gems are always on the load path
-      return unless defined?(::Gem)
-
       bundler_lib = bundler_ruby_lib
 
       loaded_gem_paths = Bundler.rubygems.loaded_gem_paths
@@ -371,10 +346,9 @@ module Bundler
     end
 
     def prints_major_deprecations?
-      require "bundler"
-      deprecation_release = Bundler::VERSION.split(".").drop(1).include?("99")
-      return false if !deprecation_release && !Bundler.settings[:major_deprecations]
-      require "bundler/deprecate"
+      require_relative "../bundler"
+      return false if Bundler.settings[:silence_deprecations]
+      require_relative "deprecate"
       return false if Bundler::Deprecate.skip
       true
     end