rubygems-update 3.3.26 → 3.4.6

data/lib/rubygems/core_ext/kernel_require.rb

@@ -13,12 +13,12 @@ module Kernel
 
   # Make sure we have a reference to Ruby's original Kernel#require
   unless defined?(gem_original_require)
+    # :stopdoc:
     alias 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,142 +33,145 @@ 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
-                next
+  def require(path) # :doc:
+    return gem_original_require(path) unless Gem.discover_gems_on_require
+
+    begin
+      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
+                  next
+                end
+              rescue SecurityError
+                RUBYGEMS_ACTIVATION_MONITOR.exit
+                raise
               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(safe_lp, "#{path}#{s}"))
+              if File.file?(full_path)
+                rp = full_path
+                break
+              end
             end
+            break if rp
           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
-
-    # If there are no unresolved deps, then we can use just try
-    # normal require handle loading a gem from the rescue below.
-
-    if Gem::Specification.unresolved_deps.empty?
-      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
-
-    if Gem::Specification.find_active_stub_by_path(path)
-      RUBYGEMS_ACTIVATION_MONITOR.exit
-      return gem_original_require(path)
-    end
 
-    # 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
+        begin
+          Kernel.send(:gem, spec.name, Gem::Requirement.default_prerelease)
+        rescue Exception
+          RUBYGEMS_ACTIVATION_MONITOR.exit
+          raise
+        end unless resolved_path
       end
 
-    # We found +path+ directly in an unresolved gem. Now we figure out, of
-    # the possible found specs, which one we should activate.
-    else
-
-      # Check that all the found specs are just different
-      # versions of the same gem
-      names = found_specs.map(&:name).uniq
+      # If there are no unresolved deps, then we can use just try
+      # normal require handle loading a gem from the rescue below.
 
-      if names.size > 1
+      if Gem::Specification.unresolved_deps.empty?
         RUBYGEMS_ACTIVATION_MONITOR.exit
-        raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ', '}"
+        return gem_original_require(path)
       end
 
-      # Ok, now find a gem that has no conflicts, starting
-      # at the highest version.
-      valid = found_specs.find {|s| !s.has_conflicts? }
+      # 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
 
-      unless valid
-        le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"
-        le.name = names.first
+      if Gem::Specification.find_active_stub_by_path(path)
         RUBYGEMS_ACTIVATION_MONITOR.exit
-        raise le
+        return gem_original_require(path)
       end
 
-      valid.activate
-    end
+      # 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
+        end
 
-    RUBYGEMS_ACTIVATION_MONITOR.exit
-    return gem_original_require(path)
-  rescue LoadError => load_error
-    RUBYGEMS_ACTIVATION_MONITOR.enter
+      # We found +path+ directly in an unresolved gem. Now we figure out, of
+      # the possible found specs, which one we should activate.
+      else
 
-    begin
-      if load_error.path == path and Gem.try_activate(path)
-        require_again = true
+        # Check that all the found specs are just different
+        # versions of the same gem
+        names = found_specs.map(&:name).uniq
+
+        if names.size > 1
+          RUBYGEMS_ACTIVATION_MONITOR.exit
+          raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ', '}"
+        end
+
+        # 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
+          RUBYGEMS_ACTIVATION_MONITOR.exit
+          raise le
+        end
+
+        valid.activate
       end
-    ensure
+
       RUBYGEMS_ACTIVATION_MONITOR.exit
-    end
+      return gem_original_require(path)
+    rescue LoadError => load_error
+      if load_error.path == path
+        RUBYGEMS_ACTIVATION_MONITOR.enter
+
+        begin
+          require_again = Gem.try_activate(path)
+        ensure
+          RUBYGEMS_ACTIVATION_MONITOR.exit
+        end
 
-    return gem_original_require(path) if require_again
+        return gem_original_require(path) if require_again
+      end
 
-    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}"
+      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}"
+        end
       end
     end
   end
-RUBY
 
   private :require
 

data/lib/rubygems/core_ext/kernel_warn.rb

@@ -1,54 +1,50 @@
 # frozen_string_literal: true
 
-# `uplevel` keyword argument of Kernel#warn is available since ruby 2.5.
-if RUBY_VERSION >= "2.5" && !Gem::KERNEL_WARN_IGNORES_INTERNAL_ENTRIES
+module Kernel
+  rubygems_path = "#{__dir__}/" # Frames to be skipped start with this path.
 
