rubygems-update 2.6.1 → 3.5.0

data/lib/rubygems/core_ext/kernel_require.rb

@@ -1,25 +1,22 @@
 # 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:
 
-  if defined?(gem_original_require) then
-    # Ruby ships with a custom_require, override its require
-    remove_method :require
-  else
-    ##
-    # The Kernel#require from before RubyGems was loaded.
-
-    alias gem_original_require require
+  # Make sure we have a reference to Ruby's original Kernel#require
+  unless defined?(gem_original_require)
+    # :stopdoc:
+    alias_method :gem_original_require, :require
     private :gem_original_require
+    # :startdoc:
   end
 
   ##
@@ -36,103 +33,108 @@ module Kernel
   # The normal <tt>require</tt> functionality of returning false if
   # that file has already been loaded is preserved.
 
-  def require path
-    RUBYGEMS_ACTIVATION_MONITOR.enter
+  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 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.find do |s|
+            $LOAD_PATH[0...load_path_check_index].find do |lp|
+              if File.symlink? lp # for backward compatibility
+                next
+              end
+
+              full_path = File.expand_path(File.join(lp, "#{path}#{s}"))
+              rp = full_path if File.file?(full_path)
+            end
+          end
+          rp
+        end
+
+        Kernel.send(:gem, spec.name, Gem::Requirement.default_prerelease) unless
+          resolved_path
+      end
 
-    path = path.to_path if path.respond_to? :to_path
+      # If there are no unresolved deps, then we can use just try
+      # normal require handle loading a gem from the rescue below.
 
-    spec = Gem.find_unresolved_default_spec(path)
-    if spec
-      Gem.remove_unresolved_default_spec(spec)
-      gem(spec.name)
-    end
+      if Gem::Specification.unresolved_deps.empty?
+        next
+      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? then
-      RUBYGEMS_ACTIVATION_MONITOR.exit
-      return gem_original_require(path)
-    end
+      if Gem::Specification.find_active_stub_by_path(path)
+        next
+      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...
 
-    spec = Gem::Specification.find_active_stub_by_path path
+      found_specs = Gem::Specification.find_in_unresolved path
 
-    begin
-      RUBYGEMS_ACTIVATION_MONITOR.exit
-      return gem_original_require(path)
-    end if spec
-
-    # 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? then
-      found_specs = Gem::Specification.find_in_unresolved_tree path
-
-      found_specs.each do |found_spec|
-        found_spec.activate
-      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
 
-    # We found +path+ directly in an unresolved gem. Now we figure out, of
-    # the possible found specs, which one we should activate.
-    else
+        found_specs.each(&:activate)
 
-      # Check that all the found specs are just different
-      # versions of the same gem
-      names = found_specs.map(&:name).uniq
+      # We found +path+ directly in an unresolved gem. Now we figure out, of
+      # the possible found specs, which one we should activate.
+      else
 
-      if names.size > 1 then
-        RUBYGEMS_ACTIVATION_MONITOR.exit
-        raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ', '}"
-      end
+        # Check that all the found specs are just different
+        # versions of the same gem
+        names = found_specs.map(&:name).uniq
 
-      # Ok, now find a gem that has no conflicts, starting
-      # at the highest version.
-      valid = found_specs.reject { |s| s.has_conflicts? }.last
+        if names.size > 1
+          raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ", "}"
+        end
 
-      unless valid then
-        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
+        # Ok, now find a gem that has no conflicts, starting
+        # at the highest version.
+        valid = found_specs.find {|s| !s.has_conflicts? }
 
-      valid.activate
-    end
+        unless valid
+          le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"
+          le.name = names.first
+          raise le
+        end
 
-    RUBYGEMS_ACTIVATION_MONITOR.exit
-    return gem_original_require(path)
-  rescue LoadError => load_error
-    RUBYGEMS_ACTIVATION_MONITOR.enter
-
-    if load_error.message.start_with?("Could not find") or
-        (load_error.message.end_with?(path) and Gem.try_activate(path)) then
-      RUBYGEMS_ACTIVATION_MONITOR.exit
-      return gem_original_require(path)
-    else
-      RUBYGEMS_ACTIVATION_MONITOR.exit
+        valid.activate
+      end
     end
 
-    raise load_error
+    begin
+      gem_original_require(path)
+    rescue LoadError => load_error
+      if load_error.path == path &&
+         RUBYGEMS_ACTIVATION_MONITOR.synchronize { Gem.try_activate(path) }
+
+        return gem_original_require(path)
+      end
+
+      raise load_error
+    end
   end
 
   private :require
