rubygems-update 4.0.21 → 4.1.0.beta1

data/lib/rubygems/specification_policy.rb

@@ -192,15 +192,14 @@ duplicate dependency on #{dep}, (#{prev.requirement}) use:
   # Checks that the gem does not depend on itself.
 
   def validate_dependencies # :nodoc:
-    warning_messages = []
+    error_messages = []
     @specification.dependencies.each do |dep|
-      if dep.name == @specification.name # warn on self reference
-        warning_messages << "Self referencing dependency is unnecessary and strongly discouraged."
+      if dep.name == @specification.name # error on self reference
+        error_messages << "Dependencies of this gem include a self-reference."
       end
     end
-    if warning_messages.any?
-      warning_messages.each {|warning_message| warning warning_message }
-    end
+
+    error error_messages.join if error_messages.any?
   end
 
   def validate_required_ruby_version
@@ -476,6 +475,7 @@ or set it to nil if you don't want to specify a license.
 
     validate_rake_extensions(builder)
     validate_rust_extensions(builder)
+    validate_extension_require_relative
   end
 
   def validate_rust_extensions(builder) # :nodoc:
@@ -496,6 +496,33 @@ You have specified rake based extension, but rake is not added as runtime depend
     WARNING
   end
 
+  def validate_extension_require_relative # :nodoc:
+    return unless @specification.extensions.any?
+
+    require_paths = @specification.require_paths
+
+    @specification.files.each do |rb_file|
+      next unless rb_file.end_with?(".rb")
+      next unless require_paths.any? {|rp| rb_file.start_with?("#{rp}/") }
+      next unless File.file?(rb_file)
+
+      File.foreach(rb_file).with_index(1) do |line, lineno|
+        next unless line =~ /^\s*require_relative\s+["']([^"']+)["']/
+
+        required_path = Regexp.last_match(1)
+        resolved = File.join(File.dirname(rb_file), required_path)
+
+        next if @specification.files.any? {|f| f == "#{resolved}.rb" || f == resolved }
+
+        warning <<~WARNING
+          #{rb_file}:#{lineno} uses `require_relative "#{required_path}"` to load a compiled extension.
+          This will break in RubyGems 4.2, which will stop copying compiled extensions into the gem's lib directory.
+          Use `require` instead of `require_relative` to load compiled extensions.
+        WARNING
+      end
+    end
+  end
+
   def validate_unique_links
     links = @specification.metadata.slice(*METADATA_LINK_KEYS)
     grouped = links.group_by {|_key, uri| uri }

data/lib/rubygems/specification_record.rb

@@ -2,12 +2,50 @@
 
 module Gem
   class SpecificationRecord
+    ##
+    # Specification directories for each path: the flat +specifications+
+    # dir and the ABI-scoped +specifications/<ruby_abi>+ subdir.
+
     def self.dirs_from(paths)
-      paths.map do |path|
-        File.join(path, "specifications")
+      paths.flat_map do |path|
+        specifications = File.join(path, "specifications")
+
+        [specifications, File.join(specifications, Gem.ruby_abi)]
       end
     end
 
+    ##
+    # Whether +dir+ is an ABI-scoped spec dir
+    # (<tt>.../specifications/<ruby_abi></tt>). Requires the parent to be
+    # named +specifications+ to avoid false positives.
+    def self.abi_scoped_spec_dir?(dir)
+      Gem::ContentAddress.valid_ruby_abi?(File.basename(dir)) &&
+        File.basename(File.dirname(dir)) == "specifications"
+    end
+
+    ##
+    # The spec dir for +spec+ under +base_dir+: the ABI-scoped subdir for
+    # content-addressed specs, the flat +specifications+ dir otherwise.
+    def self.specification_dir_for(spec, base_dir)
+      dir = File.join(base_dir, "specifications")
+      dir = File.join(dir, spec.ruby_abi) if Gem::ContentAddress.content_addressed?(spec)
+      dir
+    end
+
+    ##
+    # Ensure ABI-scoped subdirectories are present in +dirs+.  No-op when
+    # +dirs+ already includes them (e.g. MRI); expands flat-only +dirs+
+
+    def self.dirs_with_abi(dirs)
+      dirs.flat_map do |dir|
+        if File.basename(dir) == "specifications"
+          [dir, File.join(dir, Gem.ruby_abi)]
+        else
+          dir
+        end
+      end.uniq
+    end
+
     def self.from_path(path)
       new(dirs_from([path]))
     end
