rubygems-update 2.6.1 → 3.5.0

data/lib/rubygems/ext/cmake_builder.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
-require 'rubygems/command'
 
 class Gem::Ext::CmakeBuilder < Gem::Ext::Builder
-  def self.build(extension, directory, dest_path, results, args=[], lib_dir=nil)
-    unless File.exist?('Makefile') then
-      cmd = "cmake . -DCMAKE_INSTALL_PREFIX=#{dest_path}"
-      cmd << " #{Gem::Command.build_args.join ' '}" unless Gem::Command.build_args.empty?
+  def self.build(extension, dest_path, results, args=[], lib_dir=nil, cmake_dir=Dir.pwd)
+    unless File.exist?(File.join(cmake_dir, "Makefile"))
+      require_relative "../command"
+      cmd = ["cmake", ".", "-DCMAKE_INSTALL_PREFIX=#{dest_path}", *Gem::Command.build_args]
 
-      run cmd, results
+      run cmd, results, class_name, cmake_dir
     end
 
-    make dest_path, results
+    make dest_path, results, cmake_dir
 
     results
   end

data/lib/rubygems/ext/configure_builder.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
@@ -6,19 +7,15 @@
 #++
 
 class Gem::Ext::ConfigureBuilder < Gem::Ext::Builder
+  def self.build(extension, dest_path, results, args=[], lib_dir=nil, configure_dir=Dir.pwd)
+    unless File.exist?(File.join(configure_dir, "Makefile"))
+      cmd = ["sh", "./configure", "--prefix=#{dest_path}", *args]
 
-  def self.build(extension, directory, dest_path, results, args=[], lib_dir=nil)
-    unless File.exist?('Makefile') then
-      cmd = "sh ./configure --prefix=#{dest_path}"
-      cmd << " #{args.join ' '}" unless args.empty?
-
-      run cmd, results
+      run cmd, results, class_name, configure_dir
     end
 
-    make dest_path, results
+    make dest_path, results, configure_dir
 
     results
   end
-
 end
-

data/lib/rubygems/ext/ext_conf_builder.rb

@@ -1,94 +1,73 @@
 # frozen_string_literal: true
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
 # See LICENSE.txt for permissions.
 #++
 
-require 'fileutils'
-require 'tempfile'
-
 class Gem::Ext::ExtConfBuilder < Gem::Ext::Builder
-  FileEntry = FileUtils::Entry_ # :nodoc:
+  def self.build(extension, dest_path, results, args=[], lib_dir=nil, extension_dir=Dir.pwd)
+    require "fileutils"
+    require "tempfile"
 
-  def self.build(extension, directory, dest_path, results, args=[], lib_dir=nil)
-    tmp_dest = Dir.mktmpdir(".gem.", ".")
+    tmp_dest = Dir.mktmpdir(".gem.", extension_dir)
 
     # Some versions of `mktmpdir` return absolute paths, which will break make
-    # if the paths contain spaces. However, on Ruby 1.9.x on Windows, relative
-    # paths cause all C extension builds to fail.
-    #
-    # As such, we convert to a relative path unless we are using Ruby 1.9.x on
-    # Windows. This means that when using Ruby 1.9.x on Windows, paths with
-    # spaces do not work.
-    #
-    # Details: https://github.com/rubygems/rubygems/issues/977#issuecomment-171544940
+    # if the paths contain spaces.
     #
-    # TODO: Make this unconditional when rubygems no longer supports Ruby 1.9.x.
-    tmp_dest = get_relative_path(tmp_dest) unless Gem.win_platform? && RUBY_VERSION <= '2.0'
+    # As such, we convert to a relative path.
+    tmp_dest_relative = get_relative_path(tmp_dest.clone, extension_dir)
 
