rubygems-update 3.0.3 → 3.4.7

data/lib/rubygems/ext/cargo_builder.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+# 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.
+class Gem::Ext::CargoBuilder < Gem::Ext::Builder
+  attr_accessor :spec, :runner, :profile
+
+  def initialize
+    require_relative "../command"
+    require_relative "cargo_builder/link_flag_converter"
+
+    @runner = self.class.method(:run)
+    @profile = :release
+  end
+
+  def build(extension, dest_path, results, args = [], lib_dir = nil, cargo_dir = Dir.pwd)
+    require "tempfile"
+    require "fileutils"
+
+    # Where's the Cargo.toml of the crate we're building
+    cargo_toml = File.join(cargo_dir, "Cargo.toml")
+    # What's the crate's name
+    crate_name = cargo_crate_name(cargo_dir, cargo_toml, results)
+
+    begin
+      # Create a tmp dir to do the build in
+      tmp_dest = Dir.mktmpdir(".gem.", cargo_dir)
+
+      # Run the build
+      cmd = cargo_command(cargo_toml, tmp_dest, args, crate_name)
+      runner.call(cmd, results, "cargo", cargo_dir, build_env)
+
+      # Where do we expect Cargo to write the compiled library
+      dylib_path = cargo_dylib_path(tmp_dest, crate_name)
+
+      # Helpful error if we didn't find the compiled library
+      raise DylibNotFoundError, tmp_dest unless File.exist?(dylib_path)
+
+      # Cargo and Ruby differ on how the library should be named, rename from
+      # what Cargo outputs to what Ruby expects
+      dlext_name = "#{crate_name}.#{makefile_config("DLEXT")}"
+      dlext_path = File.join(File.dirname(dylib_path), dlext_name)
+      FileUtils.cp(dylib_path, dlext_path)
+
+      nesting = extension_nesting(extension)
+
+      # TODO: remove in RubyGems 4
+      if Gem.install_extension_in_lib && lib_dir
+        nested_lib_dir = File.join(lib_dir, nesting)
+        FileUtils.mkdir_p nested_lib_dir
+        FileUtils.cp_r dlext_path, nested_lib_dir, remove_destination: true
+      end
+
+      # move to final destination
+      nested_dest_path = File.join(dest_path, nesting)
+      FileUtils.mkdir_p nested_dest_path
+      FileUtils.cp_r dlext_path, nested_dest_path, remove_destination: true
+    ensure
+      # clean up intermediary build artifacts
+      FileUtils.rm_rf tmp_dest if tmp_dest
+    end
+
+    results
+  end
+
+  def build_env
+    build_env = rb_config_env
+    build_env["RUBY_STATIC"] = "true" if ruby_static? && ENV.key?("RUBY_STATIC")
+    cfg = "--cfg=rb_sys_gem --cfg=rubygems --cfg=rubygems_#{Gem::VERSION.tr(".", "_")}"
+    build_env["RUSTFLAGS"] = [ENV["RUSTFLAGS"], cfg].compact.join(" ")
+    build_env
+  end
+
+  def cargo_command(cargo_toml, dest_path, args = [], crate_name = nil)
+    require "shellwords"
+
+    cmd = []
+    cmd += [cargo, "rustc"]
+    cmd += ["--crate-type", "cdylib"]
+    cmd += ["--target", ENV["CARGO_BUILD_TARGET"]] if ENV["CARGO_BUILD_TARGET"]
+    cmd += ["--target-dir", dest_path]
+    cmd += ["--manifest-path", cargo_toml]
+    cmd += ["--lib"]
+    cmd += ["--profile", profile.to_s]
+    cmd += ["--locked"]
+    cmd += Gem::Command.build_args
+    cmd += args
+    cmd += ["--"]
+    cmd += [*cargo_rustc_args(dest_path, crate_name)]
+    cmd
+  end
+
+  private
+
+  def cargo
+    ENV.fetch("CARGO", "cargo")
+  end
+
+  # returns the directory nesting of the extension, ignoring the first part, so
+  # "ext/foo/bar/Cargo.toml" becomes "foo/bar"
+  def extension_nesting(extension)
+    parts = extension.to_s.split(Regexp.union([File::SEPARATOR, File::ALT_SEPARATOR].compact))
+
+    parts = parts.each_with_object([]) do |segment, final|
+      next if segment == "."
+      if segment == ".."
+        raise Gem::InstallError, "extension outside of gem root" if final.empty?
+        next final.pop
+      end
+      final << segment
+    end
+
+    File.join(parts[1...-1])
+  end
+
+  def rb_config_env
+    result = {}
+    RbConfig::CONFIG.each {|k, v| result["RBCONFIG_#{k}"] = v }
+    result
+  end
+
+  def cargo_rustc_args(dest_dir, crate_name)
+    [
+      *linker_args,
+      *mkmf_libpath,
+      *rustc_dynamic_linker_flags(dest_dir, crate_name),
+      *rustc_lib_flags(dest_dir),
+      *platform_specific_rustc_args(dest_dir),
+    ]
+  end
+
+  def platform_specific_rustc_args(dest_dir, flags = [])
+    if mingw_target?
+      # On mingw platforms, mkmf adds libruby to the linker flags
+      flags += libruby_args(dest_dir)
+
+      # Make sure ALSR is used on mingw
+      # see https://github.com/rust-lang/rust/pull/75406/files
+      flags += ["-C", "link-arg=-Wl,--dynamicbase"]
+      flags += ["-C", "link-arg=-Wl,--disable-auto-image-base"]
+
+      # If the gem is installed on a host with build tools installed, but is
+      # run on one that isn't the missing libraries will cause the extension
+      # to fail on start.
+      flags += ["-C", "link-arg=-static-libgcc"]
+    elsif darwin_target?
+      # Ventura does not always have this flag enabled
+      flags += ["-C", "link-arg=-Wl,-undefined,dynamic_lookup"]
+    end
+
+    flags
+  end
+
+  # 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"))
+    linker = cc_flag.shift
+    link_args = cc_flag.flat_map {|a| ["-C", "link-arg=#{a}"] }
+
+    return mswin_link_args if linker == "cl"
+
+    ["-C", "linker=#{linker}", *link_args]
+  end
+
+  def mswin_link_args
+    args = []
+    args += ["-l", makefile_config("LIBRUBYARG_SHARED").chomp(".lib")]
+    args += split_flags("LIBS").flat_map {|lib| ["-l", lib.chomp(".lib")] }
+    args += split_flags("LOCAL_LIBS").flat_map {|lib| ["-l", lib.chomp(".lib")] }
+    args
+  end
+
+  def libruby_args(dest_dir)
+    libs = makefile_config(ruby_static? ? "LIBRUBYARG_STATIC" : "LIBRUBYARG_SHARED")
+    raw_libs = Shellwords.split(libs)
+    raw_libs.flat_map {|l| ldflag_to_link_modifier(l) }
+  end
+
+  def ruby_static?
+    return true if %w[1 true].include?(ENV["RUBY_STATIC"])
+
+    makefile_config("ENABLE_SHARED") == "no"
+  end
+
+  def cargo_dylib_path(dest_path, crate_name)
+    prefix = so_ext == "dll" ? "" : "lib"
+    path_parts = [dest_path]
+    path_parts << ENV["CARGO_BUILD_TARGET"] if ENV["CARGO_BUILD_TARGET"]
+    path_parts += ["release", "#{prefix}#{crate_name}.#{so_ext}"]
+    File.join(*path_parts)
+  end
+
+  def cargo_crate_name(cargo_dir, manifest_path, results)
+    require "open3"
+    Gem.load_yaml
+
+    output, status =
+      begin
+        Open3.capture2e(cargo, "metadata", "--no-deps", "--format-version", "1", :chdir => cargo_dir)
+      rescue => error
+        raise Gem::InstallError, "cargo metadata failed #{error.message}"
+      end
+
+    unless status.success?
+      if Gem.configuration.really_verbose
+        puts output
+      else
+        results << output
+      end
+
+      exit_reason =
+        if status.exited?
+          ", exit code #{status.exitstatus}"
+        elsif status.signaled?
+          ", uncaught signal #{status.termsig}"
+        end
+
+      raise Gem::InstallError, "cargo metadata failed#{exit_reason}"
+    end
+
+    # cargo metadata output is specified as json, but with the
+    # --format-version 1 option the output is compatible with YAML, so we can
+    # avoid the json dependency
+    metadata = Gem::SafeYAML.safe_load(output)
+    package = metadata["packages"].find {|pkg| normalize_path(pkg["manifest_path"]) == manifest_path }
+    unless package
+      found = metadata["packages"].map {|md| "#{md["name"]} at #{md["manifest_path"]}" }
+      raise Gem::InstallError, <<-EOF
+failed to determine cargo package name
+
+looking for: #{manifest_path}
+
+found:
+#{found.join("\n")}
+EOF
+    end
+    package["name"].tr("-", "_")
+  end
+
+  def normalize_path(path)
+    return path unless File::ALT_SEPARATOR
+
+    path.tr(File::ALT_SEPARATOR, File::SEPARATOR)
+  end
+
+  def rustc_dynamic_linker_flags(dest_dir, crate_name)
+    split_flags("DLDFLAGS")
+      .map {|arg| maybe_resolve_ldflag_variable(arg, dest_dir, crate_name) }
+      .compact
+      .flat_map {|arg| ldflag_to_link_modifier(arg) }
+  end
+
+  def rustc_lib_flags(dest_dir)
+    split_flags("LIBS").flat_map {|arg| ldflag_to_link_modifier(arg) }
+  end
+
+  def split_flags(var)
+    Shellwords.split(RbConfig::CONFIG.fetch(var, ""))
+  end
+
+  def ldflag_to_link_modifier(arg)
+    LinkFlagConverter.convert(arg)
+  end
+
+  def msvc_target?
+    makefile_config("target_os").include?("msvc")
+  end
+
+  def darwin_target?
+    makefile_config("target_os").include?("darwin")
+  end
+
+  def mingw_target?
+    makefile_config("target_os").include?("mingw")
+  end
+
+  def win_target?
+    target_platform = RbConfig::CONFIG["target_os"]
+    !!Gem::WIN_PATTERNS.find {|r| target_platform =~ r }
+  end
+
+  # Interpolate substitution vars in the arg (i.e. $(DEFFILE))
+  def maybe_resolve_ldflag_variable(input_arg, dest_dir, crate_name)
+    var_matches = input_arg.match(/\$\((\w+)\)/)
+
+    return input_arg unless var_matches
+
+    var_name = var_matches[1]
+
+    return input_arg if var_name.nil? || var_name.chomp.empty?
+
+    case var_name
+    # On windows, it is assumed that mkmf has setup an exports file for the
+    # extension, so we have to to create one ourselves.
+    when "DEFFILE"
+      write_deffile(dest_dir, crate_name)
+    else
+      RbConfig::CONFIG[var_name]
+    end
+  end
+
+  def write_deffile(dest_dir, crate_name)
+    deffile_path = File.join(dest_dir, "#{crate_name}-#{RbConfig::CONFIG["arch"]}.def")
+    export_prefix = makefile_config("EXPORT_PREFIX") || ""
+
+    File.open(deffile_path, "w") do |f|
+      f.puts "EXPORTS"
+      f.puts "#{export_prefix.strip}Init_#{crate_name}"
+    end
+
+    deffile_path
+  end
+
+  # We have to basically reimplement RbConfig::CONFIG['SOEXT'] here to support
+  # Ruby < 2.5
+  #
+  # @see https://github.com/ruby/ruby/blob/c87c027f18c005460746a74c07cd80ee355b16e4/configure.ac#L3185
+  def so_ext
+    return RbConfig::CONFIG["SOEXT"] if RbConfig::CONFIG.key?("SOEXT")
+
+    if win_target?
+      "dll"
+    elsif darwin_target?
+      "dylib"
+    else
+      "so"
+    end
+  end
+
+  # Corresponds to $(LIBPATH) in mkmf
+  def mkmf_libpath
+    ["-L", "native=#{makefile_config("libdir")}"]
+  end
+
+  def makefile_config(var_name)
+    val = RbConfig::MAKEFILE_CONFIG[var_name]
+
+    return unless val
+
+    RbConfig.expand(val.dup)
+  end
+
+  # Error raised when no cdylib artifact was created
+  class DylibNotFoundError < StandardError
+    def initialize(dir)
+      files = Dir.glob(File.join(dir, "**", "*")).map {|f| "- #{f}" }.join "\n"
+
+      super <<~MSG
+        Dynamic library not found for Rust extension (in #{dir})
+
+        Make sure you set "crate-type" in Cargo.toml to "cdylib"
+
+        Found files:
+        #{files}
+      MSG
+    end
+  end
+end

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, dest_path, results, args=[], lib_dir=nil)
-    unless File.exist?('Makefile')
-      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

