rubygems-update 3.3.18 → 3.6.2

data/lib/rubygems/config_file.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
 # See LICENSE.txt for permissions.
 #++
 
-require_relative 'user_interaction'
-require 'rbconfig'
+require_relative "user_interaction"
+require "rbconfig"
 
 ##
 # Gem::ConfigFile RubyGems options and gem command options from gemrc.
@@ -39,13 +40,15 @@ require 'rbconfig'
 class Gem::ConfigFile
   include Gem::UserInteraction
 
-  DEFAULT_BACKTRACE = false
+  DEFAULT_BACKTRACE = true
   DEFAULT_BULK_THRESHOLD = 1000
   DEFAULT_VERBOSITY = true
   DEFAULT_UPDATE_SOURCES = true
   DEFAULT_CONCURRENT_DOWNLOADS = 8
   DEFAULT_CERT_EXPIRATION_LENGTH_DAYS = 365
   DEFAULT_IPV4_FALLBACK_ENABLED = false
+  # TODO: Use false as default value for this option in RubyGems 4.0
+  DEFAULT_INSTALL_EXTENSION_IN_LIB = true
 
   ##
   # For Ruby packagers to set configuration defaults.  Set in
@@ -71,7 +74,7 @@ class Gem::ConfigFile
 
   # :startdoc:
 
-  SYSTEM_WIDE_CONFIG_FILE = File.join SYSTEM_CONFIG_PATH, 'gemrc'
+  SYSTEM_WIDE_CONFIG_FILE = File.join SYSTEM_CONFIG_PATH, "gemrc"
 
   ##
   # List of arguments supplied to the config file object.
@@ -141,6 +144,11 @@ class Gem::ConfigFile
 
   attr_accessor :cert_expiration_length_days
 
+  ##
+  # Install extensions into lib as well as into the extension directory.
+
+  attr_accessor :install_extension_in_lib
+
   ##
   # == Experimental ==
   # Fallback to IPv4 when IPv6 is not reachable or slow (default: false)
@@ -182,40 +190,54 @@ class Gem::ConfigFile
     @update_sources = DEFAULT_UPDATE_SOURCES
     @concurrent_downloads = DEFAULT_CONCURRENT_DOWNLOADS
     @cert_expiration_length_days = DEFAULT_CERT_EXPIRATION_LENGTH_DAYS
-    @ipv4_fallback_enabled = ENV['IPV4_FALLBACK_ENABLED'] == 'true' || DEFAULT_IPV4_FALLBACK_ENABLED
+    @install_extension_in_lib = DEFAULT_INSTALL_EXTENSION_IN_LIB
+    @ipv4_fallback_enabled = ENV["IPV4_FALLBACK_ENABLED"] == "true" || DEFAULT_IPV4_FALLBACK_ENABLED
 
     operating_system_config = Marshal.load Marshal.dump(OPERATING_SYSTEM_DEFAULTS)
     platform_config = Marshal.load Marshal.dump(PLATFORM_DEFAULTS)
     system_config = load_file SYSTEM_WIDE_CONFIG_FILE
-    user_config = load_file config_file_name.dup.tap(&Gem::UNTAINT)
+    user_config = load_file config_file_name
 
-    environment_config = (ENV['GEMRC'] || '')
-      .split(File::PATH_SEPARATOR).inject({}) do |result, file|
+    environment_config = (ENV["GEMRC"] || "").
+      split(File::PATH_SEPARATOR).inject({}) do |result, file|
         result.merge load_file file
       end
 
     @hash = operating_system_config.merge platform_config
-    unless args.index '--norc'
+    unless args.index "--norc"
       @hash = @hash.merge system_config
       @hash = @hash.merge user_config
       @hash = @hash.merge environment_config
     end
 
-    # HACK these override command-line args, which is bad
+    @hash.transform_keys! do |k|
+      # gemhome and gempath are not working with symbol keys
+      if %w[backtrace bulk_threshold verbose update_sources cert_expiration_length_days
+            install_extension_in_lib ipv4_fallback_enabled sources disable_default_gem_server
+            ssl_verify_mode ssl_ca_cert ssl_client_cert].include?(k)
+        k.to_sym
+      else
+        k
+      end
+    end
+
+    # HACK: these override command-line args, which is bad
     @backtrace                   = @hash[:backtrace]                   if @hash.key? :backtrace
     @bulk_threshold              = @hash[:bulk_threshold]              if @hash.key? :bulk_threshold