-
 end
-

data/lib/rubygems/core_ext/kernel_warn.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Kernel
+  rubygems_path = "#{__dir__}/" # Frames to be skipped start with this path.
+
+  original_warn = instance_method(:warn)
+
+  remove_method :warn
+
+  class << self
+    remove_method :warn
+  end
+
+  module_function define_method(:warn) {|*messages, **kw|
+    unless uplevel = kw[:uplevel]
+      if Gem.java_platform? && RUBY_VERSION < "3.1"
+        return original_warn.bind(self).call(*messages)
+      else
+        return original_warn.bind(self).call(*messages, **kw)
+      end
+    end
+
+    # Ensure `uplevel` fits a `long`
+    uplevel, = [uplevel].pack("l!").unpack("l!")
+
+    if uplevel >= 0
+      start = 0
+      while uplevel >= 0
+        loc, = caller_locations(start, 1)
+        unless loc
+          # No more backtrace
+          start += uplevel
+          break
+        end
+
+        start += 1
+
+        next unless path = loc.path
+        unless path.start_with?(rubygems_path, "<internal:")
+          # Non-rubygems frames
+          uplevel -= 1
+        end
+      end
+      kw[:uplevel] = start
+    end
+
+    original_warn.bind(self).call(*messages, **kw)
+  }
+end

data/lib/rubygems/core_ext/tcpsocket_init.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module CoreExtensions
+  module TCPSocketExt
+    def self.prepended(base)
+      base.prepend Initializer
+    end
+
+    module Initializer
+      CONNECTION_TIMEOUT = 5
+      IPV4_DELAY_SECONDS = 0.1
+
+      def initialize(host, serv, *rest)
+        mutex = Thread::Mutex.new
+        addrs = []
+        threads = []
+        cond_var = Thread::ConditionVariable.new
+
+        Addrinfo.foreach(host, serv, nil, :STREAM) do |addr|
+          Thread.report_on_exception = false
+
+          threads << Thread.new(addr) do
+            # give head start to ipv6 addresses
+            sleep IPV4_DELAY_SECONDS if addr.ipv4?
+
+            # raises Errno::ECONNREFUSED when ip:port is unreachable
+            Socket.tcp(addr.ip_address, serv, connect_timeout: CONNECTION_TIMEOUT).close
+            mutex.synchronize do
+              addrs << addr.ip_address
+              cond_var.signal
+            end
+          end
+        end
+
+        mutex.synchronize do
+          timeout_time = CONNECTION_TIMEOUT + Time.now.to_f
+          while addrs.empty? && (remaining_time = timeout_time - Time.now.to_f) > 0
+            cond_var.wait(mutex, remaining_time)
+          end
+
+          host = addrs.shift unless addrs.empty?
+        end
+
+        threads.each {|t| t.kill.join if t.alive? }
+
+        super(host, serv, *rest)
+      end
+    end
+  end
+end
+
+TCPSocket.prepend CoreExtensions::TCPSocketExt

data/lib/rubygems/defaults.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 module Gem
   DEFAULT_HOST = "https://rubygems.org"
 
-  @post_install_hooks   ||= []
-  @done_installing_hooks  ||= []
+  @post_install_hooks ||= []
+  @done_installing_hooks ||= []
   @post_uninstall_hooks ||= []
   @pre_uninstall_hooks  ||= []
   @pre_install_hooks    ||= []
@@ -20,7 +21,13 @@ module Gem
   # specified in the environment
 
   def self.default_spec_cache_dir
-    File.join Gem.user_home, '.gem', 'specs'
+    default_spec_cache_dir = File.join Gem.user_home, ".gem", "specs"
+
+    unless File.exist?(default_spec_cache_dir)
+      default_spec_cache_dir = File.join Gem.data_home, "gem", "specs"
+    end
+
+    default_spec_cache_dir
   end
 
   ##
@@ -28,28 +35,7 @@ module Gem
   # specified in the environment
 
   def self.default_dir