@@ -6,18 +6,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, dest_path, results, args=[], lib_dir=nil)
-    unless File.exist?('Makefile')
-      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

@@ -5,80 +5,60 @@
 # See LICENSE.txt for permissions.
 #++
 
-require 'fileutils'
-require 'tempfile'
-require 'shellwords'
-
 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, 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.
+    # if the paths contain spaces.
     #
-    # Details: https://github.com/rubygems/rubygems/issues/977#issuecomment-171544940
-    tmp_dest = get_relative_path(tmp_dest)
-
-    Tempfile.open %w"siteconf .rb", "." do |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.close
-
-      destdir = ENV["DESTDIR"]
-
-      begin
-        cmd = Gem.ruby.shellsplit << "-I" << File.expand_path("../../..", __FILE__) <<
-              "-r" << get_relative_path(siteconf.path) << File.basename(extension)
-        cmd.push(*args)
-
-        begin
-          run cmd, results
-        ensure
-          if File.exist? 'mkmf.log'
-            unless $?.success?
-              results << "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"
-            end
-            FileUtils.mv 'mkmf.log', dest_path
+    # As such, we convert to a relative path.
+    tmp_dest_relative = get_relative_path(tmp_dest.clone, extension_dir)
+
+    destdir = ENV["DESTDIR"]
+
+    begin
+      require "shellwords"
+      cmd = Gem.ruby.shellsplit << "-I" << File.expand_path("../..", __dir__) << File.basename(extension)
+      cmd.push(*args)
+
+      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"
+            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
-            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
-        siteconf.close!
+      # 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
 
     results
