rb_sys 0.9.59 → 0.9.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d0c1e0630a88954cda754dbb7db45842203cacd6fd265ea75a0424989d66e34
-  data.tar.gz: 94d12fe7fe913ffb00ac9343a3ab594e3701d82f99fda2ab99a79e654bd4259e
+  metadata.gz: 123a974ae1143185fe76488a7869cb2c388046c72c07ea774b9d6ef04d76ac3d
+  data.tar.gz: fbb7fe655195f3afac258f93df6a43ecb414faa1697140500afc09153872654d
 SHA512:
-  metadata.gz: 618d433d7992df2fab66bdeb03204d0e699a4594881bc48bd61a4c5359b94eb25f26fd0eb9f2cd57038d4130c125383069267e125edc92d5761ef920ae3a6d87
-  data.tar.gz: 1d6aa9c2039dffc0093bed770be24703f88ec95164ad87d24913e1889e9697206a1ef461e405f57ef1b56e02f505b7dc86e36839d8df7a1f972aa8973b94b186
+  metadata.gz: 114714eacc8d7bd88e7fe2169d5b4356d39add07f44148650805af0e6212de154fddc5464ec7c23847b5632c1474513e83b4dfd30d15eb28ff1218c222c122aa
+  data.tar.gz: 0d6933769276e790671ab4717a756a874045c7a037eaac4220fb5a89c56798006461b3fd5d5cc99096eed05e56bfda9f553ca4fbfb71c946f986d20a13018b28

checksums.yaml.gz.sig