@@ -217,6 +255,7 @@ module Gem
     def map_stubs(pattern)
       @dirs.flat_map do |dir|
         base_dir = File.dirname dir
+        base_dir = File.dirname base_dir if self.class.abi_scoped_spec_dir?(dir)
         gems_dir = File.join base_dir, "gems"
         Gem::Specification.gemspec_stubs_in(dir, pattern) {|path| yield path, base_dir, gems_dir }
       end

data/lib/rubygems/stub_specification.rb

@@ -9,14 +9,18 @@ class Gem::StubSpecification < Gem::BasicSpecification
   # :nodoc:
   PREFIX = "# stub: "
 
+  # :nodoc:
+  TARGET_PREFIX = "# stub-target: "
+
   # :nodoc:
   OPEN_MODE = "r:UTF-8:-"
 
   class StubLine # :nodoc: all
     attr_reader :name, :version, :platform, :require_paths, :extensions,
-                :full_name
+                :full_name, :content_address
 
     NO_EXTENSIONS = [].freeze
+    NO_TARGET = {}.freeze
 
     # These are common require paths.
     REQUIRE_PATHS = { # :nodoc:
@@ -33,7 +37,7 @@ class Gem::StubSpecification < Gem::BasicSpecification
       "lib" => ["lib"].freeze,
     }.freeze
 
-    def initialize(data, extensions)
+    def initialize(data, extensions, target = NO_TARGET)
       parts          = data[PREFIX.length..-1].split(" ", 4)
       @name          = -parts[0]
       @version       = if Gem::Version.correct?(parts[1])
@@ -42,12 +46,17 @@ class Gem::StubSpecification < Gem::BasicSpecification
         Gem::Version.new(0)
       end
 
-      @platform      = Gem::Platform.new parts[2]
+      suffix = parts[2]
+      target_platform = target["platform"]
+      @platform = Gem::Platform.new(target_platform || suffix)
+      @content_address = suffix if Gem::ContentAddress.content_addressed_row?(suffix, target_platform, validate_ruby_abi: false)
       @extensions    = extensions
-      @full_name     = if platform == Gem::Platform::RUBY
+      @full_name     = if @content_address
+        "#{name}-#{version}-#{content_address}"
+      elsif platform == Gem::Platform::RUBY
         "#{name}-#{version}"
       else
-        "#{name}-#{version}-#{platform}"
+        "#{name}-#{version}-#{suffix}"
       end
 
       path_list = parts.last
@@ -110,18 +119,27 @@ class Gem::StubSpecification < Gem::BasicSpecification
           file.readline # discard encoding line
           stubline = file.readline
           if stubline.start_with?(PREFIX)
-            extline = file.readline
-
-            extensions =
-              if extline.delete_prefix!(PREFIX)
-                extline.chomp!
-                extline.split "\0"
-              else
-                StubLine::NO_EXTENSIONS
+            line = file.readline
+
+            if line.delete_prefix!(PREFIX)
+              line.chomp!
+              extensions = line.split "\0"
+              line = file.readline
+            else
+              extensions = StubLine::NO_EXTENSIONS
+            end
+
+            target = StubLine::NO_TARGET
+            if line.delete_prefix!(TARGET_PREFIX)
+              line.chomp!
+              target = line.split(",").to_h do |pair|
+                key, value = pair.split("=", 2)
+                [key, value]
               end
