rubygems-update 3.6.8 → 3.7.0

data/lib/rubygems/basic_specification.rb

@@ -256,6 +256,13 @@ class Gem::BasicSpecification
     raise NotImplementedError
   end
 
+  def installable_on_platform?(target_platform) # :nodoc:
+    return true if [Gem::Platform::RUBY, nil, target_platform].include?(platform)
+    return true if Gem::Platform.new(platform) === target_platform
+
+    false
+  end
+
   def raw_require_paths # :nodoc:
     raise NotImplementedError
   end

data/lib/rubygems/commands/pristine_command.rb

@@ -137,11 +137,14 @@ extensions will be restored.
     specs.group_by(&:full_name_with_location).values.each do |grouped_specs|
       spec = grouped_specs.find {|s| !s.default_gem? } || grouped_specs.first
 
-      unless only_executables_or_plugins?
+      only_executables = options[:only_executables]
+      only_plugins = options[:only_plugins]
+
+      unless only_executables || only_plugins
         # Default gemspecs include changes provided by ruby-core installer that
         # can't currently be pristined (inclusion of compiled extension targets in
         # the file list). So stick to resetting executables if it's a default gem.
-        options[:only_executables] = true if spec.default_gem?
+        only_executables = true if spec.default_gem?
       end
 
       if options.key? :skip
@@ -151,14 +154,14 @@ extensions will be restored.
         end
       end
 
-      unless spec.extensions.empty? || options[:extensions] || only_executables_or_plugins?
+      unless spec.extensions.empty? || options[:extensions] || only_executables || only_plugins
         say "Skipped #{spec.full_name_with_location}, it needs to compile an extension"
         next
       end
 
       gem = spec.cache_file
 
-      unless File.exist?(gem) || only_executables_or_plugins?
+      unless File.exist?(gem) || only_executables || only_plugins
         require_relative "../remote_fetcher"
 
         say "Cached gem for #{spec.full_name_with_location} not found, attempting to fetch..."
@@ -194,10 +197,10 @@ extensions will be restored.
         bin_dir: bin_dir,
       }
 
-      if options[:only_executables]
+      if only_executables
         installer = Gem::Installer.for_spec(spec, installer_options)
         installer.generate_bin
-      elsif options[:only_plugins]
+      elsif only_plugins
         installer = Gem::Installer.for_spec(spec, installer_options)
         installer.generate_plugins
       else
@@ -208,10 +211,4 @@ extensions will be restored.
       say "Restored #{spec.full_name_with_location}"
     end
   end
-
-  private
-
-  def only_executables_or_plugins?
-    options[:only_executables] || options[:only_plugins]
-  end
 end

data/lib/rubygems/commands/push_command.rb

@@ -92,7 +92,8 @@ The push command will use ~/.gem/credentials to authenticate to a server, but yo
   private
 
   def send_push_request(name, args)
