rb_sys1 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5fa473b69ad2496084571b1f592c94a1b2c2928ff98211b94961b489ff1e5392
+  data.tar.gz: 519bf8fb1a5a6420d3c146e29885f6e583918653f9bee99f7b02a7beea4c4159
+SHA512:
+  metadata.gz: 67227d00cc8c812876b944a62604441946906a6913708133e5d449e2bedb181680c3b8cc6f6423c67f37d25a26eaf6ea0328042c7448e1b7685ef768dd7dec3e
+  data.tar.gz: bc7def6f80d2e0f5e888bf572701c171e76f4def3b7e428b9825f163c36a2888d4f7ec31e2c59ee78cf519b56b91a43aac1fb39a0127123e1995ed630bbc10d4

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rb_sys"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/certs/ianks.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDfDCCAmSgAwIBAgIBATANBgkqhkiG9w0BAQUFADBCMRQwEgYDVQQDDAtpLmtl
+cnNleW1lcjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYD
+Y29tMB4XDTIyMDQxMzE5NTY1MVoXDTIzMDQxMzE5NTY1MVowQjEUMBIGA1UEAwwL
+aS5rZXJzZXltZXIxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixk
+ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJ2pG+er4cP
+PasxsMIKL9/tmLL4gh80EMuF3SCS0qZoh+Oo8dkvRYxW8NXdwEIcp3cCNgE+5G+J
+TCMOVF8S15n1Z1P7xxXiXxa/BIofKKbtatVRngm14uR/6pjdkvLXqlrWdS57bNwv
+7LtpzYVfDHfsl/qRWaEi4jq00PNCRSWjcva8teqswjBg8KlwGtyygpezPbVSWP8Y
+vzWZmVF7fqRBXU78Ah0+pNOhslBXDTvI3xJdN4hQ3H7rLjpD/qxKWq/8o+Qvx6cX
+dNZ3ugH/Pr3BAsqt4JFLXin9AK7PO9GDMH5JXJrUb+hAt2VNIZqpz9VlKA6BA0jN
+eWGea+yCZkECAwEAAaN9MHswCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+BBYEFOkrF6hsocaIMOjR/K3JBzyXCLJPMCAGA1UdEQQZMBeBFWkua2Vyc2V5bWVy
+QGdtYWlsLmNvbTAgBgNVHRIEGTAXgRVpLmtlcnNleW1lckBnbWFpbC5jb20wDQYJ
+KoZIhvcNAQEFBQADggEBADHnvHbZn5nldcpArIQcFF9URCBloCBZHqLFMhlGj5BX
+bFvuoq4CBmEFiJpTazeoEaxPlsmIK1+4CqBXwg8lHEMC9RV5g9QtJHQry2eFE/8U
+WrgCbqdxb8HBl9ayOHRcdfcv0RHBlmBHwBOoQ+hXMlInjssjfIX4BS39mTYefclE
+zxOFntl+vb4kluo0j9/BGzdnGCo7iE+GfGSENFdOn2J38RCDLUzgOCmCtxzSvldq
+Rl+ASkq2/1i07TkBpCf+2hq66+h/hx+/Y/KrUzXfe0jtvil0WESkJT2kqRqHWNhD
+9GKBxaQlXokNDtWCm1/gl6cD8WRZ0N5S4ZGJT1FLLsA=
+-----END CERTIFICATE-----