-    t = nil
-    Tempfile.open %w"siteconf .rb", "." do |siteconf|
-      t = siteconf
-      siteconf.puts "require 'rbconfig'"
-      siteconf.puts "dest_path = #{tmp_dest.dump}"
-      %w[sitearchdir sitelibdir].each do |dir|
-        siteconf.puts "RbConfig::MAKEFILE_CONFIG['#{dir}'] = dest_path"
-        siteconf.puts "RbConfig::CONFIG['#{dir}'] = dest_path"
-      end
-
-      siteconf.flush
+    destdir = ENV["DESTDIR"]
 
-      destdir = ENV["DESTDIR"]
+    begin
+      cmd = ruby << File.basename(extension)
+      cmd.push(*args)
 
-      begin
-        cmd = [Gem.ruby, "-r", get_relative_path(siteconf.path), File.basename(extension), *args].join ' '
-
-        begin
-          run cmd, results
-        ensure
-          if File.exist? 'mkmf.log'
-            results << "To see why this extension failed to compile, please check" \
+      run(cmd, results, class_name, extension_dir) do |s, r|
+        mkmf_log = File.join(extension_dir, "mkmf.log")
+        if File.exist? mkmf_log
+          unless s.success?
+            r << "To see why this extension failed to compile, please check" \
               " the mkmf.log which can be found here:\n"
-            results << "  " + File.join(dest_path, 'mkmf.log') + "\n"
-            FileUtils.mv 'mkmf.log', dest_path
+            r << "  " + File.join(dest_path, "mkmf.log") + "\n"
           end
-          siteconf.unlink
+          FileUtils.mv mkmf_log, dest_path
         end
+      end
 
-        ENV["DESTDIR"] = nil
+      ENV["DESTDIR"] = nil
 
-        make dest_path, results
+      make dest_path, results, extension_dir, tmp_dest_relative
 
-        if tmp_dest
-          # TODO remove in RubyGems 3
-          if Gem.install_extension_in_lib and lib_dir then
-            FileUtils.mkdir_p lib_dir
-            entries = Dir.entries(tmp_dest) - %w[. ..]
-            entries = entries.map { |entry| File.join tmp_dest, entry }
-            FileUtils.cp_r entries, lib_dir, :remove_destination => true
-          end
+      full_tmp_dest = File.join(extension_dir, tmp_dest_relative)
 
-          FileEntry.new(tmp_dest).traverse do |ent|
-            destent = ent.class.new(dest_path, ent.rel)
-            destent.exist? or FileUtils.mv(ent.path, destent.path)
-          end
-        end
-      ensure
-        ENV["DESTDIR"] = destdir
+      # TODO: remove in RubyGems 4
+      if Gem.install_extension_in_lib && lib_dir
+        FileUtils.mkdir_p lib_dir
+        entries = Dir.entries(full_tmp_dest) - %w[. ..]
+        entries = entries.map {|entry| File.join full_tmp_dest, entry }
+        FileUtils.cp_r entries, lib_dir, remove_destination: true
       end
+
+      FileUtils::Entry_.new(full_tmp_dest).traverse do |ent|
+        destent = ent.class.new(dest_path, ent.rel)
+        destent.exist? || FileUtils.mv(ent.path, destent.path)
+      end
+
+      make dest_path, results, extension_dir, tmp_dest_relative, ["clean"]
+    ensure
+      ENV["DESTDIR"] = destdir
     end
-    t.unlink if t and t.path
 
     results
   ensure
     FileUtils.rm_rf tmp_dest if tmp_dest
   end
 
-  private
-  def self.get_relative_path(path)
-    path[0..Dir.pwd.length-1] = '.' if path.start_with?(Dir.pwd)
+  def self.get_relative_path(path, base)
+    path[0..base.length - 1] = "." if path.start_with?(base)
     path
   end
-
 end

data/lib/rubygems/ext/rake_builder.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require_relative "../shellwords"
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
@@ -6,32 +9,26 @@
 #++
 
 class Gem::Ext::RakeBuilder < Gem::Ext::Builder