-    rubygems_api_request(*args, scope: get_push_scope) do |request|
+    scope = get_push_scope
+    rubygems_api_request(*args, scope: scope) do |request|
       body = Gem.read_binary name
       if options[:attestations].any?
         request.set_form([

data/lib/rubygems/commands/setup_command.rb

@@ -7,8 +7,8 @@ require_relative "../command"
 # RubyGems checkout or tarball.
 
 class Gem::Commands::SetupCommand < Gem::Command
-  HISTORY_HEADER = %r{^#\s*[\d.a-zA-Z]+\s*/\s*\d{4}-\d{2}-\d{2}\s*$}
-  VERSION_MATCHER = %r{^#\s*([\d.a-zA-Z]+)\s*/\s*\d{4}-\d{2}-\d{2}\s*$}
+  HISTORY_HEADER = %r{^##\s*[\d.a-zA-Z]+\s*/\s*\d{4}-\d{2}-\d{2}\s*$}
+  VERSION_MATCHER = %r{^##\s*([\d.a-zA-Z]+)\s*/\s*\d{4}-\d{2}-\d{2}\s*$}
 
   ENV_PATHS = %w[/usr/bin/env /bin/env].freeze
 

data/lib/rubygems/core_ext/kernel_require.rb

@@ -64,8 +64,11 @@ module Kernel
           rp
         end
 
-        Kernel.send(:gem, name, Gem::Requirement.default_prerelease) unless
-          resolved_path
+        next if resolved_path
+
+        Kernel.send(:gem, name, Gem::Requirement.default_prerelease)
+
+        Gem.load_bundler_extensions(Gem.loaded_specs[name].version) if name == "bundler"
 
         next
       end

data/lib/rubygems/ext/builder.rb

@@ -7,7 +7,6 @@
 #++
 
 require_relative "../user_interaction"
-require_relative "../shellwords"
 
 class Gem::Ext::Builder
   include Gem::UserInteraction
@@ -29,7 +28,7 @@ class Gem::Ext::Builder
     target_rbconfig["configure_args"] =~ /with-make-prog\=(\w+)/
     make_program_name = ENV["MAKE"] || ENV["make"] || $1
     make_program_name ||= RUBY_PLATFORM.include?("mswin") ? "nmake" : "make"
-    make_program = Shellwords.split(make_program_name)
+    make_program = shellsplit(make_program_name)
 
     # The installation of the bundled gems is failed when DESTDIR is empty in mswin platform.
     destdir = /\bnmake/i !~ make_program_name || ENV["DESTDIR"] && ENV["DESTDIR"] != "" ? format("DESTDIR=%s", ENV["DESTDIR"]) : ""
@@ -58,7 +57,7 @@ class Gem::Ext::Builder
 
   def self.ruby
     # Gem.ruby is quoted if it contains whitespace
-    cmd = Shellwords.split(Gem.ruby)
+    cmd = shellsplit(Gem.ruby)
 
     # This load_path is only needed when running rubygems test without a proper installation.
     # Prepending it in a normal installation will cause problem with order of $LOAD_PATH.
@@ -83,7 +82,7 @@ class Gem::Ext::Builder
         p(command)
       end
       results << "current directory: #{dir}"
-      results << Shellwords.join(command)
+      results << shelljoin(command)
 
       require "open3"
       # Set $SOURCE_DATE_EPOCH for the subprocess.
@@ -127,6 +126,18 @@ class Gem::Ext::Builder
     end
   end
 
+  def self.shellsplit(command)
+    require "shellwords"
+
+    Shellwords.split(command)
+  end
+
+  def self.shelljoin(command)
+    require "shellwords"
+
+    Shellwords.join(command)
+  end
+
   ##
   # Creates a new extension builder for +spec+.  If the +spec+ does not yet
   # have build arguments, saved, set +build_args+ which is an ARGV-style

data/lib/rubygems/ext/cargo_builder.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../shellwords"
-
 # This class is used by rubygems to build Rust extensions. It is a thin-wrapper
 # over the `cargo rustc` command which takes care of building Rust code in a way
 # that Ruby can use.
@@ -159,7 +157,11 @@ class Gem::Ext::CargoBuilder < Gem::Ext::Builder
   # We want to use the same linker that Ruby uses, so that the linker flags from
   # mkmf work properly.
   def linker_args
-    cc_flag = Shellwords.split(makefile_config("CC"))
+    cc_flag = self.class.shellsplit(makefile_config("CC"))
+    # Avoid to ccache like tool from Rust build
+    # see https://github.com/rubygems/rubygems/pull/8521#issuecomment-2689854359
+    # ex. CC="ccache gcc" or CC="sccache clang --any --args"
+    cc_flag.shift if cc_flag.size >= 2 && !cc_flag[1].start_with?("-")
     linker = cc_flag.shift
     link_args = cc_flag.flat_map {|a| ["-C", "link-arg=#{a}"] }
 
@@ -178,7 +180,7 @@ class Gem::Ext::CargoBuilder < Gem::Ext::Builder
 
   def libruby_args(dest_dir)
     libs = makefile_config(ruby_static? ? "LIBRUBYARG_STATIC" : "LIBRUBYARG_SHARED")
-    raw_libs = Shellwords.split(libs)
+    raw_libs = self.class.shellsplit(libs)
     raw_libs.flat_map {|l| ldflag_to_link_modifier(l) }
   end
 
@@ -261,7 +263,7 @@ EOF
   end
 
   def split_flags(var)
-    Shellwords.split(RbConfig::CONFIG.fetch(var, ""))
+    self.class.shellsplit(RbConfig::CONFIG.fetch(var, ""))
   end
 
   def ldflag_to_link_modifier(arg)

data/lib/rubygems/ext/rake_builder.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../shellwords"
-
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
@@ -22,7 +20,7 @@ class Gem::Ext::RakeBuilder < Gem::Ext::Builder
     rake = ENV["rake"]
 
     if rake
-      rake = Shellwords.split(rake)
+      rake = shellsplit(rake)
     else
       begin
         rake = ruby << "-rrubygems" << Gem.bin_path("rake", "rake")

data/lib/rubygems/gemcutter_utilities/webauthn_listener.rb

@@ -85,10 +85,17 @@ module Gem::GemcutterUtilities
     end
 
     def parse_otp_from_uri(uri)
-      require "cgi"
+      query = uri.query
+      return unless query && !query.empty?
 
-      return if uri.query.nil?
-      CGI.parse(uri.query).dig("code", 0)
+      query.split("&") do |param|
+        key, value = param.split("=", 2)
+        if value && Gem::URI.decode_www_form_component(key) == "code"
+          return Gem::URI.decode_www_form_component(value)
+        end
+      end
+
+      nil
     end
 
     class SocketResponder

data/lib/rubygems/gemcutter_utilities.rb

@@ -263,7 +263,10 @@ module Gem::GemcutterUtilities
       port = server.addr[1].to_s
 
       url_with_port = "#{webauthn_url}?port=#{port}"
-      say "You have enabled multi-factor authentication. Please visit #{url_with_port} to authenticate via security device. If you can't verify using WebAuthn but have OTP enabled, you can re-run the gem signin command with the `--otp [your_code]` option."
+      say "You have enabled multi-factor authentication. Please visit the following URL to authenticate via security device. If you can't verify using WebAuthn but have OTP enabled, you can re-run the gem signin command with the `--otp [your_code]` option."
+      say ""
+      say url_with_port
+      say ""
 
       threads = [WebauthnListener.listener_thread(host, server), WebauthnPoller.poll_thread(options, host, webauthn_url, credentials)]
       otp_thread = wait_for_otp_thread(*threads)
@@ -316,7 +319,7 @@ module Gem::GemcutterUtilities
   end
 
   def get_scope_params(scope)
-    scope_params = { index_rubygems: true }
+    scope_params = { index_rubygems: true, push_rubygem: true }
 
     if scope
       scope_params = { scope => true }

data/lib/rubygems/installer.rb

@@ -228,8 +228,7 @@ class Gem::Installer
       ruby_executable = true
       existing = io.read.slice(/
           ^\s*(
-            gem \s |
-            load \s Gem\.bin_path\( |
+            Gem\.activate_and_load_bin_path\( |
             load \s Gem\.activate_bin_path\(
           )
           (['"])(.*?)(\2),
@@ -749,54 +748,53 @@ class Gem::Installer
   def app_script_text(bin_file_name)
     # NOTE: that the `load` lines cannot be indented, as old RG versions match
     # against the beginning of the line
-    <<-TEXT
-#{shebang bin_file_name}
-#
-# This file was generated by RubyGems.
-#
-# The application '#{spec.name}' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require 'rubygems'
-#{gemdeps_load(spec.name)}
-version = "#{Gem::Requirement.default_prerelease}"
-
-str = ARGV.first
-if str
-  str = str.b[/\\A_(.*)_\\z/, 1]
-  if str and Gem::Version.correct?(str)
-    #{explicit_version_requirement(spec.name)}
-    ARGV.shift
-  end
-end
+    <<~TEXT
+      #{shebang bin_file_name}
+      #
+      # This file was generated by RubyGems.
+      #
+      # The application '#{spec.name}' is installed as part of a gem, and
+      # this file is here to facilitate running it.
+      #
+
+      require 'rubygems'
+      #{gemdeps_load(spec.name)}
+      version = "#{Gem::Requirement.default_prerelease}"
+
+      str = ARGV.first
+      if str
+        str = str.b[/\\A_(.*)_\\z/, 1]
+        if str and Gem::Version.correct?(str)
+          #{explicit_version_requirement(spec.name)}
+          ARGV.shift
+        end
+      end
 
-if Gem.respond_to?(:activate_bin_path)
-load Gem.activate_bin_path('#{spec.name}', '#{bin_file_name}', version)
-else
-gem #{spec.name.dump}, version
-load Gem.bin_path(#{spec.name.dump}, #{bin_file_name.dump}, version)
-end
-TEXT
+      if Gem.respond_to?(:activate_and_load_bin_path)
+        Gem.activate_and_load_bin_path('#{spec.name}', '#{bin_file_name}', version)
+      else
+        load Gem.activate_bin_path('#{spec.name}', '#{bin_file_name}', version)
+      end
+    TEXT
   end
 
   def gemdeps_load(name)
     return "" if name == "bundler"
 
-    <<-TEXT
+    <<~TEXT
 
-Gem.use_gemdeps
-TEXT
+      Gem.use_gemdeps
+    TEXT
   end
 
   def explicit_version_requirement(name)
     code = "version = str"
     return code unless name == "bundler"
 
-    code += <<-TEXT
+    code += <<~TEXT
 
-    ENV['BUNDLER_VERSION'] = str
-TEXT
+      ENV['BUNDLER_VERSION'] = str
+    TEXT
   end
 
   ##
@@ -811,9 +809,9 @@ TEXT
 
     if File.exist?(File.join(bindir, ruby_exe))
       # stub & ruby.exe within same folder.  Portable
-      <<-TEXT
-@ECHO OFF
-@"%~dp0#{ruby_exe}" "%~dpn0" %*
+      <<~TEXT
+        @ECHO OFF
+        @"%~dp0#{ruby_exe}" "%~dpn0" %*
       TEXT
     elsif bindir.downcase.start_with? rb_topdir.downcase
       # stub within ruby folder, but not standard bin.  Portable
@@ -821,16 +819,16 @@ TEXT
       from = Pathname.new bindir
       to   = Pathname.new "#{rb_topdir}/bin"
       rel  = to.relative_path_from from
-      <<-TEXT
-@ECHO OFF
-@"%~dp0#{rel}/#{ruby_exe}" "%~dpn0" %*
+      <<~TEXT
+        @ECHO OFF
+        @"%~dp0#{rel}/#{ruby_exe}" "%~dpn0" %*
       TEXT
     else
       # outside ruby folder, maybe -user-install or bundler.  Portable, but ruby
       # is dependent on PATH
-      <<-TEXT
-@ECHO OFF
-@#{ruby_exe} "%~dpn0" %*
+      <<~TEXT
+        @ECHO OFF
+        @#{ruby_exe} "%~dpn0" %*
       TEXT
     end
   end
@@ -953,11 +951,8 @@ TEXT
   end
 
   def ensure_writable_dir(dir) # :nodoc:
-    begin
-      Dir.mkdir dir, *[options[:dir_mode] && 0o755].compact
-    rescue SystemCallError
-      raise unless File.directory? dir
-    end
+    require "fileutils"
+    FileUtils.mkdir_p dir, mode: options[:dir_mode] && 0o755
 
     raise Gem::FilePermissionError.new(dir) unless File.writable? dir
   end

data/lib/rubygems/package/tar_writer.rb

@@ -95,10 +95,11 @@ class Gem::Package::TarWriter
   end
 
   ##
-  # Adds file +name+ with permissions +mode+, and yields an IO for writing the
-  # file to
+  # Adds file +name+ with permissions +mode+ and mtime +mtime+ (sets
+  # Gem.source_date_epoch if not specified), and yields an IO for
+  # writing the file to
 
-  def add_file(name, mode) # :yields: io
+  def add_file(name, mode, mtime=nil) # :yields: io
     check_closed
 
     name, prefix = split_name name
@@ -118,7 +119,7 @@ class Gem::Package::TarWriter
 
     header = Gem::Package::TarHeader.new name: name, mode: mode,
                                          size: size, prefix: prefix,
-                                         mtime: Gem.source_date_epoch
+                                         mtime: mtime || Gem.source_date_epoch
 
     @io.write header
     @io.pos = final_pos

data/lib/rubygems/platform.rb

@@ -88,56 +88,45 @@ class Gem::Platform
     when Array then
       @cpu, @os, @version = arch
     when String then
-      arch = arch.split "-"
+      cpu, os = arch.sub(/-+$/, "").split("-", 2)
 
-      if arch.length > 2 && !arch.last.match?(/\d+(\.\d+)?$/) # reassemble x86-linux-{libc}
-        extra = arch.pop
-        arch.last << "-#{extra}"
-      end
-
-      cpu = arch.shift
-
-      @cpu = case cpu
-             when /i\d86/ then "x86"
-             else cpu
-      end
-
-      if arch.length == 2 && arch.last.match?(/^\d+(\.\d+)?$/) # for command-line
-        @os, @version = arch
-        return
+      @cpu = if cpu.match?(/i\d86/)
+        "x86"
+      else
+        cpu
       end
 
-      os, = arch
       if os.nil?
         @cpu = nil
         os = cpu
       end # legacy jruby
 
       @os, @version = case os
-                      when /aix(\d+)?/ then             ["aix",       $1]
-                      when /cygwin/ then                ["cygwin",    nil]
-                      when /darwin(\d+)?/ then          ["darwin",    $1]
-                      when /^macruby$/ then             ["macruby",   nil]
-                      when /freebsd(\d+)?/ then         ["freebsd",   $1]
-                      when /^java$/, /^jruby$/ then     ["java",      nil]
-                      when /^java([\d.]*)/ then         ["java",      $1]
-                      when /^dalvik(\d+)?$/ then        ["dalvik",    $1]
-                      when /^dotnet$/ then              ["dotnet",    nil]
-                      when /^dotnet([\d.]*)/ then       ["dotnet",    $1]
-                      when /linux-?(\w+)?/ then         ["linux",     $1]
-                      when /mingw32/ then               ["mingw32",   nil]
-                      when /mingw-?(\w+)?/ then         ["mingw",     $1]
-                      when /(mswin\d+)(\_(\d+))?/ then
+                      when /aix-?(\d+)?/ then                ["aix",     $1]
+                      when /cygwin/ then                     ["cygwin",  nil]
+                      when /darwin-?(\d+)?/ then             ["darwin",  $1]
+                      when "macruby" then                    ["macruby", nil]
+                      when /^macruby-?(\d+(?:\.\d+)*)?/ then ["macruby", $1]
+                      when /freebsd-?(\d+)?/ then            ["freebsd", $1]
+                      when "java", "jruby" then              ["java",    nil]
+                      when /^java-?(\d+(?:\.\d+)*)?/ then    ["java",    $1]
+                      when /^dalvik-?(\d+)?$/ then           ["dalvik",  $1]
+                      when /^dotnet$/ then                   ["dotnet",  nil]
+                      when /^dotnet-?(\d+(?:\.\d+)*)?/ then  ["dotnet",  $1]
+                      when /linux-?(\w+)?/ then              ["linux",   $1]
+                      when /mingw32/ then                    ["mingw32", nil]
+                      when /mingw-?(\w+)?/ then              ["mingw",   $1]
+                      when /(mswin\d+)(?:[_-](\d+))?/ then
                         os = $1
-                        version = $3
-                        @cpu = "x86" if @cpu.nil? && os =~ /32$/
+                        version = $2
+                        @cpu = "x86" if @cpu.nil? && os.end_with?("32")
                         [os, version]
-                      when /netbsdelf/ then             ["netbsdelf", nil]
-                      when /openbsd(\d+\.\d+)?/ then    ["openbsd",   $1]
-                      when /solaris(\d+\.\d+)?/ then    ["solaris",   $1]
-                      when /wasi/ then                  ["wasi",      nil]
+                      when /netbsdelf/ then                  ["netbsdelf", nil]
+                      when /openbsd-?(\d+\.\d+)?/ then       ["openbsd",   $1]
+                      when /solaris-?(\d+\.\d+)?/ then       ["solaris",   $1]
+                      when /wasi/ then                       ["wasi",      nil]
                       # test
-                      when /^(\w+_platform)(\d+)?/ then [$1,          $2]
+                      when /^(\w+_platform)-?(\d+)?/ then    [$1,          $2]
                       else ["unknown", nil]
       end
     when Gem::Platform then
@@ -154,7 +143,7 @@ class Gem::Platform
   end
 
   def to_s
-    to_a.compact.join "-"
+    to_a.compact.join(@cpu.nil? ? "" : "-")
   end
 
   ##
@@ -266,4 +255,118 @@ class Gem::Platform
   # This will be replaced with Gem::Platform::local.
 
   CURRENT = "current"
+
+  JAVA  = Gem::Platform.new("java") # :nodoc:
+  MSWIN = Gem::Platform.new("mswin32") # :nodoc:
+  MSWIN64 = Gem::Platform.new("mswin64") # :nodoc:
+  MINGW = Gem::Platform.new("x86-mingw32") # :nodoc:
+  X64_MINGW_LEGACY = Gem::Platform.new("x64-mingw32") # :nodoc:
+  X64_MINGW = Gem::Platform.new("x64-mingw-ucrt") # :nodoc:
+  UNIVERSAL_MINGW = Gem::Platform.new("universal-mingw") # :nodoc:
+  WINDOWS = [MSWIN, MSWIN64, UNIVERSAL_MINGW].freeze # :nodoc:
+  X64_LINUX = Gem::Platform.new("x86_64-linux") # :nodoc:
+  X64_LINUX_MUSL = Gem::Platform.new("x86_64-linux-musl") # :nodoc:
+
+  GENERICS = [JAVA, *WINDOWS].freeze # :nodoc:
+  private_constant :GENERICS
+
+  GENERIC_CACHE = GENERICS.each_with_object({}) {|g, h| h[g] = g } # :nodoc:
+  private_constant :GENERIC_CACHE
+
+  class << self
+    ##
+    # Returns the generic platform for the given platform.
+
+    def generic(platform)
+      return Gem::Platform::RUBY if platform.nil? || platform == Gem::Platform::RUBY
+
+      GENERIC_CACHE[platform] ||= begin
+        found = GENERICS.find do |match|
+          platform === match
+        end
+        found || Gem::Platform::RUBY
+      end
+    end
+
+    ##
+    # Returns the platform specificity match for the given spec platform and user platform.
+
+    def platform_specificity_match(spec_platform, user_platform)
+      return -1 if spec_platform == user_platform
+      return 1_000_000 if spec_platform.nil? || spec_platform == Gem::Platform::RUBY || user_platform == Gem::Platform::RUBY
+
+      os_match(spec_platform, user_platform) +
+        cpu_match(spec_platform, user_platform) * 10 +
+        version_match(spec_platform, user_platform) * 100
+    end
+
+    ##
+    # Sorts and filters the best platform match for the given matching specs and platform.
+
+    def sort_and_filter_best_platform_match(matching, platform)
+      return matching if matching.one?
+
+      exact = matching.select {|spec| spec.platform == platform }
+      return exact if exact.any?
+
+      sorted_matching = sort_best_platform_match(matching, platform)
+      exemplary_spec = sorted_matching.first
+
+      sorted_matching.take_while {|spec| same_specificity?(platform, spec, exemplary_spec) && same_deps?(spec, exemplary_spec) }
+    end
+
+    ##
+    # Sorts the best platform match for the given matching specs and platform.
+
+    def sort_best_platform_match(matching, platform)
+      matching.sort_by.with_index do |spec, i|
+        [
+          platform_specificity_match(spec.platform, platform),
+          i, # for stable sort
+        ]
+      end
+    end
+
+    private
+
+    def same_specificity?(platform, spec, exemplary_spec)
+      platform_specificity_match(spec.platform, platform) == platform_specificity_match(exemplary_spec.platform, platform)
+    end
+
+    def same_deps?(spec, exemplary_spec)
+      spec.required_ruby_version == exemplary_spec.required_ruby_version &&
+        spec.required_rubygems_version == exemplary_spec.required_rubygems_version &&
+        spec.dependencies.sort == exemplary_spec.dependencies.sort
+    end
+
+    def os_match(spec_platform, user_platform)
+      if spec_platform.os == user_platform.os
+        0
+      else
+        1
+      end
+    end
+
+    def cpu_match(spec_platform, user_platform)
+      if spec_platform.cpu == user_platform.cpu
+        0
+      elsif spec_platform.cpu == "arm" && user_platform.cpu.to_s.start_with?("arm")
+        0
+      elsif spec_platform.cpu.nil? || spec_platform.cpu == "universal"
+        1
+      else
+        2
+      end
+    end
+
+    def version_match(spec_platform, user_platform)
+      if spec_platform.version == user_platform.version
+        0
+      elsif spec_platform.version.nil?
+        1
+      else
+        2
+      end
+    end
+  end
 end

data/lib/rubygems/remote_fetcher.rb

@@ -267,7 +267,7 @@ class Gem::RemoteFetcher
 
   def fetch_s3(uri, mtime = nil, head = false)
     begin
-      public_uri = s3_uri_signer(uri).sign
+      public_uri = s3_uri_signer(uri, head ? "HEAD" : "GET").sign
     rescue Gem::S3URISigner::ConfigurationError, Gem::S3URISigner::InstanceProfileError => e
       raise FetchError.new(e.message, "s3://#{uri.host}")
     end
@@ -275,8 +275,8 @@ class Gem::RemoteFetcher
   end
 
   # we have our own signing code here to avoid a dependency on the aws-sdk gem
-  def s3_uri_signer(uri)
-    Gem::S3URISigner.new(uri)
+  def s3_uri_signer(uri, method)
+    Gem::S3URISigner.new(uri, method)
   end
 
   ##