-  module Kernel
-    rubygems_path = "#{__dir__}/" # Frames to be skipped start with this path.
+  original_warn = instance_method(:warn)
 
-    original_warn = instance_method(:warn)
+  remove_method :warn
 
+  class << self
     remove_method :warn
+  end
 
-    class << self
-      remove_method :warn
+  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
 
-    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)
+    # 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
-      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
 
-          start += 1
-
-          if path = loc.path
-            unless path.start_with?(rubygems_path) || path.start_with?("<internal:")
-              # Non-rubygems frames
-              uplevel -= 1
-            end
+        if path = loc.path
+          unless path.start_with?(rubygems_path) || path.start_with?("<internal:")
+            # Non-rubygems frames
+            uplevel -= 1
           end
         end
-        kw[:uplevel] = start
       end
+      kw[:uplevel] = start
+    end
 
-      original_warn.bind(self).call(*messages, **kw)
-    }
-  end
+    original_warn.bind(self).call(*messages, **kw)
+  }
 end

data/lib/rubygems/defaults.rb

@@ -133,6 +133,13 @@ module Gem
     @config_file ||= find_config_file.tap(&Gem::UNTAINT)
   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").tap(&Gem::UNTAINT)
+  end
+
   ##
   # The path to standard location of the user's cache directory.
 
@@ -147,6 +154,13 @@ module Gem
     @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
+    @data_home ||= (ENV["XDG_STATE_HOME"] || File.join(Gem.user_home, ".local", "state"))
+  end
+
   ##
   # How String Gem paths should be split.  Overridable for esoteric platforms.
 
@@ -171,7 +185,7 @@ module Gem
   def self.default_exec_format
     exec_format = RbConfig::CONFIG["ruby_install_name"].sub("ruby", "%s") rescue "%s"
 
-    unless exec_format =~ /%s/
+    unless exec_format.include?("%s")
       raise Gem::Exception,
         "[BUG] invalid exec_format #{exec_format.inspect}, no %s"
     end

data/lib/rubygems/dependency.rb

@@ -277,7 +277,10 @@ class Gem::Dependency
       requirement.satisfied_by?(spec.version) && env_req.satisfied_by?(spec.version)
     end.map(&:to_spec)
 
-    Gem::BundlerVersionFinder.prioritize!(matches) if prioritizes_bundler?
+    if prioritizes_bundler?
+      require_relative "bundler_version_finder"
+      Gem::BundlerVersionFinder.prioritize!(matches)
+    end
 
     if platform_only
       matches.reject! do |spec|

data/lib/rubygems/dependency_installer.rb

@@ -16,16 +16,16 @@ class Gem::DependencyInstaller
   extend Gem::Deprecate
 
   DEFAULT_OPTIONS = { # :nodoc:
-    :env_shebang         => false,
-    :document            => %w[ri],
-    :domain              => :both, # HACK dup
-    :force               => false,
-    :format_executable   => false, # HACK dup
+    :env_shebang => false,
+    :document => %w[ri],
+    :domain => :both, # HACK dup
+    :force => false,
+    :format_executable => false, # HACK dup
     :ignore_dependencies => false,
-    :prerelease          => false,
-    :security_policy     => nil, # HACK NoSecurity requires OpenSSL. AlmostNo? Low?
-    :wrappers            => true,
-    :build_args          => nil,
+    :prerelease => false,
+    :security_policy => nil, # HACK NoSecurity requires OpenSSL. AlmostNo? Low?
+    :wrappers => true,
+    :build_args => nil,
     :build_docs_in_background => false,
     :install_as_default => false,
   }.freeze