-    @home                        = @hash[:gemhome]                     if @hash.key? :gemhome
-    @path                        = @hash[:gempath]                     if @hash.key? :gempath
-    @update_sources              = @hash[:update_sources]              if @hash.key? :update_sources
     @verbose                     = @hash[:verbose]                     if @hash.key? :verbose
-    @disable_default_gem_server  = @hash[:disable_default_gem_server]  if @hash.key? :disable_default_gem_server
-    @sources                     = @hash[:sources]                     if @hash.key? :sources
+    @update_sources              = @hash[:update_sources]              if @hash.key? :update_sources
+    # TODO: We should handle concurrent_downloads same as other options
     @cert_expiration_length_days = @hash[:cert_expiration_length_days] if @hash.key? :cert_expiration_length_days
+    @install_extension_in_lib    = @hash[:install_extension_in_lib]    if @hash.key? :install_extension_in_lib
     @ipv4_fallback_enabled       = @hash[:ipv4_fallback_enabled]       if @hash.key? :ipv4_fallback_enabled
 
-    @ssl_verify_mode  = @hash[:ssl_verify_mode]  if @hash.key? :ssl_verify_mode
-    @ssl_ca_cert      = @hash[:ssl_ca_cert]      if @hash.key? :ssl_ca_cert
-    @ssl_client_cert  = @hash[:ssl_client_cert]  if @hash.key? :ssl_client_cert
+    @home                        = @hash[:gemhome]                     if @hash.key? :gemhome
+    @path                        = @hash[:gempath]                     if @hash.key? :gempath
+    @sources                     = @hash[:sources]                     if @hash.key? :sources
+    @disable_default_gem_server  = @hash[:disable_default_gem_server]  if @hash.key? :disable_default_gem_server
+    @ssl_verify_mode             = @hash[:ssl_verify_mode]             if @hash.key? :ssl_verify_mode
+    @ssl_ca_cert                 = @hash[:ssl_ca_cert]                 if @hash.key? :ssl_ca_cert
+    @ssl_client_cert             = @hash[:ssl_client_cert]             if @hash.key? :ssl_client_cert
 
     @api_keys         = nil
     @rubygems_api_key = nil
@@ -240,9 +262,9 @@ class Gem::ConfigFile
     return if Gem.win_platform? # windows doesn't write 0600 as 0600
     return unless File.exist? credentials_path
 
-    existing_permissions = File.stat(credentials_path).mode & 0777
+    existing_permissions = File.stat(credentials_path).mode & 0o777
 
-    return if existing_permissions == 0600
+    return if existing_permissions == 0o600
 
     alert_error <<-ERROR
 Your gem push credentials file located at:
@@ -269,7 +291,7 @@ if you believe they were disclosed to a third party.
   # Location of RubyGems.org credentials
 
   def credentials_path
-    credentials = File.join Gem.user_home, '.gem', 'credentials'
+    credentials = File.join Gem.user_home, ".gem", "credentials"
     if File.exist? credentials
       credentials
     else
@@ -320,14 +342,12 @@ if you believe they were disclosed to a third party.
     config = load_file(credentials_path).merge(host => api_key)
 
     dirname = File.dirname credentials_path
-    require 'fileutils'
+    require "fileutils"
     FileUtils.mkdir_p(dirname)
 
-    Gem.load_yaml
-
-    permissions = 0600 & (~File.umask)
-    File.open(credentials_path, 'w', permissions) do |f|
-      f.write config.to_yaml
+    permissions = 0o600 & (~File.umask)
+    File.open(credentials_path, "w", permissions) do |f|
+      f.write self.class.dump_with_rubygems_yaml(config)
     end
 
     load_api_keys # reload
@@ -343,20 +363,18 @@ if you believe they were disclosed to a third party.
   end
 
   def load_file(filename)
-    Gem.load_yaml
-
     yaml_errors = [ArgumentError]
-    yaml_errors << Psych::SyntaxError if defined?(Psych::SyntaxError)
 
     return {} unless filename && !filename.empty? && File.exist?(filename)
 
     begin