+            end
 
             stubline.chomp! # readline(chomp: true) allocates 3x as much as .readline.chomp!
-            @data = StubLine.new stubline, extensions
+            @data = StubLine.new stubline, extensions, target
           end
         rescue EOFError
         end
@@ -162,6 +180,10 @@ class Gem::StubSpecification < Gem::BasicSpecification
     data.platform
   end
 
+  def content_address # :nodoc:
+    data.content_address
+  end
+
   ##
   # Extensions for this gem
 
@@ -208,13 +230,14 @@ class Gem::StubSpecification < Gem::BasicSpecification
     self.class === other &&
       name == other.name &&
       version == other.version &&
-      platform == other.platform
+      platform == other.platform &&
+      content_address == other.content_address
   end
 
   alias_method :eql?, :== # :nodoc:
 
   def hash # :nodoc:
-    name.hash ^ version.hash ^ platform.hash
+    [name, version, platform, content_address].hash
   end
 
   def <=>(other) # :nodoc:

data/lib/rubygems/uninstaller.rb

@@ -272,6 +272,8 @@ class Gem::Uninstaller
 
     safe_delete { rm_r full_gem_path, exclusions: exclusions }
     safe_delete { FileUtils.rm_r spec.extension_dir }
+    safe_delete { FileUtils.rm_f File.join(spec.build_info_dir, "#{spec.full_name}.mkmf.log") }
+    safe_delete { FileUtils.rm_f File.join(spec.build_info_dir, "#{spec.full_name}.gem_make.out") }
 
     old_platform_name = spec.original_name
 

data/lib/rubygems/util/atomic_file_writer.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Based on ActiveSupport's AtomicFile implementation
+# Copyright (c) David Heinemeier Hansson
+# https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/file/atomic.rb
+# Licensed under the MIT License
+
+module Gem
+  class AtomicFileWriter
+    ##
+    # Write to a file atomically. Useful for situations where you don't
+    # want other processes or threads to see half-written files.
+
+    def self.open(file_name)
+      require "securerandom" unless defined?(SecureRandom)
+
+      old_stat = begin
+                   File.stat(file_name)
+                 rescue SystemCallError
+                   nil
+                 end
+
+      # Names can't be longer than 255B
+      tmp_suffix = ".tmp.#{SecureRandom.hex}"
+      dirname = File.dirname(file_name)
+      basename = File.basename(file_name)
+      base_slice = byteslice_at_char_boundary(basename, 254 - tmp_suffix.bytesize)
+      tmp_path = File.join(dirname, ".#{base_slice}#{tmp_suffix}")
+
+      # The temporary name is longer than the final one, so on Windows a
+      # writable destination can still map to a path beyond the 260-character
+      # MAX_PATH limit. Trim the random suffix first, keeping at least 8 hex
+      # characters to avoid collisions, then shorten the basename if that is not
+      # enough. Recomputing the basename from the trimmed suffix would just let
+      # it grow back, so trim the already-sliced basename instead.
+      if tmp_path.length >= 260 && Gem.win_platform?
+        overflow = tmp_path.length - 259
+        trim = [tmp_suffix.bytesize - (".tmp.".bytesize + 8), overflow].min
+        tmp_suffix = tmp_suffix.byteslice(0, tmp_suffix.bytesize - trim)
+        overflow -= trim
+        base_slice = byteslice_at_char_boundary(base_slice, [base_slice.bytesize - overflow, 0].max) if overflow > 0
+        tmp_path = File.join(dirname, ".#{base_slice}#{tmp_suffix}")
+      end
+
+      flags = File::RDWR | File::CREAT | File::EXCL | File::BINARY
+      flags |= File::SHARE_DELETE if defined?(File::SHARE_DELETE)
+
+      renamed = false
+      temp_file = File.open(tmp_path, flags)
+
+      begin
+        temp_file.binmode
+        if old_stat
+          # Set correct permissions on new file
+          begin
+            temp_file.chown(old_stat.uid, old_stat.gid)
+            # This operation will affect filesystem ACL's
+            temp_file.chmod(old_stat.mode)
+          rescue Errno::EPERM, Errno::EACCES
+            # Changing file ownership failed, moving on.
+          end
+        end
+
+        return_val = yield temp_file
+
+        # Any data still buffered is handed to the filesystem on close, so a
+        # failing flush must surface while the destination is still intact.
+        # That means closing the temporary file before the rename. Note this
+        # does not fsync, so the write is atomic but not crash durable.
+        temp_file.close
+        File.rename(tmp_path, file_name)
+        renamed = true
+
+        return_val
+      ensure
+        unless renamed
+          begin
+            temp_file.close
+          rescue StandardError
+            nil
+          ensure
+            # The unlink runs from an ensure so that a non-StandardError raised by
+            # the close above, a second Ctrl-C for instance, still reaches it. An
+            # interrupt landing on the unlink itself is not covered.
+            begin
+              File.unlink(tmp_path)
+            rescue StandardError
+              nil
+            end
+          end
+        end
+      end
+    end
+
+    # Returns the longest prefix of string that is at most max_bytesize bytes
+    # and ends on a character boundary. A string that is invalid in its own
+    # encoding would be cut back to its last valid prefix, discarding an
+    # unbounded part of the name, so it is sliced as raw bytes instead and can
+    # still be cut mid-character.
+    def self.byteslice_at_char_boundary(string, max_bytesize)
+      sliced = string.byteslice(0, max_bytesize)
+      if string.valid_encoding?
+        sliced = sliced.byteslice(0, sliced.bytesize - 1) until sliced.valid_encoding?
+      end
+      sliced
+    end
+    private_class_method :byteslice_at_char_boundary
+  end
+end