-
-  def self.build(extension, directory, dest_path, results, args=[], lib_dir=nil)
-    if File.basename(extension) =~ /mkrf_conf/i then
-      cmd = "#{Gem.ruby} #{File.basename extension}"
-      cmd << " #{args.join " "}" unless args.empty?
-      run cmd, results
+  def self.build(extension, dest_path, results, args=[], lib_dir=nil, extension_dir=Dir.pwd)
+    if /mkrf_conf/i.match?(File.basename(extension))
+      run([Gem.ruby, File.basename(extension), *args], results, class_name, extension_dir)
     end
 
-    # Deal with possible spaces in the path, e.g. C:/Program Files
-    dest_path = '"' + dest_path.to_s + '"' if dest_path.to_s.include?(' ')
-
-    rake = ENV['rake']
-
-    rake ||= begin
-               "#{Gem.ruby} -rubygems #{Gem.bin_path('rake', 'rake')}"
-             rescue Gem::Exception
-             end
+    rake = ENV["rake"]
 
-    rake ||= Gem.default_exec_format % 'rake'
-
-    cmd = "#{rake} RUBYARCHDIR=#{dest_path} RUBYLIBDIR=#{dest_path}" # ENV is frozen
+    if rake
+      rake = Shellwords.split(rake)
+    else
+      begin
+        rake = ruby << "-rrubygems" << Gem.bin_path("rake", "rake")
+      rescue Gem::Exception
+        rake = [Gem.default_exec_format % "rake"]
+      end
+    end
 
-    run cmd, results
+    rake_args = ["RUBYARCHDIR=#{dest_path}", "RUBYLIBDIR=#{dest_path}", *args]
+    run(rake + rake_args, results, class_name, extension_dir)
 
     results
   end
-
 end
-

data/lib/rubygems/ext.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
@@ -10,10 +11,10 @@
 
 module Gem::Ext; end
 
-require 'rubygems/ext/build_error'
-require 'rubygems/ext/builder'
-require 'rubygems/ext/configure_builder'
-require 'rubygems/ext/ext_conf_builder'
-require 'rubygems/ext/rake_builder'
-require 'rubygems/ext/cmake_builder'
-
+require_relative "ext/build_error"
+require_relative "ext/builder"
+require_relative "ext/configure_builder"
+require_relative "ext/ext_conf_builder"
+require_relative "ext/rake_builder"
+require_relative "ext/cmake_builder"
+require_relative "ext/cargo_builder"

data/lib/rubygems/gem_runner.rb

@@ -1,18 +1,14 @@
 # frozen_string_literal: true
+
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
 # See LICENSE.txt for permissions.
 #++
 
-require 'rubygems'
-require 'rubygems/command_manager'
-require 'rubygems/config_file'
-
-##
-# Load additional plugins from $LOAD_PATH
-
-Gem.load_env_plugins rescue nil
+require_relative "../rubygems"
+require_relative "command_manager"
+require_relative "deprecate"
 
 ##
 # Run an instance of the gem program.
@@ -24,31 +20,36 @@ Gem.load_env_plugins rescue nil
 # classes they call directly.
 
 class Gem::GemRunner
-
-  def initialize(options={})
-    # TODO: nuke these options
-    @command_manager_class = options[:command_manager] || Gem::CommandManager
-    @config_file_class = options[:config_file] || Gem::ConfigFile
+  def initialize
+    @command_manager_class = Gem::CommandManager
+    @config_file_class = Gem::ConfigFile
   end
 
   ##
   # Run the gem command with the following arguments.
 
-  def run args
+  def run(args)
     build_args = extract_build_args args
 
     do_configuration args
 
+    begin
+      Gem.load_env_plugins
+    rescue StandardError
+      nil
+    end
+    Gem.load_plugins
+
     cmd = @command_manager_class.instance
 
     cmd.command_names.each do |command_name|
       config_args = Gem.configuration[command_name]
       config_args = case config_args
                     when String