-      content = Gem::SafeYAML.load(File.read(filename))
-      unless content.kind_of? Hash
+      config = self.class.load_with_rubygems_config_hash(File.read(filename))
+      if config.keys.any? {|k| k.to_s.gsub(%r{https?:\/\/}, "").include?(": ") }
         warn "Failed to load #{filename} because it doesn't contain valid YAML hash"
         return {}
+      else
+        return config
       end
-      return content
     rescue *yaml_errors => e
       warn "Failed to load #{filename}, #{e}"
     rescue Errno::EACCES
@@ -368,7 +386,21 @@ if you believe they were disclosed to a third party.
 
   # True if the backtrace option has been specified, or debug is on.
   def backtrace
-    @backtrace or $DEBUG
+    @backtrace || $DEBUG
+  end
+
+  # Check state file is writable. Creates empty file if not present to ensure we can write to it.
+  def state_file_writable?
+    if File.exist?(state_file_name)
+      File.writable?(state_file_name)
+    else
+      require "fileutils"
+      FileUtils.mkdir_p File.dirname(state_file_name)
+      File.open(state_file_name, "w") {}
+      true
+    end
+  rescue Errno::EACCES
+    false
   end
 
   # The name of the configuration file.
@@ -376,6 +408,25 @@ if you believe they were disclosed to a third party.
     @config_file_name || Gem.config_file
   end
 
+  # The name of the state file.
+  def state_file_name
+    Gem.state_file
+  end
+
+  # Reads time of last update check from state file
+  def last_update_check
+    if File.readable?(state_file_name)
+      File.read(state_file_name).to_i
+    else
+      0
+    end
+  end
+
+  # Writes time of last update check to state file
+  def last_update_check=(timestamp)
+    File.write(state_file_name, timestamp.to_s) if state_file_writable?
+  end
+
   # Delegates to @hash
   def each(&block)
     hash = @hash.dup
@@ -389,7 +440,7 @@ if you believe they were disclosed to a third party.
     yield :backtrace, @backtrace
     yield :bulk_threshold, @bulk_threshold
 
-    yield 'config_file_name', @config_file_name if @config_file_name
+    yield "config_file_name", @config_file_name if @config_file_name
 
     hash.each(&block)
   end
@@ -405,7 +456,7 @@ if you believe they were disclosed to a third party.
       when /^--debug$/ then
         $DEBUG = true
 
-        warn 'NOTE:  Debugging mode prints all exceptions even when rescued'
+        warn "NOTE:  Debugging mode prints all exceptions even when rescued"
       else
         @args << arg
       end
@@ -434,6 +485,9 @@ if you believe they were disclosed to a third party.
     yaml_hash[:concurrent_downloads] =
       @hash.fetch(:concurrent_downloads, DEFAULT_CONCURRENT_DOWNLOADS)
 
+    yaml_hash[:install_extension_in_lib] =
+      @hash.fetch(:install_extension_in_lib, DEFAULT_INSTALL_EXTENSION_IN_LIB)
+
     yaml_hash[:ssl_verify_mode] =
       @hash[:ssl_verify_mode] if @hash.key? :ssl_verify_mode
 
@@ -443,53 +497,109 @@ if you believe they were disclosed to a third party.
     yaml_hash[:ssl_client_cert] =
       @hash[:ssl_client_cert] if @hash.key? :ssl_client_cert
 
-    keys = yaml_hash.keys.map {|key| key.to_s }
-    keys << 'debug'
+    keys = yaml_hash.keys.map(&:to_s)
+    keys << "debug"
     re = Regexp.union(*keys)
 
     @hash.each do |key, value|
       key = key.to_s
-      next if key =~ re
+      next if key&.match?(re)
       yaml_hash[key.to_s] = value
     end
 
-    yaml_hash.to_yaml
+    self.class.dump_with_rubygems_yaml(yaml_hash)
   end
 
   # Writes out this config file, replacing its source.
   def write
-    require 'fileutils'
+    require "fileutils"
     FileUtils.mkdir_p File.dirname(config_file_name)
 
-    File.open config_file_name, 'w' do |io|
+    File.open config_file_name, "w" do |io|
       io.write to_yaml
     end
   end
 
   # Return the configuration information for +key+.
   def [](key)