data/lib/rubygems/vendor/net-http/lib/net/http/exceptions.rb

@@ -3,7 +3,7 @@ module Gem::Net
   # Gem::Net::HTTP exception class.
   # You cannot use Gem::Net::HTTPExceptions directly; instead, you must use
   # its subclasses.
-  module HTTPExceptions
+  module HTTPExceptions # :nodoc:
     def initialize(msg, res)   #:nodoc:
       super msg
       @response = res
@@ -12,6 +12,7 @@ module Gem::Net
     alias data response    #:nodoc: obsolete
   end
 
+  # :stopdoc:
   class HTTPError < ProtocolError
     include HTTPExceptions
   end

data/lib/rubygems/vendor/net-http/lib/net/http/generic_request.rb

@@ -19,16 +19,13 @@ class Gem::Net::HTTPGenericRequest
 
     if Gem::URI === uri_or_path then
       raise ArgumentError, "not an HTTP Gem::URI" unless Gem::URI::HTTP === uri_or_path
-      hostname = uri_or_path.hostname
+      hostname = uri_or_path.host
       raise ArgumentError, "no host component for Gem::URI" unless (hostname && hostname.length > 0)
       @uri = uri_or_path.dup
-      host = @uri.hostname.dup
-      host << ":" << @uri.port.to_s if @uri.port != @uri.default_port
       @path = uri_or_path.request_uri
       raise ArgumentError, "no HTTP request path given" unless @path
     else
       @uri = nil
-      host = nil
       raise ArgumentError, "no HTTP request path given" unless uri_or_path
       raise ArgumentError, "HTTP request path is empty" if uri_or_path.empty?
       @path = uri_or_path.dup
@@ -51,7 +48,7 @@ class Gem::Net::HTTPGenericRequest
     initialize_http_header initheader
     self['Accept'] ||= '*/*'
     self['User-Agent'] ||= 'Ruby'
-    self['Host'] ||= host if host
+    self['Host'] ||= @uri.authority if @uri
     @body = nil
     @body_stream = nil
     @body_data = nil
