rb_sys 0.9.63 → 0.9.65

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52407f94f77dfbef05d18940ac493f58192b704c64bfa30a023498e2a78c42d6
-  data.tar.gz: 25d5c1894e187b3208933d3c7874923c44f77fb0fbdbc68e63800430dfba3378
+  metadata.gz: 5dc9ecb59d4b2cc130afff772c740063ee2bdbf5bdf15fb866aa6dcbb501d396
+  data.tar.gz: b9c2c65ef48e0c5400ea857bb75ad9ec85ffac300a4290bc6f20ef00ca5e8163
 SHA512:
-  metadata.gz: 4df8ead8517d700e6690fd52e74ccf67c7b8fcd74fbbacf4a7fb9dca6bffc2da8ef8f6803c55159011030f0cf3b703d8015d29ab71ea078ef3d9649f2653247e
-  data.tar.gz: c87238853cb91b0e9bbd5deb0b1eba7ce0463812da6a9aac7c3d6695ba9102c411b0c41724c5a6fcbad2c19885447d184b7836c93240ae4d43712caf16b8c2e6
+  metadata.gz: 3c4acd2a28480da0b8adb18a48a806354afae12d963b9394f6ce9bd41f89c703a27dbe9a6bc52136f897ad7e64ccba70c9bbfd4231a9b209964d130dc703d8ad
+  data.tar.gz: 849c5b3fd8209dfe41b6a5efc0dbd06d6760e849b32cd0182915f9e1d5e011885ba64d56ef7c8f8ed286094ba4efaaec2ad5ffa1134690579223ae826e81ba54

data/.yardopts

@@ -0,0 +1,3 @@
+--no-private
+--list-undoc
+'lib/**/*.rb'

data/README.md