-    @hash[key.to_s]
+    @hash[key] || @hash[key.to_s]
   end
 
   # Set configuration option +key+ to +value+.
   def []=(key, value)
-    @hash[key.to_s] = value
+    @hash[key] = value
   end
 
   def ==(other) # :nodoc:
-    self.class === other and
-      @backtrace == other.backtrace and
-      @bulk_threshold == other.bulk_threshold and
-      @verbose == other.verbose and
-      @update_sources == other.update_sources and
+    self.class === other &&
+      @backtrace == other.backtrace &&
+      @bulk_threshold == other.bulk_threshold &&
+      @verbose == other.verbose &&
+      @update_sources == other.update_sources &&
       @hash == other.hash
   end
 
   attr_reader :hash
   protected :hash
 
+  def self.dump_with_rubygems_yaml(content)
+    content.transform_keys! do |k|
+      k.is_a?(Symbol) ? ":#{k}" : k
+    end
+
+    require_relative "yaml_serializer"
+    Gem::YAMLSerializer.dump(content)
+  end
+
+  def self.load_with_rubygems_config_hash(yaml)
+    require_relative "yaml_serializer"
+
+    content = Gem::YAMLSerializer.load(yaml)
+    deep_transform_config_keys!(content)
+  end
+
   private
 
+  def self.deep_transform_config_keys!(config)
+    config.transform_keys! do |k|
+      if k.match?(/\A:(.*)\Z/)
+        k[1..-1].to_sym
+      elsif k.include?("__") || k.match?(%r{/\Z})
+        if k.is_a?(Symbol)
+          k.to_s.gsub(/__/,".").gsub(%r{/\Z}, "").to_sym
+        else
+          k.dup.gsub(/__/,".").gsub(%r{/\Z}, "")
+        end
+      else
+        k
+      end
+    end
+
+    config.transform_values! do |v|
+      if v.is_a?(String)
+        if v.match?(/\A:(.*)\Z/)
+          v[1..-1].to_sym
+        elsif v.match?(/\A[+-]?\d+\Z/)
+          v.to_i
+        elsif v.match?(/\Atrue|false\Z/)
+          v == "true"
+        elsif v.empty?
+          nil
+        else
+          v
+        end
+      elsif v.empty?
+        nil
+      elsif v.is_a?(Hash)
+        deep_transform_config_keys!(v)
+      else
+        v
+      end
+    end
+
+    config
+  end
+
   def set_config_file_name(args)
     @config_file_name = ENV["GEMRC"]
     need_config_file_name = false
@@ -500,7 +610,7 @@ if you believe they were disclosed to a third party.
         need_config_file_name = false
       elsif arg =~ /^--config-file=(.*)/
         @config_file_name = $1
-      elsif arg =~ /^--config-file$/
+      elsif /^--config-file$/.match?(arg)
         need_config_file_name = true
       end
     end

data/lib/rubygems/core_ext/kernel_gem.rb

@@ -1,12 +1,6 @@
 # frozen_string_literal: true
-##
-# RubyGems adds the #gem method to allow activation of specific gem versions
-# and overrides the #require method on Kernel to make gems appear as if they
-# live on the <code>$LOAD_PATH</code>.  See the documentation of these methods
-# for further detail.
 
 module Kernel
-
   ##
   # Use Kernel#gem to activate a specific version of +gem_name+.
   #
@@ -39,12 +33,12 @@ module Kernel
   #   GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb
 
   def gem(gem_name, *requirements) # :doc:
-    skip_list = (ENV['GEM_SKIP'] || "").split(/:/)
+    skip_list = (ENV["GEM_SKIP"] || "").split(/:/)
     raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name
 
-    if gem_name.kind_of? Gem::Dependency
+    if gem_name.is_a? Gem::Dependency
       unless Gem::Deprecate.skip
-        warn "#{Gem.location_of_caller.join ':'}:Warning: Kernel.gem no longer "\
+        warn "#{Gem.location_of_caller.join ":"}:Warning: Kernel.gem no longer "\
           "accepts a Gem::Dependency object, please pass the name "\
           "and requirements directly"
       end
@@ -71,5 +65,4 @@ module Kernel
   end
 
   private :gem
-
 end

data/lib/rubygems/core_ext/kernel_require.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
 # See LICENSE.txt for permissions.
 #++
 
-require 'monitor'
+require "monitor"
 
 module Kernel