@@ -245,7 +242,7 @@ class Gem::Net::HTTPGenericRequest
     end
 
     if host = self['host']
-      host.sub!(/:.*/m, '')
+      host = Gem::URI.parse("//#{host}").host # Remove a port component from the existing Host header
     elsif host = @uri.host
     else
      host = addr
@@ -264,6 +261,8 @@ class Gem::Net::HTTPGenericRequest
 
   private
 
+  # :stopdoc:
+
   class Chunker #:nodoc:
     def initialize(sock)
       @sock = sock

data/lib/rubygems/vendor/net-http/lib/net/http/header.rb

@@ -179,7 +179,9 @@
 # - #each_value: Passes each string field value to the block.
 #
 module Gem::Net::HTTPHeader
+  # The maximum length of HTTP header keys.
   MAX_KEY_LENGTH = 1024
+  # The maximum length of HTTP header values.
   MAX_FIELD_LENGTH = 65536
 
   def initialize_http_header(initheader) #:nodoc:
@@ -267,6 +269,7 @@ module Gem::Net::HTTPHeader
     end
   end
 
+  # :stopdoc:
   private def set_field(key, val)
     case val
     when Enumerable
@@ -294,6 +297,7 @@ module Gem::Net::HTTPHeader
       ary.push val
     end
   end
+  # :startdoc:
 
   # Returns the array field value for the given +key+,
   # or +nil+ if there is no such field;
@@ -490,7 +494,7 @@ module Gem::Net::HTTPHeader
 
   alias canonical_each each_capitalized
 
-  def capitalize(name)
+  def capitalize(name)  # :nodoc:
     name.to_s.split('-'.freeze).map {|s| s.capitalize }.join('-'.freeze)
   end
   private :capitalize
@@ -957,12 +961,12 @@ module Gem::Net::HTTPHeader
     @header['proxy-authorization'] = [basic_encode(account, password)]
   end
 
-  def basic_encode(account, password)
+  def basic_encode(account, password)   # :nodoc:
     'Basic ' + ["#{account}:#{password}"].pack('m0')
   end
   private :basic_encode
 
-# Returns whether the HTTP session is to be closed.
+  # Returns whether the HTTP session is to be closed.
   def connection_close?
     token = /(?:\A|,)\s*close\s*(?:\z|,)/i
     @header['connection']&.grep(token) {return true}
@@ -970,7 +974,7 @@ module Gem::Net::HTTPHeader
     false
   end
 
-# Returns whether the HTTP session is to be kept alive.
+  # Returns whether the HTTP session is to be kept alive.
   def connection_keep_alive?
     token = /(?:\A|,)\s*keep-alive\s*(?:\z|,)/i
     @header['connection']&.grep(token) {return true}

data/lib/rubygems/vendor/net-http/lib/net/http/requests.rb

@@ -29,6 +29,7 @@
 # - Gem::Net::HTTP#get: sends +GET+ request, returns response object.
 #
 class Gem::Net::HTTP::Get < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'GET'
   REQUEST_HAS_BODY  = false
   RESPONSE_HAS_BODY = true
@@ -60,6 +61,7 @@ end
 # - Gem::Net::HTTP#head: sends +HEAD+ request, returns response object.
 #
 class Gem::Net::HTTP::Head < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'HEAD'
   REQUEST_HAS_BODY = false
   RESPONSE_HAS_BODY = false
@@ -95,6 +97,7 @@ end
 # - Gem::Net::HTTP#post: sends +POST+ request, returns response object.
 #
 class Gem::Net::HTTP::Post < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'POST'
   REQUEST_HAS_BODY = true
   RESPONSE_HAS_BODY = true
@@ -130,6 +133,7 @@ end
 # - Gem::Net::HTTP#put: sends +PUT+ request, returns response object.
 #
 class Gem::Net::HTTP::Put < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'PUT'
   REQUEST_HAS_BODY = true
   RESPONSE_HAS_BODY = true