-                      config_args.split ' '
+                      config_args.split " "
                     else
                       Array(config_args)
-                    end
+      end
       Gem::Command.add_specific_extra_args command_name, config_args
     end
 
@@ -59,8 +60,8 @@ class Gem::GemRunner
   # Separates the build arguments (those following <code>--</code>) from the
   # other arguments in the list.
 
-  def extract_build_args args # :nodoc:
-    return [] unless offset = args.index('--')
+  def extract_build_args(args) # :nodoc:
+    return [] unless offset = args.index("--")
 
     build_args = args.slice!(offset...args.length)
 
@@ -76,7 +77,4 @@ class Gem::GemRunner
     Gem.use_paths Gem.configuration[:gemhome], Gem.configuration[:gempath]
     Gem::Command.extra_args = Gem.configuration[:gem]
   end
-
 end
-
-Gem.load_plugins

data/lib/rubygems/gemcutter_utilities/webauthn_listener/response.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+##
+# The WebauthnListener Response class is used by the WebauthnListener to create
+# responses to be sent to the Gem host. It creates a Gem::Net::HTTPResponse instance
+# when initialized and can be converted to the appropriate format to be sent by a socket using `to_s`.
+# Gem::Net::HTTPResponse instances cannot be directly sent over a socket.
+#
+# Types of response classes:
+#   - OkResponse
+#   - NoContentResponse
+#   - BadRequestResponse
+#   - NotFoundResponse
+#   - MethodNotAllowedResponse
+#
+# Example usage:
+#
+#   server = TCPServer.new(0)
+#   socket = server.accept
+#
+#   response = OkResponse.for("https://rubygems.example")
+#   socket.print response.to_s
+#   socket.close
+#
+
+module Gem::GemcutterUtilities
+  class WebauthnListener
+    class Response
+      attr_reader :http_response
+
+      def self.for(host)
+        new(host)
+      end
+
+      def initialize(host)
+        @host = host
+
+        build_http_response
+      end
+
+      def to_s
+        status_line = "HTTP/#{@http_response.http_version} #{@http_response.code} #{@http_response.message}\r\n"
+        headers = @http_response.to_hash.map {|header, value| "#{header}: #{value.join(", ")}\r\n" }.join + "\r\n"
+        body = @http_response.body ? "#{@http_response.body}\n" : ""
+
+        status_line + headers + body
+      end
+
+      private
+
+      # Must be implemented in subclasses
+      def code
+        raise NotImplementedError
+      end
+
+      def reason_phrase
+        raise NotImplementedError
+      end
+
+      def body; end
+
+      def build_http_response
+        response_class = Gem::Net::HTTPResponse::CODE_TO_OBJ[code.to_s]
+        @http_response = response_class.new("1.1", code, reason_phrase)
+        @http_response.instance_variable_set(:@read, true)
+
+        add_connection_header
+        add_access_control_headers
+        add_body
+      end
+
+      def add_connection_header
+        @http_response["connection"] = "close"
+      end
+
+      def add_access_control_headers
+        @http_response["access-control-allow-origin"] = @host
+        @http_response["access-control-allow-methods"] = "POST"
+        @http_response["access-control-allow-headers"] = %w[Content-Type Authorization x-csrf-token]
+      end
+
+      def add_body
+        return unless body
+        @http_response["content-type"] = "text/plain; charset=utf-8"
+        @http_response["content-length"] = body.bytesize
+        @http_response.instance_variable_set(:@body, body)
+      end
+    end
+
+    class OkResponse < Response
+      private
+
+      def code
+        200
+      end
+
+      def reason_phrase
+        "OK"
+      end
+
+      def body
+        "success"
+      end
+    end
+
+    class NoContentResponse < Response
+      private
+
+      def code
+        204
+      end
+
+      def reason_phrase
+        "No Content"
+      end
+    end
+
+    class BadRequestResponse < Response
+      private
+
+      def code
+        400
+      end
+
+      def reason_phrase
+        "Bad Request"
+      end
+
+      def body
+        "missing code parameter"
+      end
+    end
+
+    class NotFoundResponse < Response
+      private
+
+      def code
+        404
+      end
+
+      def reason_phrase
+        "Not Found"
+      end
+    end
+
+    class MethodNotAllowedResponse < Response
+      private
+
+      def code
+        405
+      end
+
+      def reason_phrase
+        "Method Not Allowed"
+      end
+
+      def add_access_control_headers
+        super
+        @http_response["allow"] = %w[GET OPTIONS]
+      end
+    end
+  end
+end

