rb_sys 0.9.64 → 0.9.65

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da8a462e7210f1746cca7dd9935d243b179176318aa766474fc33dd2de71227c
-  data.tar.gz: 7cd4a0126f7240b2b58ee3338dceec912d1cd9de211adc55a6f4da320fa982cc
+  metadata.gz: 5dc9ecb59d4b2cc130afff772c740063ee2bdbf5bdf15fb866aa6dcbb501d396
+  data.tar.gz: b9c2c65ef48e0c5400ea857bb75ad9ec85ffac300a4290bc6f20ef00ca5e8163
 SHA512:
-  metadata.gz: be81aba075a717c61a156cfcfafba1b9e7b36a33a045a2f04372b1c8244dd4280c0ebcc113fdc5c468bf72e49b6aaa8eff8d20784706ac779bab80e64d09ae04
-  data.tar.gz: 3fa8cb0393b6cbbd53cba685b8616e5b747556ea583b8e943ec54b93a938b6b0f6610768c545e28076eb9806afb92108e1bdf6e0e2f9d78b6cdaf05666fa6bd9
+  metadata.gz: 3c4acd2a28480da0b8adb18a48a806354afae12d963b9394f6ce9bd41f89c703a27dbe9a6bc52136f897ad7e64ccba70c9bbfd4231a9b209964d130dc703d8ad
+  data.tar.gz: 849c5b3fd8209dfe41b6a5efc0dbd06d6760e849b32cd0182915f9e1d5e011885ba64d56ef7c8f8ed286094ba4efaaec2ad5ffa1134690579223ae826e81ba54

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

@@ -12,10 +12,13 @@ module RbSys
       # Initializes a new Cargo::Metadata instance.
       #
       # @param name [String] the name of the Cargo project
-      def initialize(name)
+      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
 
       # Returns the path where the Cargo project's Cargo.toml is located.
@@ -88,6 +91,13 @@ module RbSys
         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
 
       def package_metadata
@@ -103,7 +113,8 @@ module RbSys
 
         ::Gem.load_yaml
         cargo = ENV["CARGO"] || "cargo"
-        args = ["metadata", "--no-deps", "--format-version", "1"]
+        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)

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

@@ -246,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}

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.64"
+  VERSION = "0.9.65"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rb_sys
 version: !ruby/object:Gem::Version
-  version: 0.9.64
+  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-07 00:00:00.000000000 Z
+date: 2023-02-13 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -57,6 +57,7 @@ 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
 homepage: https://oxidize-rb.github.io/rb-sys/
 licenses:
@@ -79,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