-
   RUBYGEMS_ACTIVATION_MONITOR = Monitor.new # :nodoc:
 
   # Make sure we have a reference to Ruby's original Kernel#require
   unless defined?(gem_original_require)
-    alias gem_original_require require
+    # :stopdoc:
+    alias_method :gem_original_require, :require
     private :gem_original_require
+    # :startdoc:
   end
 
-  file = Gem::KERNEL_WARN_IGNORES_INTERNAL_ENTRIES ? "<internal:#{__FILE__}>" : __FILE__
-  module_eval <<'RUBY', file, __LINE__ + 1 # rubocop:disable Style/EvalWithLocation
   ##
   # When RubyGems is required, Kernel#require is replaced with our own which
   # is capable of loading gems on demand.
@@ -33,143 +33,117 @@ module Kernel
   # The normal <tt>require</tt> functionality of returning false if
   # that file has already been loaded is preserved.
 
-  def require(path)
-    if RUBYGEMS_ACTIVATION_MONITOR.respond_to?(:mon_owned?)
-      monitor_owned = RUBYGEMS_ACTIVATION_MONITOR.mon_owned?
-    end
-    RUBYGEMS_ACTIVATION_MONITOR.enter
-
-    path = path.to_path if path.respond_to? :to_path
-
-    if spec = Gem.find_unresolved_default_spec(path)
-      # Ensure -I beats a default gem
-      resolved_path = begin
-        rp = nil
-        load_path_check_index = Gem.load_path_insert_index - Gem.activated_gem_paths
-        Gem.suffixes.each do |s|
-          $LOAD_PATH[0...load_path_check_index].each do |lp|
-            safe_lp = lp.dup.tap(&Gem::UNTAINT)
-            begin
-              if File.symlink? safe_lp # for backward compatibility
+  def require(path) # :doc:
+    return gem_original_require(path) unless Gem.discover_gems_on_require
+
+    RUBYGEMS_ACTIVATION_MONITOR.synchronize do
+      path = File.path(path)
+
+      # If +path+ belongs to a default gem, we activate it and then go straight
+      # to normal require
+
+      if spec = Gem.find_default_spec(path)
+        name = spec.name
+
+        next if Gem.loaded_specs[name]
+
+        # Ensure -I beats a default gem
+        resolved_path = begin
+          rp = nil
+          load_path_check_index = Gem.load_path_insert_index - Gem.activated_gem_paths
+          Gem.suffixes.find do |s|
+            $LOAD_PATH[0...load_path_check_index].find do |lp|
+              if File.symlink? lp # for backward compatibility
                 next
               end
-            rescue SecurityError
-              RUBYGEMS_ACTIVATION_MONITOR.exit
-              raise
-            end
 
-            full_path = File.expand_path(File.join(safe_lp, "#{path}#{s}"))
-            if File.file?(full_path)
-              rp = full_path
-              break
+              full_path = File.expand_path(File.join(lp, "#{path}#{s}"))
+              rp = full_path if File.file?(full_path)
             end
           end
-          break if rp
+          rp
         end
-        rp
-      end
 
-      begin
-        Kernel.send(:gem, spec.name, Gem::Requirement.default_prerelease)
-      rescue Exception
-        RUBYGEMS_ACTIVATION_MONITOR.exit
-        raise
-      end unless resolved_path
-    end
+        Kernel.send(:gem, name, Gem::Requirement.default_prerelease) unless
+          resolved_path
 
-    # If there are no unresolved deps, then we can use just try
-    # normal require handle loading a gem from the rescue below.
+        next
+      end
 
-    if Gem::Specification.unresolved_deps.empty?
-      RUBYGEMS_ACTIVATION_MONITOR.exit
-      return gem_original_require(path)
-    end
+      # If there are no unresolved deps, then we can use just try
+      # normal require handle loading a gem from the rescue below.
 
-    # If +path+ is for a gem that has already been loaded, don't
-    # bother trying to find it in an unresolved gem, just go straight
-    # to normal require.
-    #--
-    # TODO request access to the C implementation of this to speed up RubyGems
+      if Gem::Specification.unresolved_deps.empty?
+        next
+      end
 