@@ -87,9 +67,9 @@ class Gem::Ext::ExtConfBuilder < Gem::Ext::Builder
   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

@@ -5,31 +5,28 @@
 # See LICENSE.txt for permissions.
 #++
 
-require "shellwords"
-
 class Gem::Ext::RakeBuilder < Gem::Ext::Builder
-
-  def self.build(extension, dest_path, results, args=[], lib_dir=nil)
+  def self.build(extension, dest_path, results, args=[], lib_dir=nil, extension_dir=Dir.pwd)
     if File.basename(extension) =~ /mkrf_conf/i
-      run([Gem.ruby, File.basename(extension), *args], results)
+      run([Gem.ruby, File.basename(extension), *args], results, class_name, extension_dir)
     end
 
-    rake = ENV['rake']
+    rake = ENV["rake"]
 
     if rake
+      require "shellwords"
       rake = rake.shellsplit
     else
       begin
-        rake = [Gem.ruby, "-rrubygems", Gem.bin_path('rake', 'rake')]
+        rake = [Gem.ruby, "-I#{File.expand_path("../..", __dir__)}", "-rrubygems", Gem.bin_path("rake", "rake")]
       rescue Gem::Exception
-        rake = [Gem.default_exec_format % 'rake']
+        rake = [Gem.default_exec_format % "rake"]
       end
     end
 
     rake_args = ["RUBYARCHDIR=#{dest_path}", "RUBYLIBDIR=#{dest_path}", *args]