@@ -230,22 +230,22 @@ class Gem::DependencyInstaller
     @installed_gems = []
 
     options = {
-      :bin_dir             => @bin_dir,
-      :build_args          => @build_args,
-      :document            => @document,
-      :env_shebang         => @env_shebang,
-      :force               => @force,
-      :format_executable   => @format_executable,
+      :bin_dir => @bin_dir,
+      :build_args => @build_args,
+      :document => @document,
+      :env_shebang => @env_shebang,
+      :force => @force,
+      :format_executable => @format_executable,
       :ignore_dependencies => @ignore_dependencies,
-      :prerelease          => @prerelease,
-      :security_policy     => @security_policy,
-      :user_install        => @user_install,
-      :wrappers            => @wrappers,
-      :build_root          => @build_root,
-      :install_as_default  => @install_as_default,
-      :dir_mode            => @dir_mode,
-      :data_mode           => @data_mode,
-      :prog_mode           => @prog_mode,
+      :prerelease => @prerelease,
+      :security_policy => @security_policy,
+      :user_install => @user_install,
+      :wrappers => @wrappers,
+      :build_root => @build_root,
+      :install_as_default => @install_as_default,
+      :dir_mode => @dir_mode,
+      :data_mode => @data_mode,
+      :prog_mode => @prog_mode,
     }
     options[:install_dir] = @install_dir if @only_install_dir
 

data/lib/rubygems/exceptions.rb

@@ -221,14 +221,12 @@ class Gem::SystemExitException < SystemExit
   ##
   # The exit code for the process
 
-  attr_accessor :exit_code
+  alias exit_code status
 
   ##
   # Creates a new SystemExitException with the given +exit_code+
 
   def initialize(exit_code)
-    @exit_code = exit_code
-
     super exit_code, "Exiting RubyGems with exit_code #{exit_code}"
   end
 end

data/lib/rubygems/ext/builder.rb

@@ -17,7 +17,7 @@ class Gem::Ext::Builder
     $1.downcase
   end
 
-  def self.make(dest_path, results, make_dir = Dir.pwd, sitedir = nil)
+  def self.make(dest_path, results, make_dir = Dir.pwd, sitedir = nil, targets = ["clean", "", "install"])
     unless File.exist? File.join(make_dir, "Makefile")
       raise Gem::InstallError, "Makefile not found"
     end
@@ -26,7 +26,7 @@ class Gem::Ext::Builder
     RbConfig::CONFIG["configure_args"] =~ /with-make-prog\=(\w+)/
     make_program_name = ENV["MAKE"] || ENV["make"] || $1
     unless make_program_name
-      make_program_name = (/mswin/ =~ RUBY_PLATFORM) ? "nmake" : "make"
+      make_program_name = (RUBY_PLATFORM.include?("mswin")) ? "nmake" : "make"
     end
     make_program = Shellwords.split(make_program_name)
 
@@ -40,7 +40,7 @@ class Gem::Ext::Builder
       env << "sitelibdir=%s" % sitedir
     end
 
-    ["clean", "", "install"].each do |target|
+    targets.each do |target|
       # Pass DESTDIR via command line to override what's in MAKEFLAGS
       cmd = [
         *make_program,
@@ -131,8 +131,7 @@ class Gem::Ext::Builder
     when /CMakeLists.txt/ then
       Gem::Ext::CmakeBuilder
     when /Cargo.toml/ then
-      # We use the spec name here to ensure we invoke the correct init function later
-      Gem::Ext::CargoBuilder.new(@spec)
+      Gem::Ext::CargoBuilder.new
     else
       build_error("No builder for extension '#{extension}'")
     end

data/lib/rubygems/ext/cargo_builder/link_flag_converter.rb

@@ -3,20 +3,24 @@
 class Gem::Ext::CargoBuilder < Gem::Ext::Builder
   # Converts Ruby link flags into something cargo understands
   class LinkFlagConverter
+    FILTERED_PATTERNS = [
+      /compress-debug-sections/, # Not supported by all linkers, and not required for Rust
+    ].freeze
+
     def self.convert(arg)
+      return [] if FILTERED_PATTERNS.any? {|p| p.match?(arg) }
+
       case arg.chomp
       when /^-L\s*(.+)$/
         ["-L", "native=#{$1}"]
       when /^--library=(\w+\S+)$/, /^-l\s*(\w+\S+)$/
         ["-l", $1]
-      when /^-l\s*:lib(\S+).a$/
-        ["-l", "static=#{$1}"]
-      when /^-l\s*:lib(\S+).(so|dylib|dll)$/
-        ["-l", "dylib=#{$1}"]
+      when /^-l\s*([^:\s])+/ # -lfoo, but not -l:libfoo.a
+        ["-l", $1]
       when /^-F\s*(.*)$/
         ["-l", "framework=#{$1}"]
       else
-        ["-C", "link_arg=#{arg}"]
+        ["-C", "link-args=#{arg}"]
       end
     end
   end