-    path = if defined? RUBY_FRAMEWORK_VERSION then
-             [
-               File.dirname(RbConfig::CONFIG['sitedir']),
-               'Gems',
-               RbConfig::CONFIG['ruby_version']
-             ]
-           elsif RbConfig::CONFIG['rubylibprefix'] then
-             [
-              RbConfig::CONFIG['rubylibprefix'],
-              'gems',
-              RbConfig::CONFIG['ruby_version']
-             ]
-           else
-             [
-               RbConfig::CONFIG['libdir'],
-               ruby_engine,
-               'gems',
-               RbConfig::CONFIG['ruby_version']
-             ]
-           end
-
-    @default_dir ||= File.join(*path)
+    @default_dir ||= File.join(RbConfig::CONFIG["rubylibprefix"], "gems", RbConfig::CONFIG["ruby_version"])
   end
 
   ##
@@ -59,7 +45,7 @@ module Gem
   # By default, the binary extensions are located side by side with their
   # Ruby counterparts, therefore nil is returned
 
-  def self.default_ext_dir_for base_dir
+  def self.default_ext_dir_for(base_dir)
     nil
   end
 
@@ -70,15 +56,112 @@ module Gem
     nil # default to standard layout
   end
 
+  ##
+  # Path to specification files of default gems.
+
+  def self.default_specifications_dir
+    @default_specifications_dir ||= File.join(Gem.default_dir, "specifications", "default")
+  end
+
+  ##
+  # Finds the user's home directory.
+  #--
+  # Some comments from the ruby-talk list regarding finding the home
+  # directory:
+  #
+  #   I have HOME, USERPROFILE and HOMEDRIVE + HOMEPATH. Ruby seems
+  #   to be depending on HOME in those code samples. I propose that
+  #   it should fallback to USERPROFILE and HOMEDRIVE + HOMEPATH (at
+  #   least on Win32).
+  #++
+  #--
+  #
+  #++
+
+  def self.find_home
+    Dir.home.dup
+  rescue StandardError
+    if Gem.win_platform?
+      File.expand_path File.join(ENV["HOMEDRIVE"] || ENV["SystemDrive"], "/")
+    else
+      File.expand_path "/"
+    end
+  end
+
+  private_class_method :find_home
+
+  ##
+  # The home directory for the user.
+
+  def self.user_home
+    @user_home ||= find_home
+  end
+
   ##
   # Path for gems in the user's home directory
 
   def self.user_dir
-    parts = [Gem.user_home, '.gem', ruby_engine]
-    parts << RbConfig::CONFIG['ruby_version'] unless RbConfig::CONFIG['ruby_version'].empty?
+    gem_dir = File.join(Gem.user_home, ".gem")
+    gem_dir = File.join(Gem.data_home, "gem") unless File.exist?(gem_dir)
+    parts = [gem_dir, ruby_engine]
+    parts << RbConfig::CONFIG["ruby_version"] unless RbConfig::CONFIG["ruby_version"].empty?
     File.join parts
   end
 
+  ##
+  # The path to standard location of the user's configuration directory.
+
+  def self.config_home
+    @config_home ||= (ENV["XDG_CONFIG_HOME"] || File.join(Gem.user_home, ".config"))
+  end
+
+  ##
+  # Finds the user's config file
+
+  def self.find_config_file
+    gemrc = File.join Gem.user_home, ".gemrc"
+    if File.exist? gemrc
+      gemrc
+    else
+      File.join Gem.config_home, "gem", "gemrc"
+    end
+  end
+
+  ##
+  # The path to standard location of the user's .gemrc file.
+
+  def self.config_file
+    @config_file ||= find_config_file
+  end
+
+  ##
+  # The path to standard location of the user's state file.
+
+  def self.state_file
+    @state_file ||= File.join(Gem.state_home, "gem", "last_update_check")
+  end
+
+  ##
+  # The path to standard location of the user's cache directory.
+
+  def self.cache_home
+    @cache_home ||= (ENV["XDG_CACHE_HOME"] || File.join(Gem.user_home, ".cache"))
+  end
+
+  ##
+  # The path to standard location of the user's data directory.
+
+  def self.data_home
+    @data_home ||= (ENV["XDG_DATA_HOME"] || File.join(Gem.user_home, ".local", "share"))
+  end
+
+  ##
+  # The path to standard location of the user's state directory.
+
+  def self.state_home
+    @state_home ||= (ENV["XDG_STATE_HOME"] || File.join(Gem.user_home, ".local", "state"))
+  end
+
   ##
   # How String Gem paths should be split.  Overridable for esoteric platforms.
 
@@ -93,7 +176,7 @@ module Gem
     path = []
     path << user_dir if user_home && File.exist?(user_home)
     path << default_dir
-    path << vendor_dir if vendor_dir and File.directory? vendor_dir
+    path << vendor_dir if vendor_dir && File.directory?(vendor_dir)
     path
   end
 