data/lib/rubygems/gemcutter_utilities/webauthn_listener.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "webauthn_listener/response"
+
+##
+# The WebauthnListener class retrieves an OTP after a user successfully WebAuthns with the Gem host.
+# An instance opens a socket using the TCPServer instance given and listens for a request from the Gem host.
+# The request should be a GET request to the root path and contains the OTP code in the form
+# of a query parameter `code`. The listener will return the code which will be used as the OTP for
+# API requests.
+#
+# Types of responses sent by the listener after receiving a request:
+#   - 200 OK: OTP code was successfully retrieved
+#   - 204 No Content: If the request was an OPTIONS request
+#   - 400 Bad Request: If the request did not contain a query parameter `code`
+#   - 404 Not Found: The request was not to the root path
+#   - 405 Method Not Allowed: OTP code was not retrieved because the request was not a GET/OPTIONS request
+#
+# Example usage:
+#
+#   thread = Gem::WebauthnListener.listener_thread("https://rubygems.example", server)
+#   thread.join
+#   otp = thread[:otp]
+#   error = thread[:error]
+#
+
+module Gem::GemcutterUtilities
+  class WebauthnListener
+    attr_reader :host
+
+    def initialize(host)
+      @host = host
+    end
+
+    def self.listener_thread(host, server)
+      Thread.new do
+        thread = Thread.current
+        thread.abort_on_exception = true
+        thread.report_on_exception = false
+        thread[:otp] = new(host).wait_for_otp_code(server)
+      rescue Gem::WebauthnVerificationError => e
+        thread[:error] = e
+      ensure
+        server.close
+      end
+    end
+
+    def wait_for_otp_code(server)
+      loop do
+        socket = server.accept
+        request_line = socket.gets
+
+        method, req_uri, _protocol = request_line.split(" ")
+        req_uri = URI.parse(req_uri)
+
+        responder = SocketResponder.new(socket)
+
+        unless root_path?(req_uri)
+          responder.send(NotFoundResponse.for(host))
+          raise Gem::WebauthnVerificationError, "Page at #{req_uri.path} not found."
+        end
+
+        case method.upcase
+        when "OPTIONS"
+          responder.send(NoContentResponse.for(host))
+          next # will be GET
+        when "GET"
+          if otp = parse_otp_from_uri(req_uri)
+            responder.send(OkResponse.for(host))
+            return otp
+          end
+          responder.send(BadRequestResponse.for(host))
+          raise Gem::WebauthnVerificationError, "Did not receive OTP from #{host}."
+        else
+          responder.send(MethodNotAllowedResponse.for(host))
+          raise Gem::WebauthnVerificationError, "Invalid HTTP method #{method.upcase} received."
+        end
+      end
+    end
+
+    private
+
+    def root_path?(uri)
+      uri.path == "/"
+    end
+
+    def parse_otp_from_uri(uri)
+      require "cgi"
+
+      return if uri.query.nil?
+      CGI.parse(uri.query).dig("code", 0)
+    end
+
+    class SocketResponder
+      def initialize(socket)
+        @socket = socket
+      end
+
+      def send(response)
+        @socket.print response.to_s
+        @socket.close
+      end
+    end
+  end
+end