rb_sys 0.9.60 → 0.9.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84546ca4af298b39d45c6c8b931d59671a1e04900a8e2b86a852c9921475442d
-  data.tar.gz: 6ea6cde3068e5fa49eed2c9fbedc676eb48bb6932922d986f6d691f5a25eb7a4
+  metadata.gz: bb45d1f47ed05580f9d5e9d1799b17c9f29dc503846a70b579db5817c65efb25
+  data.tar.gz: 758e642b26c85bd37cb1787131a223958cd93d7358c44ccc99a9dc889f089b29
 SHA512:
-  metadata.gz: a9f6f0bbe1a74b1bd994217d7d25c89abce2df9b10b44dad0b656d906b02edc3aec1b142c927a57e773ea9e6764cb90f59657700a232775515717c450f42bf7d
-  data.tar.gz: c17a3fda12f884ab3577c1b9ee16f1aada070fc2935421b36fa7888cbd521a6c0c5d20848642829fe337e1da88f298941d3ab0409587d778668e175115ec6019
+  metadata.gz: 728591453d68f544915dfaaf0fbf2d66a55f72879542853f8c7dab8a1313a23bd85c78cd7befa1ffc3dbecccbef5f565ae0a5998a0801cf0798d9a0315360fc5
+  data.tar.gz: d9c3344159a08fe66f227adb5bf65b1c2fe7307ded78536da7760ea0cdf6c4806e9e955a1edd70b2b6efb99202d40903390657cc2ebeadde8918533a189c0b90

data/exe/rb-sys-dock

@@ -115,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
@@ -171,19 +183,12 @@ def volume(src, dest, mode: "rw")
 end
 
 def mount_bundle_cache(options)
-  unless File.exist?(File.join(Dir.pwd, "Gemfile"))
-    log(:trace, "Ignoring bundler config")
-    return
-  end
-
   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}")
-  bundle_config = gen_bundle_config_file(bundle_path)
-  bundle_dir = File.dirname(bundle_config)
 
-  "#{volume(dir, bundle_path)} -v #{bundle_dir}:#{File.join(Dir.pwd, ".bundle")}"
+  "#{volume(dir, bundle_path)} -e BUNDLE_PATH=#{bundle_path.inspect}"
 end
 
 def tmp_target_dir(options)
@@ -210,13 +215,11 @@ 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"
+    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")
-    cargo_env = "export RB_SYS_CARGO_TARGET_DIR=#{tmp_target_dir(options)}"
-    "bash -c '#{cargo_env}; (#{with_bundle}) || (#{without_bundle})'"
+    "bash -c '(#{with_bundle}) || (#{without_bundle})'"
   else
     input_args.empty? ? "bash" : "bash -c '#{input_args.join(" ")}'"
   end
@@ -239,19 +242,6 @@ def interactive?(input_args)
   $stdin.tty?
 end
 
-def gen_bundle_config_file(path)
-  dir = Dir.mktmpdir("rb-sys-dock")
-  file = File.join(dir, "config")
-  File.write(file, <<~YAML)
-    ---
-    BUNDLE_JOBS: "4"
-    BUNDLE_RETRY: "4"
-    BUNDLE_PATH: #{path.inspect}
-  YAML
-
-  file
-end
-
 def mount_tmp_dir(options)
   "--mount type=bind,source=#{Dir.mktmpdir},destination=#{Dir.pwd}/tmp/#{options.fetch(:toolchain_info).platform},readonly=false"
 end
@@ -280,7 +270,12 @@ 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 \
@@ -306,7 +301,7 @@ def download_image(options)
 end
 
 def log_some_useful_info(_options)
-  if ARGV.empty?
+  if ARGV.empty? && !options[:build]
     log(:notice, "Entering shell in Docker container #{ENV["RCD_IMAGE"].inspect}")
   else
     log(:notice, "Running command #{ARGV.inspect} in Docker container #{ENV["RCD_IMAGE"].inspect}")

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,15 +58,16 @@ module RbSys
       build_env.merge(env)
     end
 
-    def cargo_command(dest_path, args = [])
-      manifest = File.join(ext_dir, "Cargo.toml")
+    def manifest_dir
+      ext_dir
+    end
 
+    def cargo_command(dest_path, args = [])
       cmd = []
       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
@@ -234,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+)\)/)
 
@@ -245,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.60"
+  VERSION = "0.9.62"
 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rb_sys
 version: !ruby/object:Gem::Version
-  version: 0.9.60
+  version: 0.9.62
 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-02 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