@@ -101,9 +184,13 @@ module Gem
   # Deduce Ruby's --program-prefix and --program-suffix from its install name
 
   def self.default_exec_format
-    exec_format = RbConfig::CONFIG['ruby_install_name'].sub('ruby', '%s') rescue '%s'
+    exec_format = begin
+                    RbConfig::CONFIG["ruby_install_name"].sub("ruby", "%s")
+                  rescue StandardError
+                    "%s"
+                  end
 
-    unless exec_format =~ /%s/ then
+    unless exec_format.include?("%s")
       raise Gem::Exception,
         "[BUG] invalid exec_format #{exec_format.inspect}, no %s"
     end
@@ -115,43 +202,49 @@ module Gem
   # The default directory for binaries
 
   def self.default_bindir
-    if defined? RUBY_FRAMEWORK_VERSION then # mac framework support
-      '/usr/bin'
-    else # generic install
-      RbConfig::CONFIG['bindir']
-    end
+    RbConfig::CONFIG["bindir"]
   end
 
-  ##
-  # A wrapper around RUBY_ENGINE const that may not be defined
-
   def self.ruby_engine
-    if defined? RUBY_ENGINE then
-      RUBY_ENGINE
-    else
-      'ruby'
-    end
+    RUBY_ENGINE
   end
 
   ##
   # The default signing key path
 
   def self.default_key_path
-    File.join Gem.user_home, ".gem", "gem-private_key.pem"
+    default_key_path = File.join Gem.user_home, ".gem", "gem-private_key.pem"
+
+    unless File.exist?(default_key_path)
+      default_key_path = File.join Gem.data_home, "gem", "gem-private_key.pem"
+    end
+
+    default_key_path
   end
 
   ##
   # The default signing certificate chain path
 
   def self.default_cert_path
-    File.join Gem.user_home, ".gem", "gem-public_cert.pem"
+    default_cert_path = File.join Gem.user_home, ".gem", "gem-public_cert.pem"
+
+    unless File.exist?(default_cert_path)
+      default_cert_path = File.join Gem.data_home, "gem", "gem-public_cert.pem"
+    end
+
+    default_cert_path
   end
 
   ##
-  # Whether to expect full paths in default gems - true for non-MRI
-  # ruby implementations
-  def self.default_gems_use_full_paths?
-    ruby_engine != 'ruby'
+  # Enables automatic installation into user directory
+
+  def self.default_user_install # :nodoc:
+    if !ENV.key?("GEM_HOME") && (File.exist?(Gem.dir) && !File.writable?(Gem.dir))
+      Gem.ui.say "Defaulting to user installation because default installation directory (#{Gem.dir}) is not writable."
+      return true
+    end
+
+    false
   end
 
   ##
@@ -165,14 +258,51 @@ module Gem
   # Directory where vendor gems are installed.
 
   def self.vendor_dir # :nodoc:
-    if vendor_dir = ENV['GEM_VENDOR'] then
+    if vendor_dir = ENV["GEM_VENDOR"]
       return vendor_dir.dup
     end
 
-    return nil unless RbConfig::CONFIG.key? 'vendordir'
+    return nil unless RbConfig::CONFIG.key? "vendordir"
 
-    File.join RbConfig::CONFIG['vendordir'], 'gems',
-              RbConfig::CONFIG['ruby_version']
+    File.join RbConfig::CONFIG["vendordir"], "gems",
+              RbConfig::CONFIG["ruby_version"]
   end
 
+  ##
+  # Default options for gem commands for Ruby packagers.
+  #
+  # The options here should be structured as an array of string "gem"
+  # command names as keys and a string of the default options as values.
+  #
+  # Example:
+  #
+  # def self.operating_system_defaults
+  #   {
+  #       'install' => '--no-rdoc --no-ri --env-shebang',
+  #       'update' => '--no-rdoc --no-ri --env-shebang'
+  #   }
+  # end
+
+  def self.operating_system_defaults
+    {}
+  end
+
+  ##
+  # Default options for gem commands for Ruby implementers.
+  #
+  # The options here should be structured as an array of string "gem"
+  # command names as keys and a string of the default options as values.
+  #
+  # Example:
+  #
+  # def self.platform_defaults
+  #   {
+  #       'install' => '--no-rdoc --no-ri --env-shebang',
+  #       'update' => '--no-rdoc --no-ri --env-shebang'
+  #   }
+  # end
+
+  def self.platform_defaults
+    {}
+  end
 end