data/lib/rb_sys/mkmf.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "rubygems/ext"
+require "shellwords"
+require_relative "./../../vendor/rubygems/ext/cargo_builder"
+
+# Root module
+module RbSys
+  # Helpers for creating a Ruby compatible makefile for Rust
+  module Mkmf
+    def create_rust_makefile(target, srcprefix = nil)
+      if target.include?("/")
+        target_prefix, target = File.split(target)
+        target_prefix[0, 0] = "/"
+      else
+        target_prefix = ""
+      end
+
+      spec = Struct.new(:name, :metadata).new(target, {})
+      builder = Gem::Ext::CargoBuilder.new(spec)
+      srcprefix ||= "$(srcdir)/#{srcprefix}".chomp("/")
+      RbConfig.expand(srcdir = srcprefix.dup)
+
+      # rubocop:disable Style/GlobalVars
+      make_install = <<~MAKE
+        target_prefix = #{target_prefix}
+        CARGO_PROFILE = release
+        CLEANLIBS = target/ $(RUSTLIB) $(DLLIB)
+        RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+        RUSTLIB = #{dllib_path(builder)}
+        TARGET = #{target}
+        DLLIB = $(TARGET).#{RbConfig::CONFIG["DLEXT"]}
+
+        #{base_makefile(srcdir)}
+
+        #{env_vars(builder)}
+
+        FORCE: ;
+
+        $(DLLIB): FORCE
+        \t#{cargo_command(srcdir, builder)}
+        \t$(COPY) "$(RUSTLIB)" $@
+
+        install: $(DLLIB)
+        \t$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+
+        all: #{$extout ? "install" : "$(DLLIB)"}
+      MAKE
+
+      File.write("Makefile", make_install)
+    end
+    # rubocop:enable Style/GlobalVars
+
+    private
+
+    def base_makefile(cargo_dir)
+      base_makefile = dummy_makefile(__dir__).join("\n")
+      base_makefile.gsub!("all install static install-so install-rb", "all static install-so install-rb")
+      base_makefile.gsub!("clean-so::", "clean-so:\n\t-$(Q)$(RM) $(DLLIB)\n")
+      base_makefile.gsub!(/^srcdir = .*$/, "srcdir = #{cargo_dir}")
+      base_makefile
+    end
+
+    def cargo_command(cargo_dir, builder)
+      dest_path = File.join(Dir.pwd, "target")
+      args = []
+      cargo_cmd = builder.cargo_command(cargo_dir, dest_path, args)
+      Shellwords.join(cargo_cmd).gsub("\\=", "=")
+    end
+
+    def env_vars(builder)
+      builder.build_env.map { |k, v| %($(DLLIB): export #{k} = #{v.gsub("\n", '\n')}) }.join("\n")
+    end
+
+    def dllib_path(builder)
+      builder.cargo_dylib_path(File.join(Dir.pwd, "target"))
+    end
+  end
+end
+
+include RbSys::Mkmf # rubocop:disable Style/MixinUsage

data/lib/rb_sys/version.rb

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

data/lib/rb_sys.rb

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

data/sig/rb_sys.rbs

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

data/vendor/rubygems/ext/cargo_builder/link_flag_converter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Gem::Ext::CargoBuilder < Gem::Ext::Builder
+  # Converts Ruby link flags into something cargo understands
+  class LinkFlagConverter
+    def self.convert(arg)
+      case arg.chomp
+      when /^-L\s*(.+)$/
+        ["-L", "native=#{$1}"]
+      when /^--library=(\w+\S+)$/, /^-l\s*(\w+\S+)$/
+        ["-l", $1]
+      when /^-l\s*:lib(\S+).a$/
+        ["-l", "static=#{$1}"]
+      when /^-l\s*:lib(\S+).(so|dylib|dll)$/
+        ["-l", "dylib=#{$1}"]
+      when /^-F\s*(.*)$/
+        ["-l", "framework=#{$1}"]
+      else
+        ["-C", "link_arg=#{arg}"]
+      end
+    end
+  end
+end

data/vendor/rubygems/ext/cargo_builder.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+# This class is used by rubygems to build Rust extensions. It is a thin-wrapper
+# over the `cargo rustc` command which takes care of building Rust code in a way
+# that Ruby can use.
+class Gem::Ext::CargoBuilder < Gem::Ext::Builder
+  attr_accessor :spec, :runner, :profile
+
+  def initialize(spec)
+    require "rubygems/command"
+    require_relative "cargo_builder/link_flag_converter"
+
+    @spec = spec
+    @runner = self.class.method(:run)
+    @profile = :release
+  end
+
+  def build(_extension, dest_path, results, args = [], lib_dir = nil, cargo_dir = Dir.pwd)
+    require "fileutils"
+    require "shellwords"
+
+    build_crate(dest_path, results, args, cargo_dir)
+    validate_cargo_build!(dest_path)
+    rename_cdylib_for_ruby_compatibility(dest_path)
+    finalize_directory(dest_path, lib_dir, cargo_dir)
+    results
+  end
+
+  def build_crate(dest_path, results, args, cargo_dir)
+    env = build_env
+    cmd = cargo_command(cargo_dir, dest_path, args)
+    runner.call cmd, results, "cargo", cargo_dir, env
+
+    results
+  end
+
+  def build_env
+    build_env = rb_config_env
+    build_env["RUBY_STATIC"] = "true" if ruby_static? && ENV.key?("RUBY_STATIC")
+    build_env
+  end
+
+  def cargo_command(cargo_dir, dest_path, args = [])
+    manifest = File.join(cargo_dir, "Cargo.toml")
+    cargo = ENV.fetch("CARGO", "cargo")
+
+    cmd = []
+    cmd += [cargo, "rustc"]
+    cmd += ["--target", ENV["CARGO_BUILD_TARGET"]] if ENV["CARGO_BUILD_TARGET"]
+    cmd += ["--target-dir", dest_path]
+    cmd += ["--manifest-path", manifest]
+    cmd += ["--lib"]
+    cmd += ["--profile", profile.to_s]
+    cmd += ["--locked"] if profile == :release
+    cmd += Gem::Command.build_args
+    cmd += args
+    cmd += ["--"]
+    cmd += [*cargo_rustc_args(dest_path)]
+    cmd
+  end
+
+  def cargo_dylib_path(dest_path)
+    prefix = so_ext == "dll" ? "" : "lib"
+    path_parts = [dest_path]
+    path_parts << ENV["CARGO_BUILD_TARGET"] if ENV["CARGO_BUILD_TARGET"]
+    path_parts += [profile_target_directory, "#{prefix}#{cargo_crate_name}.#{so_ext}"]
+    File.join(*path_parts)
+  end
+
+  private
+
+  def rb_config_env
+    result = {}
+    RbConfig::CONFIG.each { |k, v| result["RBCONFIG_#{k}"] = v }
+    result
+  end
+
+  def cargo_rustc_args(dest_dir)
+    [
+      *linker_args,
+      *mkmf_libpath,
+      *rustc_dynamic_linker_flags(dest_dir),
+      *rustc_lib_flags(dest_dir),
+      *platform_specific_rustc_args(dest_dir),
+      *debug_flags
+    ]
+  end
+
+  def platform_specific_rustc_args(dest_dir, flags = [])
+    if mingw_target?
+      # On mingw platforms, mkmf adds libruby to the linker flags
+      flags += libruby_args(dest_dir)
+
+      # Make sure ALSR is used on mingw
+      # see https://github.com/rust-lang/rust/pull/75406/files
+      flags += ["-C", "link-arg=-Wl,--dynamicbase"]
+      flags += ["-C", "link-arg=-Wl,--disable-auto-image-base"]
+
+      # If the gem is installed on a host with build tools installed, but is
+      # run on one that isn't the missing libraries will cause the extension
+      # to fail on start.
+      flags += ["-C", "link-arg=-static-libgcc"]
+    end
+
+    flags
+  end
+
+  # We want to use the same linker that Ruby uses, so that the linker flags from
+  # mkmf work properly.
+  def linker_args
+    # Have to handle CC="cl /nologo" on mswin
+    cc_flag = Shellwords.split(makefile_config("CC"))
+    linker = cc_flag.shift
+    link_args = cc_flag.flat_map { |a| ["-C", "link-arg=#{a}"] }
+
+    ["-C", "linker=#{linker}", *link_args]
+  end
+
+  def libruby_args(dest_dir)
+    libs = makefile_config(ruby_static? ? "LIBRUBYARG_STATIC" : "LIBRUBYARG_SHARED")
+    raw_libs = Shellwords.split(libs)
+    raw_libs.flat_map { |l| ldflag_to_link_modifier(l) }
+  end
+
+  def ruby_static?
+    return true if %w[1 true].include?(ENV["RUBY_STATIC"])
+
+    makefile_config("ENABLE_SHARED") == "no"
+  end
+
+  # Ruby expects the dylib to follow a file name convention for loading
+  def rename_cdylib_for_ruby_compatibility(dest_path)
+    new_path = final_extension_path(dest_path)
+    FileUtils.cp(cargo_dylib_path(dest_path), new_path)
+    new_path
+  end
+
+  def validate_cargo_build!(dir)
+    dylib_path = cargo_dylib_path(dir)
+
+    raise DylibNotFoundError, dir unless File.exist?(dylib_path)
+
+    dylib_path
+  end
+
+  def final_extension_path(dest_path)
+    dylib_path = cargo_dylib_path(dest_path)
+    dlext_name = "#{spec.name}.#{makefile_config("DLEXT")}"
+    dylib_path.gsub(File.basename(dylib_path), dlext_name)
+  end
+
+ def cargo_crate_name
+    spec.metadata.fetch("cargo_crate_name", spec.name).tr("-", "_")
+  end
+
+  def rustc_dynamic_linker_flags(dest_dir)
+    split_flags("DLDFLAGS")
+      .map { |arg| maybe_resolve_ldflag_variable(arg, dest_dir) }
+      .compact
+      .flat_map { |arg| ldflag_to_link_modifier(arg) }
+  end
+
+  def rustc_lib_flags(dest_dir)
+    split_flags("LIBS").flat_map { |arg| ldflag_to_link_modifier(arg) }
+  end
+
+  def split_flags(var)
+    Shellwords.split(RbConfig::CONFIG.fetch(var, ""))
+  end
+
+  def ldflag_to_link_modifier(arg)
+    LinkFlagConverter.convert(arg)
+  end
+
+  def msvc_target?
+    makefile_config("target_os").include?("msvc")
+  end
+
+  def darwin_target?
+    makefile_config("target_os").include?("darwin")
+  end
+
+  def mingw_target?
+    makefile_config("target_os").include?("mingw")
+  end
+
+  def win_target?
+    target_platform = RbConfig::CONFIG["target_os"]
+    !!Gem::WIN_PATTERNS.find { |r| target_platform =~ r }
+  end
+
+  # Interpolate substition vars in the arg (i.e. $(DEFFILE))
+  def maybe_resolve_ldflag_variable(input_arg, dest_dir)
+    var_matches = input_arg.match(/\$\((\w+)\)/)
+
+    return input_arg unless var_matches
+
+    var_name = var_matches[1]
+
+    return input_arg if var_name.nil? || var_name.chomp.empty?
+
+    case var_name
+    # On windows, it is assumed that mkmf has setup an exports file for the
+    # extension, so we have to to create one ourselves.
+    when "DEFFILE"
+      write_deffile(dest_dir)
+    else
+      RbConfig::CONFIG[var_name]
+    end
+  end
+
+  def write_deffile(dest_path)
+    dest_dir = File.dirname(final_extension_path(dest_path))
+    FileUtils.mkdir_p(dest_dir)
+    deffile_path = File.join(dest_dir, "#{spec.name}-#{RbConfig::CONFIG["arch"]}.def")
+    export_prefix = makefile_config("EXPORT_PREFIX") || ""
+
+    File.open(deffile_path, "w") do |f|
+      f.puts "EXPORTS"
+      f.puts "#{export_prefix.strip}Init_#{spec.name}"
+    end
+
+    deffile_path
+  end
+
+  # We have to basically reimplement RbConfig::CONFIG['SOEXT'] here to support
+  # Ruby < 2.5
+  #
+  # @see https://github.com/ruby/ruby/blob/c87c027f18c005460746a74c07cd80ee355b16e4/configure.ac#L3185
+  def so_ext
+    return RbConfig::CONFIG["SOEXT"] if RbConfig::CONFIG.key?("SOEXT")
+
+    if win_target?
+      "dll"
+    elsif darwin_target?
+      "dylib"
+    else
+      "so"
+    end
+  end
+
+  # Corresponds to $(LIBPATH) in mkmf
+  def mkmf_libpath
+    ["-L", "native=#{makefile_config("libdir")}"]
+  end
+
+  def makefile_config(var_name)
+    val = RbConfig::MAKEFILE_CONFIG[var_name]
+
+    return unless val
+
+    RbConfig.expand(val.dup)
+  end
+
+  # Good balance between binary size and debugability
+  def debug_flags
+    return [] if profile == :dev
+
+    ["-C", "debuginfo=1"]
+  end
+
+  # Copied from ExtConfBuilder
+  def finalize_directory(dest_path, lib_dir, extension_dir)
+    require "fileutils"
+    require "tempfile"
+
+    ext_path = final_extension_path(dest_path)
+
+    begin
+      tmp_dest = Dir.mktmpdir(".gem.", extension_dir)
+
+      # Some versions of `mktmpdir` return absolute paths, which will break make
+      # if the paths contain spaces. However, on Ruby 1.9.x on Windows, relative
+      # paths cause all C extension builds to fail.
+      #
+      # As such, we convert to a relative path unless we are using Ruby 1.9.x on
+      # Windows. This means that when using Ruby 1.9.x on Windows, paths with
+      # spaces do not work.
+      #
+      # Details: https://github.com/rubygems/rubygems/issues/977#issuecomment-171544940
+      tmp_dest_relative = get_relative_path(tmp_dest.clone, extension_dir)
+
+      if tmp_dest_relative
+        full_tmp_dest = File.join(extension_dir, tmp_dest_relative)
+
+        # TODO: remove in RubyGems 3
+        if Gem.install_extension_in_lib && lib_dir
+          FileUtils.mkdir_p lib_dir
+          FileUtils.cp_r ext_path, lib_dir, remove_destination: true
+        end
+
+        FileUtils::Entry_.new(full_tmp_dest).traverse do |ent|
+          destent = ent.class.new(dest_path, ent.rel)
+          destent.exist? || FileUtils.mv(ent.path, destent.path)
+        end
+      end
+    ensure
+      FileUtils.rm_rf tmp_dest if tmp_dest
+    end
+  end
+
+  def get_relative_path(path, base)
+    path[0..base.length - 1] = "." if path.start_with?(base)
+    path
+  end
+
+  def profile_target_directory
+    case profile
+    when :release then "release"
+    when :dev then "debug"
+    else raise "unknown target directory for profile: #{profile}"
+    end
+  end
+
+  # Error raised when no cdylib artifact was created
+  class DylibNotFoundError < StandardError
+    def initialize(dir)
+      files = Dir.glob(File.join(dir, "**", "*")).map { |f| "- #{f}" }.join "\n"
+
+      super <<~MSG
+        Dynamic library not found for Rust extension (in #{dir})
+
+        Make sure you set "crate-type" in Cargo.toml to "cdylib"
+
+        Found files:
+        #{files}
+      MSG
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: rb_sys1
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ian Ker-Seymer
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-04-21 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- i.kerseymer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/setup
+- certs/ianks.pem
+- lib/rb_sys.rb
+- lib/rb_sys/mkmf.rb
+- lib/rb_sys/version.rb
+- sig/rb_sys.rbs
+- vendor/rubygems/ext/cargo_builder.rb
+- vendor/rubygems/ext/cargo_builder/link_flag_converter.rb
+homepage: https://github.com/oxidize-rb/rb-sys
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.12
+signing_key:
+specification_version: 4
+summary: Helpers for compiling Rust extensions for ruby
+test_files: []