-    if Gem::Specification.find_active_stub_by_path(path)
-      RUBYGEMS_ACTIVATION_MONITOR.exit
-      return gem_original_require(path)
-    end
+      # If +path+ is for a gem that has already been loaded, don't
+      # bother trying to find it in an unresolved gem, just go straight
+      # to normal require.
+      #--
+      # TODO request access to the C implementation of this to speed up RubyGems
 
-    # Attempt to find +path+ in any unresolved gems...
-
-    found_specs = Gem::Specification.find_in_unresolved path
-
-    # If there are no directly unresolved gems, then try and find +path+
-    # in any gems that are available via the currently unresolved gems.
-    # For example, given:
-    #
-    #   a => b => c => d
-    #
-    # If a and b are currently active with c being unresolved and d.rb is
-    # requested, then find_in_unresolved_tree will find d.rb in d because
-    # it's a dependency of c.
-    #
-    if found_specs.empty?
-      found_specs = Gem::Specification.find_in_unresolved_tree path
-
-      found_specs.each do |found_spec|
-        found_spec.activate
+      if Gem::Specification.find_active_stub_by_path(path)
+        next
       end
 
-    # We found +path+ directly in an unresolved gem. Now we figure out, of
-    # the possible found specs, which one we should activate.
-    else
+      # Attempt to find +path+ in any unresolved gems...
 
-      # Check that all the found specs are just different
-      # versions of the same gem
-      names = found_specs.map(&:name).uniq
+      found_specs = Gem::Specification.find_in_unresolved path
 
-      if names.size > 1
-        RUBYGEMS_ACTIVATION_MONITOR.exit
-        raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ', '}"
-      end
+      # If there are no directly unresolved gems, then try and find +path+
+      # in any gems that are available via the currently unresolved gems.
+      # For example, given:
+      #
+      #   a => b => c => d
+      #
+      # If a and b are currently active with c being unresolved and d.rb is
+      # requested, then find_in_unresolved_tree will find d.rb in d because
+      # it's a dependency of c.
+      #
+      if found_specs.empty?
+        found_specs = Gem::Specification.find_in_unresolved_tree path
 
-      # Ok, now find a gem that has no conflicts, starting
-      # at the highest version.
-      valid = found_specs.find {|s| !s.has_conflicts? }
+        found_specs.each(&:activate)
 
-      unless valid
-        le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"
-        le.name = names.first
-        RUBYGEMS_ACTIVATION_MONITOR.exit
-        raise le
-      end
+      # We found +path+ directly in an unresolved gem. Now we figure out, of
+      # the possible found specs, which one we should activate.
+      else
 
-      valid.activate
-    end
+        # Check that all the found specs are just different
+        # versions of the same gem
+        names = found_specs.map(&:name).uniq
 
-    RUBYGEMS_ACTIVATION_MONITOR.exit
-    return gem_original_require(path)
-  rescue LoadError => load_error
-    RUBYGEMS_ACTIVATION_MONITOR.enter
+        if names.size > 1
+          raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ", "}"
+        end
 
-    begin
-      if load_error.path == path and Gem.try_activate(path)
-        require_again = true
+        # Ok, now find a gem that has no conflicts, starting
+        # at the highest version.
+        valid = found_specs.find {|s| !s.has_conflicts? }
+
+        unless valid
+          le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"
+          le.name = names.first
+          raise le
+        end
+
+        valid.activate
       end
-    ensure
-      RUBYGEMS_ACTIVATION_MONITOR.exit
     end
 
-    return gem_original_require(path) if require_again
+    begin
+      gem_original_require(path)
+    rescue LoadError => load_error
+      if load_error.path == path &&
+         RUBYGEMS_ACTIVATION_MONITOR.synchronize { Gem.try_activate(path) }
 
-    raise load_error
-  ensure
-    if RUBYGEMS_ACTIVATION_MONITOR.respond_to?(:mon_owned?)
-      if monitor_owned != (ow = RUBYGEMS_ACTIVATION_MONITOR.mon_owned?)
-        STDERR.puts [$$, Thread.current, $!, $!.backtrace].inspect if $!
-        raise "CRITICAL: RUBYGEMS_ACTIVATION_MONITOR.owned?: before #{monitor_owned} -> after #{ow}"
+        return gem_original_require(path)
       end
+
+      raise load_error
     end
   end
-RUBY
 
   private :require
-
 end