@@ -162,6 +166,7 @@ end
 # - Gem::Net::HTTP#delete: sends +DELETE+ request, returns response object.
 #
 class Gem::Net::HTTP::Delete < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'DELETE'
   REQUEST_HAS_BODY = false
   RESPONSE_HAS_BODY = true
@@ -193,6 +198,7 @@ end
 # - Gem::Net::HTTP#options: sends +OPTIONS+ request, returns response object.
 #
 class Gem::Net::HTTP::Options < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'OPTIONS'
   REQUEST_HAS_BODY = false
   RESPONSE_HAS_BODY = true
@@ -224,6 +230,7 @@ end
 # - Gem::Net::HTTP#trace: sends +TRACE+ request, returns response object.
 #
 class Gem::Net::HTTP::Trace < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'TRACE'
   REQUEST_HAS_BODY = false
   RESPONSE_HAS_BODY = true
@@ -258,6 +265,7 @@ end
 # - Gem::Net::HTTP#patch: sends +PATCH+ request, returns response object.
 #
 class Gem::Net::HTTP::Patch < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'PATCH'
   REQUEST_HAS_BODY = true
   RESPONSE_HAS_BODY = true
@@ -285,6 +293,7 @@ end
 # - Gem::Net::HTTP#propfind: sends +PROPFIND+ request, returns response object.
 #
 class Gem::Net::HTTP::Propfind < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'PROPFIND'
   REQUEST_HAS_BODY = true
   RESPONSE_HAS_BODY = true
@@ -308,6 +317,7 @@ end
 # - Gem::Net::HTTP#proppatch: sends +PROPPATCH+ request, returns response object.
 #
 class Gem::Net::HTTP::Proppatch < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'PROPPATCH'
   REQUEST_HAS_BODY = true
   RESPONSE_HAS_BODY = true
@@ -331,6 +341,7 @@ end
 # - Gem::Net::HTTP#mkcol: sends +MKCOL+ request, returns response object.
 #
 class Gem::Net::HTTP::Mkcol < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'MKCOL'
   REQUEST_HAS_BODY = true
   RESPONSE_HAS_BODY = true
@@ -354,6 +365,7 @@ end
 # - Gem::Net::HTTP#copy: sends +COPY+ request, returns response object.
 #
 class Gem::Net::HTTP::Copy < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'COPY'
   REQUEST_HAS_BODY = false
   RESPONSE_HAS_BODY = true
@@ -377,6 +389,7 @@ end
 # - Gem::Net::HTTP#move: sends +MOVE+ request, returns response object.
 #
 class Gem::Net::HTTP::Move < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'MOVE'
   REQUEST_HAS_BODY = false
   RESPONSE_HAS_BODY = true
@@ -400,6 +413,7 @@ end
 # - Gem::Net::HTTP#lock: sends +LOCK+ request, returns response object.
 #
 class Gem::Net::HTTP::Lock < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'LOCK'
   REQUEST_HAS_BODY = true
   RESPONSE_HAS_BODY = true
@@ -423,8 +437,8 @@ end
 # - Gem::Net::HTTP#unlock: sends +UNLOCK+ request, returns response object.
 #
 class Gem::Net::HTTP::Unlock < Gem::Net::HTTPRequest
+  # :stopdoc:
   METHOD = 'UNLOCK'
   REQUEST_HAS_BODY = true
   RESPONSE_HAS_BODY = true
 end
-

data/lib/rubygems/vendor/net-http/lib/net/http/response.rb

@@ -153,6 +153,7 @@ class Gem::Net::HTTPResponse
     end
 
     private
+    # :stopdoc:
 
     def read_status_line(sock)
       str = sock.readline
@@ -259,7 +260,7 @@ class Gem::Net::HTTPResponse
   # header.
   attr_accessor :ignore_eof
 
-  def inspect
+  def inspect   # :nodoc:
     "#<#{self.class} #{@code} #{@message} readbody=#{@read}>"
   end