-    run(rake + rake_args, results)
+    run(rake + rake_args, results, class_name, extension_dir)
 
     results
   end
-
 end

data/lib/rubygems/ext.rb

@@ -10,9 +10,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

@@ -5,15 +5,9 @@
 # See LICENSE.txt for permissions.
 #++
 
-require 'rubygems'
-require 'rubygems/command_manager'
-require 'rubygems/config_file'
-require 'rubygems/deprecate'
-
-##
-# 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.
@@ -25,14 +19,9 @@ Gem.load_env_plugins rescue nil
 # classes they call directly.
 
 class Gem::GemRunner
-
-  def initialize(options={})
-    if !options.empty? && !Gem::Deprecate.skip
-      Kernel.warn "NOTE: passing options to Gem::GemRunner.new is deprecated with no replacement. It will be removed on or after 2016-10-01."
-    end
-
-    @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
 
   ##
@@ -43,16 +32,19 @@ class Gem::GemRunner
 
     do_configuration args
 
+    Gem.load_env_plugins rescue nil
+    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 ' '
-                    else
-                      Array(config_args)
-                    end
+      when String
+        config_args.split " "
+      else
+        Array(config_args)
+      end
       Gem::Command.add_specific_extra_args command_name, config_args
     end
 
@@ -64,7 +56,7 @@ class Gem::GemRunner
   # other arguments in the list.
 
   def extract_build_args(args) # :nodoc:
-    return [] unless offset = args.index('--')
+    return [] unless offset = args.index("--")
 
     build_args = args.slice!(offset...args.length)
 
@@ -80,7 +72,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