@@ -0,0 +1,98 @@
+# The `rb_sys` gem
+
+![Gem](https://img.shields.io/gem/v/rb_sys)
+[![Documentation](https://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/rb_sys/frames)
+[![Join the discussion](https://img.shields.io/badge/slack-chat-blue.svg)](https://join.slack.com/t/oxidize-rb/shared_invite/zt-16zv5tqte-Vi7WfzxCesdo2TqF_RYBCw)
+
+The `rb_sys` gem is a Ruby gem makes it easy to build native Ruby extensions in Rust. It interops with the existing Ruby
+native extension toolchains (i.e. `rake-compiler`) to make testing, building, and cross compilation of gems easy.
+
+## `RbSys::ExtensionTask`
+
+This gem provides a `RbSys::ExtensionTask` class that can be used to build a Ruby extension in Rust. It's a thin wrapper
+around `Rake::ExtensionTask` that provides sane defaults for building Rust extensions.
+
+```ruby
+# Rakefile
+
+require "rb_sys/extensiontask"
+
+GEMSPEC = Gem::Specification.load("my_gem.gemspec")
+
+RbSys::ExtensionTask.new("my-crate-name", GEMSPEC) do |ext|
+  ext.lib_dir = "lib/my_gem"
+end
+```
+
+## `create_rust_makefile`
+
+This gem provides a simple helper to build a Ruby compatible Makefile for you Rust extension. For a full example, see
+the [examples](./../examples) directory.
+
+```ruby
+# ext/rust_reverse/extconf.rb
+
+# We need to require mkmf *first* this since `rake-compiler` injects code here for cross compilation
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("rust_reverse") do |r|
+  # Create debug builds in dev. Make sure that release gems are compiled with
+  # `RB_SYS_CARGO_PROFILE=release` (optional)
+  r.profile = ENV.fetch("RB_SYS_CARGO_PROFILE", :dev).to_sym
+
+  # Can be overridden with `RB_SYS_CARGO_FEATURES` env var (optional)
+  r.features = ["test-feature"]
+
+  # You can add whatever env vars you want to the env hash (optional)
+  r.env = {"FOO" => "BAR"}
+
+  # If your Cargo.toml is in a different directory, you can specify it here (optional)
+  r.ext_dir = "."
+
+  # Extra flags to pass to the $RUSTFLAGS environment variable (optional)
+  r.extra_rustflags = ["--cfg=some_nested_config_var_for_crate"]
+
+  # Force a rust toolchain to be installed via rustup (optional)
+  # You can also set the env var `RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN=true`
+  r.force_install_rust_toolchain = "stable"
+
+  # Clean up the target/ dir after `gem install` to reduce bloat (optional)
+  r.clean_after_install = false # default: true if invoked by rubygems
+
+  # Auto-install Rust toolchain if not present on "gem install" (optional)
+  r.auto_install_rust_toolchain = false # default: true if invoked by rubygems
+end
+```
+
+## Tips and Tricks
+
+- When using `rake-compiler` to build your gem, you can use the `RB_SYS_CARGO_PROFILE` environment variable to set the
+  Cargo profile (i.e. `release` or `dev`).
+
+- You can pass Cargo arguments to `rake-compiler` like so: `rake compile -- --verbose`
+
+- It's possible to force an installation of a Rust toolchain by setting the `RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN`
+  environment variable. This will install [rustup](https://rustup.rs/) and [cargo](https://crates.io/) in the build
+  directory, so the end user does not have to have Rust pre-installed. Ideally, this should be a last resort, as it's
+  better to already have the toolchain installed on your system.
+
+## Troubleshooting
+
+### Libclang issues
+
+If you see an error like this:
+
+```
+thread 'main' panicked at 'Unable to find libclang: "couldn't find any valid shared libraries matching: \['libclang.so', 'libclang-*.so', 'libclang.so.*', 'libclang-*.so.*'\], set the `LIBCLANG_PATH` environment variable to a path where one of these files can be found (invalid: \[\])"'
+```
+
+This means that bindgen is having issues finding a usable version of libclang. An easy way to fix this is to install the
+[`libclang` gem](https://github.com/oxidize-rb/libclang-rb), which will install a pre-built version of libclang for you.
+`rb_sys` will automatically detect this gem and use it.
+
+```ruby
+# Gemfile
+
+gem "libclang", "~> 14.0.6"
+```

data/exe/rb-sys-dock

@@ -1,82 +1,61 @@
 #!/usr/bin/env ruby
 
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
 require "optparse"
+require "open3"
 require "rb_sys/version"
 require "rb_sys/toolchain_info"
+require "rb_sys/cargo/metadata"
+require "rb_sys/util/logger"
 require "fileutils"
 require "tmpdir"
 
-options = {
-  version: RbSys::VERSION
+OPTIONS = {
+  docker_platform: "linux/amd64",
+  version: RbSys::VERSION,
+  directory: Dir.pwd
 }
 
-def log(level, message, emoji: true, io: $stderr)
-  emoji_opt, shellcode = case level
-  when :error
-    ["❌", "\e[1;31m"]
-  when :warn
-    ["⚠️", "\e[1;33m"]
-  when :info
-    ["ℹ️", "\e[1;37m"]
-  when :notice
-    ["🐳", "\e[1;34m"]
-  when :trace
-    return unless ENV["LOG_LEVEL"] == "trace"
-
-    ["🔍", "\e[1;2m"]
-  else raise "Unknown log level: #{level.inspect}"
-  end
-
-  emoji_opt = if emoji.is_a?(String)
-    emoji + " "
-  elsif emoji
-    emoji_opt + " "
-  end
+def cargo_metadata
+  @cargo_metadata ||= RbSys::Cargo::Metadata.new("rb-sys-dock", deps: true)
+end
 
-  # Escape the message for bash shell codes (e.g. \e[1;31m)
-  escaped = message.gsub("\\", "\\\\\\").gsub("\e", "\\e")
+def logger
+  return @logger if @logger
 
-  io.puts "#{shellcode}#{emoji_opt}#{escaped}\e[0m"
+  io = ARGV.include?("--quiet") ? File.open(File::NULL, "w") : $stderr
+  @logger ||= RbSys::Util::Logger.new(io: io)
 end
 
-def default_docker_command
-  return @default_docker_command if defined?(@default_docker_command)
+OptionParser.new do |opts|
+  opts.banner = <<~MSG
+    Usage: rb-sys-dock [OPTIONS] [COMMAND]
 
-  @default_docker_command = ENV.fetch("DOCKER", "docker")
-end
+    A CLI to facillitate building Ruby on Rust extensions using Docker.
 
-def run_command!(cmd)
-  log(:trace, "Running command: $ #{cmd}")
-  stdout, stderr, status = Open3.capture3(cmd)
+    Examples:
 
-  if status.success?
-    stdout
-  else
-    log(:error, "Error running command: $ #{cmd}")
-    warn(stderr)
-    exit(status.exitstatus)
-  end
-end
+        Build for Linux (x86_64)
+            $ rb-sys-dock --platform x86_64-linux --build
 
-def docker(cmd)
-  require "open3"
+        Build for macOS (Ruby 3.1 and 3.2)
+            $ rb-sys-dock -p arm64-darwin --ruby-versions 3.1,3.2 --build
 
-  run_command!("#{default_docker_command} #{cmd}")
-rescue Errno::ENOENT
-  log(:trace, "Could not find docker command, trying podman")
+        Enter a shell
+            $ rb-sys-dock --list-platforms
 
-  begin
-    stdout = run_command!("podman #{cmd}")
-    @default_docker_command = "podman"
-    stdout
-  rescue Errno::ENOENT
-    log(:error, "Could not find docker or podman command, please install one of them")
-    exit(1)
-  end
-end
+        Run a command in the container with a specific directory mounted
+            $ rb-sys-dock -p x64-mingw-ucrt -d /tmp/mygem -- "env | grep RUBY"
 
-OptionParser.new do |opts|
-  opts.banner = "Usage: rb-sys-dock --platform PLATFORM [COMMAND]"
+        List all supported platforms
+            $ rb-sys-dock --list-platforms
+
+    Options:
+  MSG
+
+  opts.on("--quiet", "Prints no logging output") do
+  end
 
   opts.on("-v", "--version", "Prints version") do
     require "rb_sys/version"
@@ -84,6 +63,10 @@ OptionParser.new do |opts|
     exit
   end
 
+  opts.on("--build", "Run the default command to cross-compile a gem") do
+    OPTIONS[:build] = true
+  end
+
   opts.on("-p", "--platform PLATFORM", "Platform to build for (i.e. x86_64-linux)") do |p|
     toolchain_info = begin
       RbSys::ToolchainInfo.new(p)
@@ -91,42 +74,40 @@ OptionParser.new do |opts|
       supported_list = RbSys::ToolchainInfo.all
       supported_list.select!(&:supported?)
       list = supported_list.map { |p| "- #{p} (#{p.rust_target})" }.join("\n")
-      log(:error, "Platform #{p} is not supported, please use one of:\n\n#{list}")
+      logger.error("Platform #{p} is not supported, please use one of:\n\n#{list}")
       exit(1)
     end
 
-    options[:platform] = p
-    options[:toolchain_info] = toolchain_info
-  end
-
-  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
-    log(:notice, "Supported platforms listed below:")
-
-    RbSys::ToolchainInfo.supported.each do |p|
-      log(:info, "- #{p} (#{p.rust_target})", emoji: false, io: $stdout)
-    end
-
-    exit(0)
+    OPTIONS[:platform] = p
+    OPTIONS[:toolchain_info] = toolchain_info
   end
 
-  opts.on("--ruby-versions LIST", "List all supported Ruby versions") do |arg|
-    log(:notice, "Requested Ruby versions: #{arg}")
-
+  opts.on("-r", "--ruby-versions LIST", "List all supported Ruby versions") do |arg|
     vers = arg.split(/[^0-9.]/).map do |v|
       parts = v.split(".")
       parts[2] = "0" if parts[2].nil?
       parts.join(".")
     end
 
+    OPTIONS[:ruby_versions] = vers
+
+    logger.info("Building for Ruby requested versions: #{vers}")
+
     ENV["RUBY_CC_VERSION"] = vers.join(":")
   end
 
+  opts.on("--tag TAG", "Use a specific version of the Docker image") do |tag|
+    logger.info("Using version #{tag} of the Docker image")
+    OPTIONS[:version] = tag
+    OPTIONS[:no_cache] = tag == "latest"
+  end
+
+  opts.on("--list-platforms", "--list", "List all supported platforms") do
+    logger.info("Supported platforms listed below:")
+    list_platforms
+    exit(0)
+  end
+
   opts.on("-h", "--help", "Prints this help") do
     puts opts
     exit
@@ -135,14 +116,60 @@ OptionParser.new do |opts|
   opts.on("-V", "--verbose", "Prints verbose output") do
     ENV["LOG_LEVEL"] = "trace"
     ENV["VERBOSE"] = "1"
-    options[:verbose] = true
+    logger.level = :trace
+    OPTIONS[:verbose] = true
   end
 
-  opts.on("--build", "Build the Docker image") do
-    options[:build] = true
+  opts.on("--mount-toolchains", "Mount local Rustup toolchain (instead of pre-installed from Docker container)") do
+    OPTIONS[:mount_rustup_toolchains] = true
+  end
+
+  opts.on("-d", "--directory DIR", "Directory to run the command in") do |val|
+    OPTIONS[:directory] = File.expand_path(val)
   end
 end.parse!
 
+def list_platforms
+  RbSys::ToolchainInfo.supported.each do |p|
+    old = logger.io
+    logger.io = $stdout
+    puts "- #{p.platform}"
+  ensure
+    logger.io = old
+  end
+end
+
+def default_docker_command
+  return @default_docker_command if defined?(@default_docker_command)
+
+  @default_docker_command = ENV.fetch("DOCKER") do
+    if !(docker = `which docker`).empty?
+      docker.strip
+    elsif !(podman = `which podman`).empty?
+      podman.strip
+    else
+      logger.fatal("Could not find docker or podman command, please install one of them")
+    end
+  end
+end
+
+def run_command!(*cmd)
+  logger.trace("Running command:\n\t$ #{cmd.join(" ")}")
+  stdout, stderr, status = Open3.capture3(*cmd)
+
+  if status.success?
+    stdout
+  else
+    logger.error("Error running command: $ #{cmd}")
+    warn(stderr)
+    exit(status.exitstatus)
+  end
+end
+
+def docker(cmd)
+  run_command!("#{default_docker_command} #{cmd}")
+end
+
 def determine_cache_dir
   return ENV["RB_SYS_DOCK_CACHE_DIR"] if ENV["RB_SYS_DOCK_CACHE_DIR"]
   return File.join(ENV["XDG_CACHE_HOME"], "rb-sys-dock") if ENV["XDG_CACHE_HOME"]
@@ -172,53 +199,93 @@ def mount_cargo_registry
   end
 
   dir = File.join("registry")
-  log(:trace, "Mounting cargo registry dir: #{dir}")
+  logger.trace("Mounting cargo registry dir: #{dir}")
   FileUtils.mkdir_p(dir)
 
-  "--mount type=bind,source=#{File.join(local_registry_dir, dir)},target=#{File.join("/usr/local/cargo", dir)},readonly=false"
+  mount_shared_bind_dir(File.join(local_registry_dir, dir), File.join("/usr/local/cargo", dir))
+end
+
+def mount_rustup_toolchains
+  return unless OPTIONS[:mount_rustup_toolchains]
+
+  local_rustup_dir = if OPTIONS[:mount_rustup_toolchains].is_a?(String)
+    OPTIONS[:mount_rustup_toolchains]
+  elsif ENV["RUSTUP_HOME"]
+    ENV["RUSTUP_HOME"]
+  elsif File.exist?(rustup_home = File.join(ENV["HOME"], ".rustup"))
+    rustup_home
+  else
+    logger.fatal("Could not find Rustup home directory, please set RUSTUP_HOME")
+  end
+
+  logger.info("Mounting rustup toolchains from #{local_rustup_dir}")
+
+  target_triple = OPTIONS[:toolchain_info].rust_target
+  dkr_triple = "x86_64-unknown-linux-gnu"
+  dkr_toolchain = "stable-#{dkr_triple}"
+  dkr_toolchain_dir = "/usr/local/rustup/toolchains/#{dkr_toolchain}"
+  installed_toolchains = Dir.glob(File.join(local_rustup_dir, "toolchains", "*")).map { |f| File.basename(f) }
+  has_host_toolchain = installed_toolchains.any? { |t| t.end_with?(dkr_toolchain) }
+
+  if !has_host_toolchain
+    logger.info("Installing default toolchain for docker image (#{dkr_toolchain})")
+    run_command!("rustup", "toolchain", "add", dkr_toolchain, "--force-non-host")
+  end
+
+  has_target = run_command!("rustup target list --installed --toolchain #{dkr_toolchain}").include?(target_triple)
+
+  if !has_target
+    logger.info("Installing target for docker image (#{target_triple})")
+    run_command!("rustup", "target", "add", target_triple, "--toolchain", dkr_toolchain)
+  end
+
+  volume("#{local_rustup_dir}/toolchains/#{dkr_toolchain}", dkr_toolchain_dir, mode: "z,ro")
 end
 
 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")
+def mount_bundle_cache
+  dir = File.join(cache_dir, ruby_platform, "bundle")
   bundle_path = File.join(docker_tmp, "bundle")
   FileUtils.mkdir_p(dir)
-  log(:trace, "Mounting bundle cache: #{dir}")
+  logger.trace("Mounting bundle cache: #{dir}")
 
   "#{volume(dir, bundle_path)} -e BUNDLE_PATH=#{bundle_path.inspect}"
 end
 
-def tmp_target_dir(options)
+def tmp_target_dir
   return @tmp_target_dir if defined?(@tmp_target_dir)
 
-  dir = File.join(Dir.pwd, "tmp", "rb-sys-dock", options.fetch(:toolchain_info).platform, "target")
+  dir = File.join(working_directory, "tmp", "rb-sys-dock", ruby_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")}"
+def working_directory
+  OPTIONS.fetch(:directory)
 end
 
-def mount_command_history(options)
+def mount_target_dir
+  "-v #{tmp_target_dir}:#{File.join(working_directory, "target")}"
+end
+
+def mount_command_history
   return unless $stdin.tty?
 
-  history_dir = File.join(cache_dir, options.fetch(:platform), "commandhistory")
+  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)
+def default_command_to_run(input_args)
   input_cmd = input_args.empty? ? "true" : input_args.join(" ")
 
-  if options[:build]
+  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")
+    logger.info("Running default build command (rake native:#{ruby_platform} gem)")
     "bash -c '(#{with_bundle}) || (#{without_bundle})'"
   else
     input_args.empty? ? "bash" : "bash -c '#{input_args.join(" ")}'"
@@ -242,11 +309,27 @@ 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"
+def mount_shared_bind_dir(src, dest)
+  "--mount type=bind,source=#{src},destination=#{dest},readonly=false"
+end
+
+def mount_tmp_dir
+  "--mount type=bind,source=#{Dir.mktmpdir},destination=#{working_directory}/tmp/#{ruby_platform},readonly=false"
+end
+
+def toolchain_info
+  @toolchain_info ||= OPTIONS.fetch(:toolchain_info) do
+    logger.error("Could not determine ruby platform, please set ruby platform with --platform to one of:")
+    list_platforms
+    logger.fatal("Exiting...")
+  end
 end
 
-def rcd(input_args, options)
+def ruby_platform
+  @ruby_platform ||= toolchain_info.platform
+end
+
+def rcd(input_args)
   wrapper_command = []
   wrapper_command << "sigfw" unless interactive?(input_args)
   wrapper_command << "runas"
@@ -256,12 +339,14 @@ def rcd(input_args, options)
 
   cmd = <<~SH
     #{default_docker_command} run \
-      -v #{Dir.pwd}:#{Dir.pwd} \
-      #{mount_tmp_dir(options)} \
-      #{mount_target_dir(options)} \
+      --platform #{OPTIONS.fetch(:docker_platform)} \
+      -v #{working_directory}:#{working_directory} \
+      #{mount_tmp_dir} \
+      #{mount_target_dir} \
       #{mount_cargo_registry} \
-      #{mount_bundle_cache(options)} \
-      #{mount_command_history(options)} \
+      #{mount_rustup_toolchains} \
+      #{mount_bundle_cache} \
+      #{mount_command_history} \
       #{user_mapping} \
       -e GEM_PRIVATE_KEY_PASSPHRASE \
       -e ftp_proxy \
@@ -269,52 +354,64 @@ def rcd(input_args, options)
       -e https_proxy \
       -e RCD_HOST_RUBY_PLATFORM=#{RbConfig::CONFIG["arch"]} \
       -e RCD_HOST_RUBY_VERSION=#{RUBY_VERSION} \
+      -e RUSTUP_PERMIT_COPY_RENAME=true \
       -e RCD_IMAGE \
       -e RB_SYS_DOCK_TMPDIR="/tmp/rb-sys-dock" \
-      -e RB_SYS_CARGO_TARGET_DIR=#{tmp_target_dir(options).inspect} \
+      -e RB_SYS_CARGO_TARGET_DIR=#{tmp_target_dir.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} \
+      -w #{working_directory} \
       --rm \
       --interactive \
       #{docker_options.join(" ")} \
       #{ENV.fetch("RCD_IMAGE")} \
       #{wrapper_command.join(" ")} \
-      #{default_command_to_run(input_args, options)}
+      #{default_command_to_run(input_args)}
   SH
 
-  log(:trace, "Running command: $ #{cmd}")
+  cmd.gsub!(/\s+/, " ")
+
+  logger.trace("Running command:\n\t$ #{cmd}")
 
   exec(cmd)
 end
 
-def download_image(options)
+def download_image
   image = ENV.fetch("RCD_IMAGE")
 
-  if docker("images -q #{image}").strip.empty? || options[:no_cache]
+  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")
+    logger.info("Downloading container #{image.inspect}, this might take awhile...")
+    docker("pull #{image} --platform #{OPTIONS[:docker_platform]} --quiet > /dev/null")
   end
 end
 
-def log_some_useful_info(options)
-  return if options[:build]
+def log_some_useful_info
+  return if OPTIONS[:build]
 
   if ARGV.empty?
-    log(:notice, "Entering shell in Docker container #{ENV["RCD_IMAGE"].inspect}")
+    logger.info("Entering shell in Docker container #{ENV["RCD_IMAGE"].inspect}")
   else
-    log(:notice, "Running command #{ARGV.inspect} in Docker container #{ENV["RCD_IMAGE"].inspect}")
+    logger.info("Running command #{ARGV.inspect} in Docker container #{ENV["RCD_IMAGE"].inspect}")
   end
 end
 
-def set_env(options)
-  ENV["RCD_IMAGE"] ||= "rbsys/#{options[:toolchain_info].platform}:#{options[:version]}"
+def set_env
+  ENV["RCD_IMAGE"] ||= "rbsys/#{ruby_platform}:#{OPTIONS[:version]}"
+end
+
+def lint_rb_sys
+  cargo_version = cargo_metadata.rb_sys_version
+  return if cargo_version == RbSys::VERSION
+  logger.warn("Cargo rb-sys version (#{cargo_version}) does not match Ruby gem version (#{RbSys::VERSION})")
+rescue => e
+  logger.warn("Could not determine Cargo rb-sys version")
+  logger.trace("Error was: #{e.inspect}")
 end
 
-set_env(options)
-download_image(options)
-log_some_useful_info(options)
-rcd(ARGV, options)
+set_env
+lint_rb_sys
+download_image
+log_some_useful_info
+rcd(ARGV)

data/lib/rb_sys/cargo/metadata.rb

@@ -9,35 +9,93 @@ module RbSys
     class Metadata
       attr_reader :name
 
-      def initialize(name)
+      # Initializes a new Cargo::Metadata instance.
+      #
+      # @param name [String] the name of the Cargo project
+      def initialize(name, deps: false)
         raise ArgumentError, "name must be a String" unless name.is_a?(String)
 
         @name = name
+        @cargo_metadata = nil
+        @package_metadata = nil
+        @deps = deps
       end
 
-      # @api private
-      def self.delegates_to_cargo_metadata(*methods)
-        methods.each do |method|
-          define_method(method) { cargo_metadata.fetch(method.to_s) }
-        end
+      # Returns the path where the Cargo project's Cargo.toml is located.
+      #
+      # @return [String]
+      def manifest_directory
+        @manifest_directory ||= File.dirname(manifest_path)
       end
 
-      # @api private
-      def self.delegates_to_package_metadata(*methods)
-        methods.each do |method|
-          define_method(method) { package_metadata.fetch(method.to_s) }
-        end
+      # Returns the target directory for the Cargo project.
+      #
+      # @return [String]
+      def target_directory
+        cargo_metadata.fetch("target_directory")
       end
 
-      delegates_to_cargo_metadata :target_directory, :workspace_root, :packages
+      # Returns the workspace root for the Cargo project.
+      #
+      # @return [String]
+      def workspace_root
+        cargo_metadata.fetch("workspace_root")
+      end
 
-      delegates_to_package_metadata :manifest_path, :version, :id, :edition, :targets, :features, :metadata
+      # Returns the workspace members for the Cargo project.
+      #
+      # @return [Array<Hash>]
+      def packages
+        cargo_metadata.fetch("packages")
+      end
 
-      # Returns the path where the Cargo project's Cargo.toml is located.
+      # Returns the path to the package's Cargo.toml.
       #
       # @return [String]
-      def manifest_directory
-        @manifest_directory ||= File.dirname(manifest_path)
+      def manifest_path
+        package_metadata.fetch("manifest_path")
+      end
+
+      # Returns the package's version.
+      #
+      # @return [String]
+      def version
+        package_metadata.fetch("version")
+      end
+
+      # Returns the package's id.
+      #
+      # @return [String]
+      def id
+        package_metadata.fetch("id")
+      end
+
+      # Returns the package's Rust edition.
+      #
+      # @return [String]
+      def edition
+        package_metadata.fetch("edition")
+      end
+
+      # Returns the package's features.
+      #
+      # @return [Array<String>]
+      def features
+        package_metadata.fetch("features")
+      end
+
+      # Returns the package's custom metadata.
+      #
+      # @return [Hash]
+      def metadata
+        package_metadata.fetch("metadata")
+      end
+
+      # Returns the rb-sys version, if any.
+      def rb_sys_version
+        pkg = packages.find { |p| p.fetch("name") == "rb-sys" }
+        return unless pkg
+        pkg["version"]
       end
 
       private
@@ -55,11 +113,15 @@ module RbSys
 
         ::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)
+        args = ["metadata", "--format-version", "1"]
+        args << "--no-deps" unless @deps
+        out, stderr, status = Open3.capture3(cargo, *args)
+        raise "exited with non-zero status (#{status})" unless status.success?
+        data = Gem::SafeYAML.safe_load(out)
+        raise "metadata must be a Hash" unless data.is_a?(Hash)
+        @cargo_metadata = data
       rescue => err
-        raise CargoMetadataError.new(err, stderr, manifest_path)
+        raise CargoMetadataError.new(err, stderr)
       end
     end
   end

data/lib/rb_sys/error.rb

@@ -19,18 +19,24 @@ module RbSys
 
   # Raised when Cargo metadata cannot be parsed.
   class CargoMetadataError < Error
-    def initialize(err, stderr, manifest_path)
+    def initialize(err, stderr)
       msg = <<~MSG.chomp.tr("\n", " ")
-        Could not parse Cargo metadata. Please check that your Cargo.toml
-        is valid. The error was: #{err}
+        Could not infer Rust crate information using `cargo metadata`.
 
-        Looking for this Cargo.toml: #{manifest_path.inspect}
+        Original error was:
+          #{err.class}: #{err.message}
 
-        Stderr
-        ------
-        #{stderr}
+        Things to check:
+          - Check that your ext/*/Cargo.toml at is valid
+          - If you are using a workspace, make sure you are the root Cargo.toml exists
+          - Make sure `cargo` is installed and in your PATH
       MSG
 
+      if !stderr.empty?
+        indented_stderr = stderr.lines.map { |line| "  #{line}" }.join
+        msg << "Stderr from `cargo metadata` was:\n#{indented_stderr}"
+      end
+
       super(msg)
     end
   end

data/lib/rb_sys/extensiontask.rb

@@ -4,7 +4,7 @@ require_relative "error"
 begin
   require "rake/extensiontask"
 rescue LoadError
-  abort "Please install rake-compiler to use this gem"
+  abort "Please install rake-compiler to use this feature"
 end
 
 module RbSys
@@ -22,8 +22,9 @@ module RbSys
   # @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
+    def init(name = nil, gem_spec = :undefined)
+      super(name, lint_gem_spec(name, gem_spec))
+
       @orginal_ext_dir = @ext_dir
       @ext_dir = cargo_metadata.manifest_directory
       @source_pattern = nil
@@ -46,6 +47,8 @@ module RbSys
     def define
       super
       define_env_tasks
+
+      CLEAN.include(target_directory) if defined?(CLEAN)
     end
 
     def cargo_metadata
@@ -118,5 +121,34 @@ module RbSys
       desc 'Compile the native Rust extension with the "release" profile'
       task "compile:release" => ["rb_sys:env:release", "compile"]
     end
+
+    private
+
+    def lint_gem_spec(name, gs)
+      gem_spec = case gs
+      when :undefined
+        return
+      when Gem::Specification
+        gs
+      when String
+        Gem::Specification.load(gem_spec) || raise(ArgumentError, "Unable to load gemspec from file #{gs.inspect}")
+      else
+        raise ArgumentError, "gem_spec must be a Gem::Specification, got #{gs.class}"
+      end
+
+      gem_spec.files.each do |f|
+        if /\.(dll|so|dylib|lib|bundle)$/.match?(f)
+          warn "⚠️ gemspec includes native artifact (#{f}), please remove it."
+        end
+      end
+
+      if (gem_crate_name = gem_spec.metadata["cargo_crate_name"])
+        if name != gem_crate_name
+          warn "⚠️ cargo_crate_name (#{gem_crate_name}) does not match extension task crate name (#{name})"
+        end
+      end
+
+      gem_spec
+    end
   end
 end

data/lib/rb_sys/mkmf.rb

@@ -59,6 +59,7 @@ module RbSys
         #{conditional_assign("CARGO", "cargo")}
         #{conditional_assign("CARGO_BUILD_TARGET", builder.target)}
         #{conditional_assign("SOEXT", builder.so_ext)}
+        #{try_load_bundled_libclang(builder)}
 
         # Determine the prefix Cargo uses for the lib.
         #{if_neq_stmt("$(SOEXT)", "dll")}
@@ -245,7 +246,6 @@ module RbSys
         \t$(Q) curl --proto '=https' --tlsv1.2 --retry 10 --retry-connrefused -fsSL "https://sh.rustup.rs" | sh -s -- --no-modify-path --profile $(RB_SYS_RUSTUP_PROFILE) --default-toolchain none -y
         \t$(Q) rustup toolchain install $(RB_SYS_DEFAULT_TOOLCHAIN) --profile $(RB_SYS_RUSTUP_PROFILE)
         \t$(Q) rustup default $(RB_SYS_DEFAULT_TOOLCHAIN)
-        \t$(Q) rustup component add rustfmt
 
         $(RUSTLIB): $(CARGO)
         #{endif_stmt}
@@ -317,6 +317,26 @@ module RbSys
       end
     end
 
+    def try_load_bundled_libclang(_builder)
+      require "libclang"
+      assert_libclang_version_valid!
+      export_env("LIBCLANG_PATH", Libclang.libdir)
+    rescue LoadError
+      # If we can't load the bundled libclang, just continue
+    end
+
+    def assert_libclang_version_valid!
+      libclang_version = Libclang.version
+
+      if libclang_version < Gem::Version.new("5.0.0")
+        raise "libclang version 5.0.0 or greater is required (current #{libclang_version})"
+      end
+
+      if libclang_version >= Gem::Version.new("15.0.0")
+        raise "libclang version > 14.0.0 or greater is required (current #{libclang_version})"
+      end
+    end
+
     def set_cargo_profile(builder)
       return assign_stmt("RB_SYS_CARGO_PROFILE", "release") if builder.rubygems_invoked?
 

data/lib/rb_sys/util/logger.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RbSys
+  module Util
+    class Logger
+      attr_accessor :io, :level
+
+      def initialize(io: $stderr, level: :info)
+        @io = ENV["GITHUB_ACTIONS"] ? $stdout : io
+        @level = level
+      end
+
+      def error(message, **opts)
+        add(:error, message, **opts)
+      end
+
+      def warn(message, **opts)
+        add(:warn, message, **opts)
+      end
+
+      def info(message, **opts)
+        add(:info, message, **opts)
+      end
+
+      def notice(message, **opts)
+        add(:notice, message, **opts)
+      end
+
+      def trace(message, **opts)
+        return unless level == :trace
+
+        add(:trace, message, **opts)
+      end
+
+      def fatal(message, **opts)
+        error(message, **opts)
+        abort
+      end
+
+      private
+
+      LEVEL_STYLES = {
+        warn: ["⚠️", "\e[1;33m"],
+        error: ["❌", "\e[1;31m"],
+        notice: ["👋", "\e[1;37m"],
+        info: ["🐳", "\e[1;34m"],
+        trace: ["🔍", "\e[1;2m"]
+      }
+
+      if ENV["GITHUB_ACTIONS"]
+        def add(level, message, emoji: true)
+          emote, _ = LEVEL_STYLES.fetch(level.to_sym)
+          io.puts "::#{level}::#{emote} #{message}"
+        end
+      else
+        def add(level, message, emoji: true)
+          emoji_opt, shellcode = LEVEL_STYLES.fetch(level.to_sym)
+
+          emoji_opt = if emoji.is_a?(String)
+            emoji + " "
+          elsif emoji
+            emoji_opt + " "
+          end
+
+          # Escape the message for bash shell codes (e.g. \033[1;31m)
+          escaped = message.gsub("\\", "\\\\\\").gsub("\033", "\\033")
+
+          io.puts "#{shellcode}#{emoji_opt}#{escaped}\033[0m"
+        end
+      end
+    end
+  end
+end

data/lib/rb_sys/version.rb

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

data.tar.gz.sig

@@ -1 +1 @@
-[������~Ή���(e�تI:�(9D�F[��b�B}��ݓY�j��>�B]�G��ع�:��z�V����%L}/b)�K�"a�L3d>գ��UE7[�zߞ���2p�N&��v�(t��A��K�Z4Wmœc;�H�4X���1����g��{�e�c�g�y�E�|.K.��p9V!��[���C�xF�t�#�CeR���~����aKY���?��!r4��y[��5p/t��~��N �B0]+Y��\r���>pA�
+���2��N���C�$�#d&>?��yZZv�_Il�3�/z��d7��
Fo���{7B���J3Ql��
:w� � �pVh���:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rb_sys
 version: !ruby/object:Gem::Version
-  version: 0.9.63
+  version: 0.9.65
 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-06 00:00:00.000000000 Z
+date: 2023-02-13 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -40,8 +40,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - LICENSE-APACHE
 - LICENSE-MIT
+- README.md
 - certs/ianks.pem
 - exe/rb-sys-dock
 - lib/rb_sys.rb
@@ -55,9 +57,9 @@ files:
 - lib/rb_sys/mkmf/config.rb
 - lib/rb_sys/toolchain_info.rb
 - lib/rb_sys/toolchain_info/data.rb
+- lib/rb_sys/util/logger.rb
 - lib/rb_sys/version.rb
-- sig/rb_sys.rbs
-homepage: https://github.com/oxidize-rb/rb-sys
+homepage: https://oxidize-rb.github.io/rb-sys/
 licenses:
 - MIT
 - Apache-2.0
@@ -78,7 +80,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

data/sig/rb_sys.rbs

@@ -1,4 +0,0 @@
-module RbSys
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end