@@ -1 +1,3 @@
-8�y/���$�\���͟��G�ߎd�Q*ۈ����:6!G��Z#�&wl��G��6_��� ��������Gwc�IP:J��׿���Ӯ�2#��ڇ9!)/}F(�Z�upj�i�?g�O�������\d'q���w[��آ�8�B�8�t��c�`Y�<+��YK~��e�I֗2����u���Q��b��R]|m�@\����R�p���Vﾧ��ͅ��HZG[����ߍa��n�M1�	S������
+�z9Rb�R�4�]f=!�Yκ�Cm�_�ZO,��ͣ�FD���ޘm��u��$3����[�!L3.1��7"Q�4��y�$f̓
+�T�UF�!Ȓ�yF�S)��x�����.��{���O2���
+t5�g��=K��ÏvķzvD#�J_e��N�q�4�ǻsC1=�;�J�T�Z�W����E?Ӎ%�����컜4<Х.�)քڀK߀��㭭�l2ݪ�b�+1�Q1d��n�_����Խo�~]D3D
x��.�BM�z�

data/exe/rb-sys-dock

@@ -4,6 +4,7 @@ require "optparse"
 require "rb_sys/version"
 require "rb_sys/toolchain_info"
 require "fileutils"
+require "tmpdir"
 
 options = {
   version: RbSys::VERSION
@@ -101,6 +102,7 @@ OptionParser.new do |opts|
   opts.on("--latest", "Use the latest version of the Docker image") do
     log(:notice, "Using latest version of the Docker image", emoji: "🆕")
     options[:version] = "latest"
+    options[:no_cache] = true
   end
 
   opts.on("--list-platforms", "--list", "List all supported platforms") do
@@ -113,6 +115,18 @@ OptionParser.new do |opts|
     exit(0)
   end
 
+  opts.on("--ruby-versions LIST", "List all supported Ruby versions") do |arg|
+    log(:notice, "Requested Ruby versions: #{arg}")
+
+    vers = arg.split(/[^0-9.]/).map do |v|
+      parts = v.split(".")
+      parts[2] = "0" if parts[2].nil?
+      parts.join(".")
+    end
+
+    ENV["RUBY_CC_VERSION"] = vers.join(":")
+  end
+
   opts.on("-h", "--help", "Prints this help") do
     puts opts
     exit
@@ -123,6 +137,10 @@ OptionParser.new do |opts|
     ENV["VERBOSE"] = "1"
     options[:verbose] = true
   end
+
+  opts.on("--build", "Build the Docker image") do
+    options[:build] = true
+  end
 end.parse!
 
 def determine_cache_dir
@@ -160,48 +178,91 @@ def mount_cargo_registry
   "--mount type=bind,source=#{File.join(local_registry_dir, dir)},target=#{File.join("/usr/local/cargo", dir)},readonly=false"
 end
 
-def mount_bundle_cache(options, extra_env)
-  dir = File.join(cache_dir, options.fetch(:platform), "bundle")
+def volume(src, dest, mode: "rw")
+  "--volume #{src}:#{dest}:rw"
+end
+
+def mount_bundle_cache(options)
+  dir = File.join(cache_dir, options.fetch(:toolchain_info).platform, "bundle")
+  bundle_path = File.join(docker_tmp, "bundle")
   FileUtils.mkdir_p(dir)
   log(:trace, "Mounting bundle cache: #{dir}")
-  "-v #{dir}:#{File.join(docker_tmp, "bundle")}"
+
+  "#{volume(dir, bundle_path)} -e BUNDLE_PATH=#{bundle_path.inspect}"
 end
 
-def mount_target_dir(options, _extra_env)
-  tmp_target_dir = File.join(Dir.pwd, "tmp", "rb-sys-dock", options[:platform], "target")
-  FileUtils.mkdir_p(tmp_target_dir)
-  "-v #{tmp_target_dir}:#{File.join(Dir.pwd, "target")}"
+def tmp_target_dir(options)
+  return @tmp_target_dir if defined?(@tmp_target_dir)
+
+  dir = File.join(Dir.pwd, "tmp", "rb-sys-dock", options.fetch(:toolchain_info).platform, "target")
+  FileUtils.mkdir_p(dir)
+  @tmp_target_dir = dir
+end
+
+def mount_target_dir(options)
+  "-v #{tmp_target_dir(options)}:#{File.join(Dir.pwd, "target")}"
 end
 
 def mount_command_history(options)
   return unless $stdin.tty?
 
   history_dir = File.join(cache_dir, options.fetch(:platform), "commandhistory")
+  FileUtils.mkdir_p(history_dir)
   "-v #{history_dir}:#{File.join(docker_tmp, "commandhistory")}"
 end
 
+def default_command_to_run(input_args, options)
+  input_cmd = input_args.empty? ? "true" : input_args.join(" ")
+
+  if options[:build]
+    with_bundle = +"test -f Gemfile && bundle install && #{input_cmd} && bundle exec rake native:$RUBY_TARGET gem"
+    without_bundle = "#{input_cmd} && rake native:$RUBY_TARGET gem"
+    log(:notice, "Running default build command:")
+    log(:notice, "    $ rake native:#{options[:toolchain_info].platform} gem")
+    "bash -c '(#{with_bundle}) || (#{without_bundle})'"
+  else
+    input_args.empty? ? "bash" : "bash -c '#{input_args.join(" ")}'"
+  end
+end
+
+def uid_gid
+  if /darwin/.match?(RbConfig::CONFIG["host_os"])
+    ["1000", "1000"]
+  else
+    [Process.uid, Process.gid]
+  end
+end
+
+def user_mapping
+  uid, gid = uid_gid
+  "-e UID=#{uid} -e GID=#{gid} -e GROUP=_staff -e USER=rb-sys-dock"
+end
+
+def interactive?(input_args)
+  $stdin.tty?
+end
+
+def mount_tmp_dir(options)
+  "--mount type=bind,source=#{Dir.mktmpdir},destination=#{Dir.pwd}/tmp/#{options.fetch(:toolchain_info).platform},readonly=false"
+end
+
 def rcd(input_args, options)
   wrapper_command = []
-  wrapper_command << "sigfw" unless $stdin.tty?
+  wrapper_command << "sigfw" unless interactive?(input_args)
   wrapper_command << "runas"
 
-  extra_env = []
-
   docker_options = []
-  docker_options << "--tty" if $stdin.tty?
-  cmd = input_args.empty? ? "bash" : "bash -c '#{input_args.join(" ")}'"
+  docker_options << "--tty" if interactive?(input_args)
 
   cmd = <<~SH
     #{default_docker_command} run \
       -v #{Dir.pwd}:#{Dir.pwd} \
-      #{mount_target_dir(options, extra_env)} \
+      #{mount_tmp_dir(options)} \
+      #{mount_target_dir(options)} \
       #{mount_cargo_registry} \
-      #{mount_bundle_cache(options, extra_env)} \
+      #{mount_bundle_cache(options)} \
       #{mount_command_history(options)} \
-      -e UID=#{ENV.fetch("RB_SYS_DOCK_UID", "1000")} \
-      -e GID=#{ENV.fetch("RB_SYS_DOCK_GID", "1000")} \
-      -e USER=rb-sys-dock \
-      -e GROUP=_staff \
+      #{user_mapping} \
       -e GEM_PRIVATE_KEY_PASSPHRASE \
       -e ftp_proxy \
       -e http_proxy \
@@ -209,14 +270,19 @@ def rcd(input_args, options)
       -e RCD_HOST_RUBY_PLATFORM=#{RbConfig::CONFIG["arch"]} \
       -e RCD_HOST_RUBY_VERSION=#{RUBY_VERSION} \
       -e RCD_IMAGE \
+      -e RB_SYS_DOCK_TMPDIR="/tmp/rb-sys-dock" \
+      -e RB_SYS_CARGO_TARGET_DIR=#{tmp_target_dir(options).inspect} \
+      #{ENV["RUBY_CC_VERSION"] ? "-e RUBY_CC_VERSION=#{ENV["RUBY_CC_VERSION"]}" : ""} \
+      -e RAKEOPT \
       -e TERM \
+      -e LC_ALL=#{ENV.fetch("LC_ALL", "en_US.UTF-8")} \
       -w #{Dir.pwd} \
       --rm \
       --interactive \
       #{docker_options.join(" ")} \
       #{ENV.fetch("RCD_IMAGE")} \
       #{wrapper_command.join(" ")} \
-      #{cmd}
+      #{default_command_to_run(input_args, options)}
   SH
 
   log(:trace, "Running command: $ #{cmd}")
@@ -224,10 +290,10 @@ def rcd(input_args, options)
   exec(cmd)
 end
 
-def download_image(_options)
+def download_image(options)
   image = ENV.fetch("RCD_IMAGE")
 
-  if docker("images -q #{image}").strip.empty?
+  if docker("images -q #{image}").strip.empty? || options[:no_cache]
     # Nicely formatted message that we are downloading the image which might take awhile
     log(:notice, "Downloading container #{image.inspect}, this might take awhile...")
     docker("pull #{image} --quiet > /dev/null")

data/lib/rb_sys/cargo/metadata.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "open3"
+require "psych"
+
+module RbSys
+  module Cargo
+    # Extracts metadata from a Cargo project using `cargo metadata`.
+    class Metadata
+      attr_reader :name
+
+      def initialize(name)
+        raise ArgumentError, "name must be a String" unless name.is_a?(String)
+
+        @name = name
+      end
+
+      # @api private
+      def self.delegates_to_cargo_metadata(*methods)
+        methods.each do |method|
+          define_method(method) { cargo_metadata.fetch(method.to_s) }
+        end
+      end
+
+      # @api private
+      def self.delegates_to_package_metadata(*methods)
+        methods.each do |method|
+          define_method(method) { package_metadata.fetch(method.to_s) }
+        end
+      end
+
+      delegates_to_cargo_metadata :target_directory, :workspace_root, :packages
+
+      delegates_to_package_metadata :manifest_path, :version, :id, :edition, :targets, :features, :metadata
+
+      # Returns the path where the Cargo project's Cargo.toml is located.
+      #
+      # @return [String]
+      def manifest_directory
+        @manifest_directory ||= File.dirname(manifest_path)
+      end
+
+      private
+
+      def package_metadata
+        return @package_metadata if @package_metadata
+
+        found = cargo_metadata.fetch("packages").find { |p| p.fetch("name") == name }
+        raise PackageNotFoundError, @name unless found
+        @package_metadata = found
+      end
+
+      def cargo_metadata
+        return @cargo_metadata if @cargo_metadata
+
+        ::Gem.load_yaml
+        cargo = ENV["CARGO"] || "cargo"
+        args = ["metadata", "--no-deps", "--format-version", "1"]
+        out, stderr, _status = Open3.capture3(cargo, *args)
+        @cargo_metadata = Gem::SafeYAML.safe_load(out)
+      rescue => err
+        raise CargoMetadataError.new(err, stderr, manifest_path)
+      end
+    end
+  end
+end

data/lib/rb_sys/cargo.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RbSys
+  # Helpers for Cargo
+  module Cargo
+  end
+end
+
+require_relative "cargo/metadata"

data/lib/rb_sys/cargo_builder/link_flag_converter.rb

@@ -5,6 +5,7 @@ require "shellwords"
 module RbSys
   class CargoBuilder < Gem::Ext::Builder
     # Converts Ruby link flags into something cargo understands
+    # @api private
     class LinkFlagConverter
       FILTERED_PATTERNS = [
         /compress-debug-sections/, # Not supported by all linkers, and not required for Rust

data/lib/rb_sys/cargo_builder.rb

@@ -4,6 +4,7 @@ require_relative "cargo_builder/link_flag_converter"
 
 module RbSys
   # A class to build a Ruby gem Cargo. Extracted from `rubygems` gem, with some modifications.
+  # @api private
   class CargoBuilder < Gem::Ext::Builder
     attr_accessor :spec, :runner, :env, :features, :target, :extra_rustc_args, :dry_run, :ext_dir, :extra_rustflags,
       :extra_cargo_args
@@ -22,7 +23,7 @@ module RbSys
       @extra_rustc_args = []
       @extra_cargo_args = []
       @dry_run = true
-      @ext_dir = nil
+      @ext_dir = ""
       @extra_rustflags = []
     end
 
@@ -57,16 +58,16 @@ module RbSys
       build_env.merge(env)
     end
 
-    def cargo_command(dest_path, args = [])
-      manifest = File.join(ext_dir, "Cargo.toml")
-      cargo = ENV.fetch("CARGO", "cargo")
+    def manifest_dir
+      ext_dir
+    end
 
+    def cargo_command(dest_path, args = [])
       cmd = []
-      cmd += [cargo, "rustc"]
+      cmd += ["cargo", "rustc"]
       cmd += ["--target", target] if target
       cmd += ["--target-dir", dest_path]
       cmd += ["--features", features.join(",")] unless features.empty?
-      cmd += ["--manifest-path", manifest]
       cmd += ["--lib"]
       cmd += ["--profile", profile.to_s]
       cmd += Gem::Command.build_args
@@ -235,7 +236,7 @@ module RbSys
       !!Gem::WIN_PATTERNS.find { |r| target_platform =~ r }
     end
 
-    # Interpolate substition vars in the arg (i.e. $(DEFFILE))
+    # Interpolate substition vars in the arg
     def maybe_resolve_ldflag_variable(input_arg, dest_dir)
       var_matches = input_arg.match(/\$\((\w+)\)/)
 
@@ -246,31 +247,13 @@ module RbSys
       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)
+        # DEFFILE already generated by cargo
       else
         RbConfig::CONFIG[var_name]
       end
     end
 
-    def write_deffile(dest_path)
-      deffile_path = File.join(dest_path, "#{spec.name}-#{RbConfig::CONFIG["arch"]}.def")
-
-      unless dry_run
-        FileUtils.mkdir_p(dest_dir)
-        export_prefix = makefile_config("EXPORT_PREFIX") || ""
-
-        File.open(deffile_path, "w") do |f|
-          f.puts "EXPORTS"
-          f.puts "#{export_prefix.strip}Init_#{spec.name}"
-        end
-      end
-
-      deffile_path
-    end
-
     # Corresponds to $(LIBPATH) in mkmf
     def mkmf_libpath
       ["-L", "native=#{makefile_config("libdir")}"]

data/lib/rb_sys/error.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RbSys
+  # Error is the base class for all errors raised by rb_sys.
+  class Error < StandardError; end
+
+  # Raised when a package is not found from the Cargo metadata.
+  class PackageNotFoundError < Error
+    def initialize(name)
+      msg = <<~MSG.chomp.tr("\n", " ")
+        Could not find Cargo package metadata for #{@name.inspect}. Please
+        check that #{@name.inspect} matches the crate name in your
+        Cargo.toml."
+      MSG
+
+      super(msg)
+    end
+  end
+
+  # Raised when Cargo metadata cannot be parsed.
+  class CargoMetadataError < Error
+    def initialize(err, stderr, manifest_path)
+      msg = <<~MSG.chomp.tr("\n", " ")
+        Could not parse Cargo metadata. Please check that your Cargo.toml
+        is valid. The error was: #{err}
+
+        Looking for this Cargo.toml: #{manifest_path.inspect}
+
+        Stderr
+        ------
+        #{stderr}
+      MSG
+
+      super(msg)
+    end
+  end
+end

data/lib/rb_sys/extensiontask.rb

@@ -0,0 +1,122 @@
+require_relative "cargo/metadata"
+require_relative "error"
+
+begin
+  require "rake/extensiontask"
+rescue LoadError
+  abort "Please install rake-compiler to use this gem"
+end
+
+module RbSys
+  # ExtensionTask is a Rake::ExtensionTask subclass that is used to tailored for
+  # Rust extensions. It has the same options a `Rake::ExtensionTask`.
+  #
+  # @see https://www.rubydoc.info/gems/rake-compiler/Rake/ExtensionTask
+  #
+  # @example
+  #   RbSys::ExtensionTask.new("my-crate", my_gemspec) do |ext|
+  #     ext.lib_dir = "lib/my-crate"
+  #   end
+  #
+  # @param name [String] the crate name to build
+  # @param gem_spec [Gem::Specification] the gem specification to build (needed for cross-compiling)
+  # @return [Rake::ExtensionTask]
+  class ExtensionTask < Rake::ExtensionTask
+    def init(name = nil, gem_spec = nil)
+      super
+      @orginal_ext_dir = @ext_dir
+      @ext_dir = cargo_metadata.manifest_directory
+      @source_pattern = nil
+      @compiled_pattern = "*.{obj,so,bundle,dSYM}"
+      @cross_compile = ENV.key?("RUBY_TARGET")
+      @cross_platform = [ENV["RUBY_TARGET"]].compact
+      @cross_compiling_blocks = []
+      @cross_compiling_blocks << proc do |gemspec|
+        warn "Removing unneeded dependencies from native gemspec"
+        gemspec.dependencies.reject! { |d| d.name == "rb_sys" }
+      end
+      @cross_compiling_blocks << proc do |gemspec|
+        warn "Removing source files from native gemspec"
+        gemspec.files.reject! { |f| f.end_with?(".rs") }
+        gemspec.files.reject! { |f| f.match?(/Cargo.(toml|lock)$/) }
+        gemspec.files.reject! { |f| extconf.end_with?(f) }
+      end
+    end
+
+    def define
+      super
+      define_env_tasks
+    end
+
+    def cargo_metadata
+      @cargo_metadata ||= Cargo::Metadata.new(@name)
+    end
+
+    def extconf
+      File.join(cargo_metadata.manifest_directory, "extconf.rb")
+    end
+
+    def binary(_platf)
+      super.tr("-", "_")
+    end
+
+    # I'm not sure why this is necessary, can it be removed?
+    def source_files
+      list = FileList[
+        "#{ext_dir}/**/*.{rs,rb,c,h,toml}",
+        "**/Cargo.{toml,lock}",
+        "**/.cargo/**/*",
+        "#{ext_dir}/lib/**/*"
+      ]
+      list.include("#{ext_dir}/#{@source_pattern}") if @source_pattern
+      list.exclude(File.join(target_directory, "**/*"))
+      list
+    end
+
+    def cross_compiling(&block)
+      @cross_compiling_blocks << block if block
+    end
+
+    def target_directory
+      cargo_metadata.target_directory
+    end
+
+    def define_native_tasks(for_platform = nil, ruby_ver = RUBY_VERSION, callback = nil)
+      cb = proc do |gemspec|
+        callback&.call(gemspec)
+
+        @cross_compiling_blocks.each do |block|
+          block.call(gemspec)
+        end
+      end
+
+      super(for_platform, ruby_ver, cb)
+    end
+
+    def define_env_tasks
+      task "rb_sys:env:default" do
+        ENV["RB_SYS_CARGO_TARGET_DIR"] ||= target_directory
+        ENV["RB_SYS_CARGO_MANIFEST_DIR"] ||= cargo_metadata.manifest_directory
+        ENV["RB_SYS_CARGO_PROFILE"] ||= "release"
+      end
+
+      desc "Use the debug profile for building native Rust extensions"
+      task "rb_sys:env:dev" do
+        ENV["RB_SYS_CARGO_PROFILE"] = "dev"
+      end
+
+      desc "Use the release profile for building native Rust extensions"
+      task "rb_sys:env:release" do
+        ENV["RB_SYS_CARGO_PROFILE"] = "release"
+      end
+
+      file extconf => "rb_sys:env:default"
+
+      desc 'Compile the native Rust extension with the "dev" profile'
+      task "compile:dev" => ["rb_sys:env:dev", "compile"]
+
+      desc 'Compile the native Rust extension with the "release" profile'
+      task "compile:release" => ["rb_sys:env:release", "compile"]
+    end
+  end
+end

data/lib/rb_sys/mkmf/config.rb

@@ -4,7 +4,20 @@ module RbSys
   module Mkmf
     # Config that delegates to CargoBuilder if needded
     class Config
-      attr_accessor :force_install_rust_toolchain, :clean_after_install, :target_dir, :auto_install_rust_toolchain, :rubygems_clean_dirs
+      # Force the installation of the Rust toolchain when building
+      attr_accessor :force_install_rust_toolchain
+
+      # Clean artifacts after install (default: true if invoked by Rubygems)
+      attr_accessor :clean_after_install
+
+      # Target directory for cargo artifacts
+      attr_accessor :target_dir
+
+      # Automatically install the Rust toolchain when building (default: true)
+      attr_accessor :auto_install_rust_toolchain
+
+      # Directories to clean after installing with Rubygems
+      attr_accessor :rubygems_clean_dirs
 
       def initialize(builder)
         @builder = builder
@@ -14,14 +27,17 @@ module RbSys
         @rubygems_clean_dirs = ["./cargo-vendor"]
       end
 
+      # @api private
       def cross_compiling?
         RbConfig::CONFIG["CROSS_COMPILING"] == "yes"
       end
 
+      # @api private
       def method_missing(name, *args, &blk)
         @builder.send(name, *args, &blk)
       end
 
+      # @api private
       def respond_to_missing?(name, include_private = false)
         @builder.respond_to?(name) || super
       end
@@ -29,6 +45,7 @@ module RbSys
       # Seems to be the only way to reliably know if we were invoked by Rubygems.
       # We want to know this so we can cleanup the target directory after an
       # install, to remove bloat.
+      # @api private
       def rubygems_invoked?
         ENV.key?("SOURCE_DATE_EPOCH")
       end

data/lib/rb_sys/mkmf.rb

@@ -10,6 +10,7 @@ require_relative "mkmf/config"
 module RbSys
   # Helper class for creating Rust Makefiles
   module Mkmf
+    # @api private
     GLOBAL_RUSTFLAGS = ["--cfg=rb_sys_gem"]
 
     # Helper for building Rust extensions by creating a Ruby compatible makefile
@@ -48,7 +49,7 @@ module RbSys
 
       yield builder if blk
 
-      srcprefix = "$(srcdir)/#{builder.ext_dir}".chomp("/")
+      srcprefix = File.join("$(srcdir)", builder.ext_dir.gsub(/\A\.\/?/, "")).chomp("/")
       RbConfig.expand(srcdir = srcprefix.dup)
 
       full_cargo_command = cargo_command(srcdir, builder)
@@ -69,6 +70,7 @@ module RbSys
         #{conditional_assign("RB_SYS_GLOBAL_RUSTFLAGS", GLOBAL_RUSTFLAGS.join(" "))}
         #{conditional_assign("RB_SYS_EXTRA_RUSTFLAGS", builder.extra_rustflags.join(" "))}
         #{conditional_assign("RB_SYS_EXTRA_CARGO_ARGS", builder.extra_cargo_args.join(" "))}
+        #{conditional_assign("RB_SYS_CARGO_MANIFEST_DIR", builder.manifest_dir)}
 
         # Set dirname for the profile, since the profiles do not directly map to target dir (i.e. dev -> debug)
         #{if_eq_stmt("$(RB_SYS_CARGO_PROFILE)", "dev")}
@@ -100,10 +102,10 @@ module RbSys
         DLLIB = $(TARGET).#{RbConfig::CONFIG["DLEXT"]}
         RUSTLIBDIR = $(RB_SYS_FULL_TARGET_DIR)/$(RB_SYS_CARGO_PROFILE_DIR)
         RUSTLIB = $(RUSTLIBDIR)/$(SOEXT_PREFIX)$(TARGET_NAME).$(SOEXT)
+        TIMESTAMP_DIR = .
 
         CLEANOBJS = $(RUSTLIBDIR) $(RB_SYS_BUILD_DIR)
-        DEFFILE = $(RB_SYS_CARGO_TARGET_DIR)/$(TARGET)-$(arch).def
-        CLEANLIBS = $(DLLIB) $(RUSTLIB) $(DEFFILE)
+        CLEANLIBS = $(DLLIB) $(RUSTLIB)
         RUBYGEMS_CLEAN_DIRS = $(CLEANOBJS) $(CLEANFILES) #{builder.rubygems_clean_dirs.join(" ")}
 
         #{base_makefile(srcdir)}
@@ -119,18 +121,20 @@ module RbSys
 
         FORCE: ;
 
-        #{deffile_definition}
-
         #{optional_rust_toolchain(builder)}
 
-        $(RUSTLIB): #{deffile_definition ? "$(DEFFILE) " : nil}FORCE
+        #{timestamp_file("sitearchdir")}:
+        \t$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+        \t$(Q) $(TOUCH) $@
+
+        $(RUSTLIB): FORCE
         \t$(ECHO) generating $(@) \\("$(RB_SYS_CARGO_PROFILE)"\\)
         \t#{full_cargo_command}
 
         $(DLLIB): $(RUSTLIB)
         \t$(Q) $(COPY) "$(RUSTLIB)" $@
 
-        install-so: $(DLLIB)
+        install-so: $(DLLIB) #{timestamp_file("sitearchdir")}
         \t$(ECHO) installing $(DLLIB) to $(RUBYARCHDIR)
         \t$(Q) $(MAKEDIRS) $(RUBYARCHDIR)
         \t$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
@@ -166,7 +170,7 @@ module RbSys
       cargo_cmd = builder.cargo_command(dest_path, args)
       cmd = Shellwords.join(cargo_cmd)
       cmd.gsub!("\\=", "=")
-      cmd.gsub!(/\Acargo rustc/, "$(CARGO) rustc $(RB_SYS_EXTRA_CARGO_ARGS)")
+      cmd.gsub!(/\Acargo rustc/, "$(CARGO) rustc $(RB_SYS_EXTRA_CARGO_ARGS) --manifest-path $(RB_SYS_CARGO_MANIFEST_DIR)/Cargo.toml")
       cmd.gsub!(/-v=\d/, "")
       cmd
     end
@@ -200,21 +204,6 @@ module RbSys
       cargo_command
     end
 
-    def deffile_definition
-      warn("EXPORT_PREFIX is not defined, please require \"mkmf\" before requiring \"rb_sys/mkmf\"") unless defined?(EXPORT_PREFIX)
-
-      return unless defined?(EXPORT_PREFIX) && EXPORT_PREFIX
-
-      @deffile_definition ||= <<~MAKE
-        $(DEFFILE):
-        \t$(ECHO) creating target directory \\($(RUSTLIBDIR)\\)
-        \t$(Q) $(MAKEDIRS) $(RUSTLIBDIR)
-        \t$(ECHO) generating $(@)
-        \t$(ECHO) EXPORTS > $@
-        \t$(ECHO) $(TARGET_ENTRY) >> $@
-      MAKE
-    end
-
     def rust_toolchain_env(builder)
       <<~MAKE
         #{conditional_assign("RB_SYS_RUSTUP_PROFILE", "minimal")}

data/lib/rb_sys/toolchain_info/data.rb

@@ -4,6 +4,7 @@
 
 module RbSys
   class ToolchainInfo
+    # @private
     DATA = {"arm-linux" => {"rust-target" => "arm-unknown-linux-gnueabihf", "rake-compiler-dock" => {"cc" => "arm-linux-gnueabihf-gcc"}, "docker-platform" => "linux/arm/v7", "supported" => true}, "aarch64-linux" => {"rust-target" => "aarch64-unknown-linux-gnu", "rake-compiler-dock" => {"cc" => "aarch64-linux-gnu-gcc"}, "docker-platform" => "linux/arm64/v8", "supported" => true}, "arm64-darwin" => {"rust-target" => "aarch64-apple-darwin", "rake-compiler-dock" => {"cc" => "aarch64-apple-darwin-clang"}, "docker-platform" => "linux/arm64/v8", "supported" => true}, "x64-mingw-ucrt" => {"rust-target" => "x86_64-pc-windows-gnu", "rake-compiler-dock" => {"cc" => "x86_64-windows-gnu-gcc"}, "docker-platform" => "linux/amd64", "supported" => true}, "x64-mingw32" => {"rust-target" => "x86_64-pc-windows-gnu", "rake-compiler-dock" => {"cc" => "x86_64-windows-gnu-gcc"}, "docker-platform" => "linux/amd64", "supported" => true}, "x86-linux" => {"rust-target" => "i686-unknown-linux-gnu", "rake-compiler-dock" => {"cc" => "i686-redhat-linux-gcc"}, "docker-platform" => "linux/i386", "supported" => false}, "x86-mingw32" => {"rust-target" => "i686-pc-windows-gnu", "rake-compiler-dock" => {"cc" => "i686-w64-mingw32-gcc"}, "docker-platform" => "linux/i386", "supported" => false}, "x86_64-darwin" => {"rust-target" => "x86_64-apple-darwin", "rake-compiler-dock" => {"cc" => "x86_64-apple-darwin-clang"}, "docker-platform" => "linux/amd64", "supported" => true}, "x86_64-linux" => {"rust-target" => "x86_64-unknown-linux-gnu", "rake-compiler-dock" => {"cc" => "x86_64-redhat-linux-gcc"}, "docker-platform" => "linux/amd64", "supported" => true}, "x86_64-linux-musl" => {"rust-target" => "x86_64-unknown-linux-musl", "rake-compiler-dock" => {"cc" => "x86_64-unknown-linux-musl-gcc"}, "docker-platform" => "linux/amd64", "supported" => true}}
   end
 end

data/lib/rb_sys/toolchain_info.rb

@@ -14,19 +14,31 @@ module RbSys
     attr_reader :platform, :gem_platform, :rust_target, :rake_compiler_dock_cc, :supported, :rake_compiler_dock_image, :docker_platform
 
     class << self
+      # Get all known toolchains.
+      #
+      # @return [Array<RbSys::ToolchainInfo>]
       def all
         @all ||= DATA.keys.map { |k| new(k) }
       end
 
+      # Get all supported toolchains.
+      #
+      # @return [Array<RbSys::ToolchainInfo>]
       def supported
         @supported ||= all.select(&:supported?)
       end
 
+      # Get the toolchain for the current platform.
+      #
+      # @return [RbSys::ToolchainInfo]
       def local
         @current ||= new(RbConfig::CONFIG["arch"])
       end
     end
 
+    # Create a new toolchain info object.
+    #
+    # @param platform [String] The platform to get information about.
     def initialize(platform)
       @platform = platform
       @gem_platform = Gem::Platform.new(platform)
@@ -38,14 +50,24 @@ module RbSys
       @docker_platform = data["docker-platform"]
     end
 
+    # Whether this toolchain is supported.
+    #
+    # @return [Boolean]
     def supported?
       @supported
     end
 
+    # String representation of the toolchain.
+    #
+    # @return [String]
     def to_s
       "#{gem_platform.cpu}-#{gem_platform.os}"
     end
 
+    # Compare two toolchains.
+    #
+    # @param other [RbSys::ToolchainInfo]
+    # @return [Boolean]
     def ==(other)
       @gem_platform == other.gem_platform
     end

data/lib/rb_sys/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RbSys
-  VERSION = "0.9.59"
+  VERSION = "0.9.61"
 end

data/lib/rb_sys.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "rb_sys/version"
+require_relative "rb_sys/error"
 require_relative "rb_sys/toolchain_info"
 
 module RbSys
-  class Error < StandardError; end
-  # Your code goes here...
 end

data.tar.gz.sig

@@ -1,2 +1 @@
-�f�1`�QQ׿2�B���c�x(�����Z�H��U�-|p+$ P|�}d4~�y(i?y�1R]�
-Jm�Rt�
��r
+�¸cdm����S)����Z��6�O��b�����j��R�41,Lڃ��}\AzJ��S�c�|�as����*u-��=S|�5�r�5~�З�BQpiH{��Z:�M4���B?@��#�q���@X���v���Ѯ�����K�hq���]p��=���yU��ӛ���ΟB[��x�>2z�h��7��Qw��SC1�-w�Y��\H

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rb_sys
 version: !ruby/object:Gem::Version
-  version: 0.9.59
+  version: 0.9.61
 platform: ruby
 authors:
 - Ian Ker-Seymer
@@ -30,7 +30,7 @@ cert_chain:
   Rl+ASkq2/1i07TkBpCf+2hq66+h/hx+/Y/KrUzXfe0jtvil0WESkJT2kqRqHWNhD
   9GKBxaQlXokNDtWCm1/gl6cD8WRZ0N5S4ZGJT1FLLsA=
   -----END CERTIFICATE-----
-date: 2023-02-01 00:00:00.000000000 Z
+date: 2023-02-06 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -45,8 +45,12 @@ files:
 - certs/ianks.pem
 - exe/rb-sys-dock
 - lib/rb_sys.rb
+- lib/rb_sys/cargo.rb
+- lib/rb_sys/cargo/metadata.rb
 - lib/rb_sys/cargo_builder.rb
 - lib/rb_sys/cargo_builder/link_flag_converter.rb
+- lib/rb_sys/error.rb
+- lib/rb_sys/extensiontask.rb
 - lib/rb_sys/mkmf.rb
 - lib/rb_sys/mkmf/config.rb
 - lib/rb_sys/toolchain_info.rb
@@ -74,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.2
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Helpers for compiling Rust extensions for ruby