itsi-server 0.2.21 → 0.2.23

data/vendor/rb-sys-build/src/bindings.rs

@@ -0,0 +1,280 @@
+mod sanitizer;
+mod stable_api;
+
+use crate::cc::Build;
+use crate::utils::is_msvc;
+use crate::{debug_log, RbConfig};
+use quote::ToTokens;
+use stable_api::{categorize_bindings, opaqueify_bindings};
+use std::fs::File;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::{env, error::Error};
+use syn::{Expr, ExprLit, ItemConst, Lit};
+
+const WRAPPER_H_CONTENT: &str = include_str!("bindings/wrapper.h");
+
+/// Generate bindings for the Ruby using bindgen.
+pub fn generate(
+    rbconfig: &RbConfig,
+    static_ruby: bool,
+    cfg_out: &mut File,
+) -> Result<PathBuf, Box<dyn Error>> {
+    let out_dir = PathBuf::from(env::var("OUT_DIR")?);
+
+    let mut clang_args = vec![];
+    if let Some(ruby_include_dir) = rbconfig.get("rubyhdrdir") {
+        clang_args.push(format!("-I{}", ruby_include_dir));
+    }
+    if let Some(ruby_arch_include_dir) = rbconfig.get("rubyarchhdrdir") {
+        clang_args.push(format!("-I{}", ruby_arch_include_dir));
+    }
+
+    clang_args.extend(Build::default_cflags());
+    clang_args.extend(rbconfig.cflags.clone());
+    clang_args.extend(rbconfig.cppflags());
+
+    // On Windows x86_64, we need to handle AVX512 FP16 compatibility issues
+    // Clang 20+ includes types like __m512h that aren't compatible with bindgen
+    if cfg!(target_os = "windows") && cfg!(target_arch = "x86_64") {
+        // For MinGW toolchain, disable SSE/AVX only for bindgen
+        // This prevents intrinsics headers from loading but doesn't affect the final binary
+        if !is_msvc() {
+            clang_args.push("-mno-sse".to_string());
+            clang_args.push("-mno-avx".to_string());
+        }
+    }
+
+    debug_log!("INFO: using bindgen with clang args: {:?}", clang_args);
+
+    let mut wrapper_h = WRAPPER_H_CONTENT.to_string();
+
+    if !is_msvc() {
+        wrapper_h.push_str("#ifdef HAVE_RUBY_ATOMIC_H\n");
+        wrapper_h.push_str("#include \"ruby/atomic.h\"\n");
+        wrapper_h.push_str("#endif\n");
+    }
+
+    if rbconfig.have_ruby_header("ruby/io/buffer.h") {
+        clang_args.push("-DHAVE_RUBY_IO_BUFFER_H".to_string());
+    }
+
+    let bindings = default_bindgen(clang_args, rbconfig)
+        .allowlist_file(".*ruby.*")
+        .blocklist_item("ruby_abi_version")
+        .blocklist_function("rb_tr_abi_version")
+        .blocklist_function("^__.*")
+        .blocklist_item("RData")
+        .blocklist_function("rb_tr_rdata")
+        .blocklist_function("rb_tr_rtypeddata")
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()));
+
+    let bindings = if cfg!(feature = "bindgen-rbimpls") {
+        bindings
+    } else {
+        bindings
+            .blocklist_item("^rbimpl_.*")
+            .blocklist_item("^RBIMPL_.*")
+    };
+
+    let bindings = if cfg!(feature = "bindgen-deprecated-types") {
+        bindings
+    } else {
+        bindings.blocklist_item("^_bindgen_ty_9.*")
+    };
+
+    let bindings = opaqueify_bindings(rbconfig, bindings, &mut wrapper_h);
+
+    let mut tokens = {
+        write!(std::io::stderr(), "{}", wrapper_h)?;
+        let bindings = bindings.header_contents("wrapper.h", &wrapper_h);
+        let code_string = bindings.generate()?.to_string();
+        syn::parse_file(&code_string)?
+    };
+
+    let slug = rbconfig.ruby_version_slug();
+    let crate_version = env!("CARGO_PKG_VERSION");
+    let out_path = out_dir.join(format!("bindings-{}-{}.rs", crate_version, slug));
+
+    let code = {
+        sanitizer::ensure_backwards_compatible_encoding_pointers(&mut tokens);
+        clean_docs(rbconfig, &mut tokens);
+
+        if is_msvc() {
+            qualify_symbols_for_msvc(&mut tokens, static_ruby, rbconfig);
+        }
+
+        push_cargo_cfg_from_bindings(&tokens, cfg_out)?;
+        categorize_bindings(&mut tokens);
+        tokens.into_token_stream().to_string()
+    };
+
+    let mut out_file = File::create(&out_path)?;
+    std::io::Write::write_all(&mut out_file, code.as_bytes())?;
+    run_rustfmt(&out_path);
+
+    Ok(out_path)
+}
+
+fn run_rustfmt(path: &Path) {
+    let mut cmd = std::process::Command::new("rustfmt");
+    cmd.stderr(std::process::Stdio::inherit());
+    cmd.stdout(std::process::Stdio::inherit());
+
+    cmd.arg(path);
+
+    if let Err(e) = cmd.status() {
+        debug_log!("WARN: failed to run rustfmt: {}", e);
+    }
+}
+
+fn clean_docs(rbconfig: &RbConfig, syntax: &mut syn::File) {
+    if rbconfig.is_cross_compiling() {
+        return;
+    }
+
+    let ver = rbconfig.ruby_version_slug();
+
+    sanitizer::cleanup_docs(syntax, &ver).unwrap_or_else(|e| {
+        debug_log!("WARN: failed to clean up docs, skipping: {}", e);
+    })
+}
+
+fn default_bindgen(clang_args: Vec<String>, _rbconfig: &RbConfig) -> bindgen::Builder {
+    // Disable layout tests and Debug impl on Windows MinGW due to packed struct layout incompatibilities
+    let is_windows_mingw = cfg!(target_os = "windows") && !is_msvc();
+
+    let enable_layout_tests = !is_windows_mingw && cfg!(feature = "bindgen-layout-tests");
+    let impl_debug = !is_windows_mingw && cfg!(feature = "bindgen-impl-debug");
+
+    let mut bindings = bindgen::Builder::default()
+        .rustified_enum(".*")
+        .no_copy("rb_data_type_struct")
+        .derive_eq(true)
+        .derive_debug(true)
+        .clang_args(clang_args)
+        .layout_tests(enable_layout_tests)
+        .blocklist_item("^__darwin_pthread.*")
+        .blocklist_item("^_opaque_pthread.*")
+        .blocklist_item("^__pthread_.*")
+        .blocklist_item("^pthread_.*")
+        .blocklist_item("^rb_native.*")
+        .blocklist_type("INET_PORT_RESERVATION_INSTANCE")
+        .blocklist_type("PINET_PORT_RESERVATION_INSTANCE")
+        .opaque_type("^__sFILE$")
+        .merge_extern_blocks(true)
+        .generate_comments(true)
+        .size_t_is_usize(env::var("CARGO_FEATURE_BINDGEN_SIZE_T_IS_USIZE").is_ok())
+        .impl_debug(impl_debug)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()));
+
+    // Make __mingw_ldbl_type_t opaque on Windows MinGW to avoid conflicting packed/align representation
+    if cfg!(target_os = "windows") && !is_msvc() {
+        bindings = bindings.opaque_type("__mingw_ldbl_type_t");
+    }
+
+    if env::var("CARGO_FEATURE_BINDGEN_ENABLE_FUNCTION_ATTRIBUTE_DETECTION").is_ok() {
+        bindings.enable_function_attribute_detection()
+    } else {
+        bindings
+    }
+}
+
+// This is needed because bindgen doesn't support the `__declspec(dllimport)` on
+// global variables. Without it, symbols are not found.
+// See https://stackoverflow.com/a/66182704/2057700
+fn qualify_symbols_for_msvc(tokens: &mut syn::File, is_static: bool, rbconfig: &RbConfig) {
+    let kind = if is_static { "static" } else { "dylib" };
+
+    let name = if is_static {
+        rbconfig.libruby_static_name()
+    } else {
+        rbconfig.libruby_so_name()
+    };
+
+    sanitizer::add_link_ruby_directives(tokens, &name, kind).unwrap_or_else(|e| {
+        debug_log!("WARN: failed to add link directives: {}", e);
+    });
+}
+
+// Add things like `#[cfg(ruby_use_transient_heap = "true")]` to the bindings config
+fn push_cargo_cfg_from_bindings(
+    syntax: &syn::File,
+    cfg_out: &mut File,
+) -> Result<(), Box<dyn Error>> {
+    fn is_defines(line: &str) -> bool {
+        line.starts_with("HAVE_RUBY")
+            || line.starts_with("HAVE_RB")
+            || line.starts_with("USE")
+            || line.starts_with("RUBY_DEBUG")
+            || line.starts_with("RUBY_NDEBUG")
+    }
+
+    for item in syntax.items.iter() {
+        if let syn::Item::Const(item) = item {
+            let conf = ConfValue::new(item);
+            let conf_name = conf.name();
+
+            if is_defines(&conf_name) {
+                let name = conf_name.to_lowercase();
+                let val = conf.value_bool().to_string();
+                println!(
+                    r#"cargo:rustc-check-cfg=cfg(ruby_{}, values("true", "false"))"#,
+                    name
+                );
+                println!("cargo:rustc-cfg=ruby_{}=\"{}\"", name, val);
+                println!("cargo:defines_{}={}", name, val);
+                writeln!(cfg_out, "cargo:defines_{}={}", name, val)?;
+            }
+
+            if conf_name.starts_with("RUBY_ABI_VERSION") {
+                println!("cargo:ruby_abi_version={}", conf.value_string());
+                writeln!(cfg_out, "cargo:ruby_abi_version={}", conf.value_string())?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// An autoconf constant in the bindings
+struct ConfValue<'a> {
+    item: &'a syn::ItemConst,
+}
+
+impl<'a> ConfValue<'a> {
+    pub fn new(item: &'a ItemConst) -> Self {
+        Self { item }
+    }
+
+    pub fn name(&self) -> String {
+        self.item.ident.to_string()
+    }
+
+    pub fn value_string(&self) -> String {
+        match &*self.item.expr {
+            Expr::Lit(ExprLit { lit, .. }) => lit.to_token_stream().to_string(),
+            _ => panic!(
+                "Could not convert HAVE_* constant to string: {:#?}",
+                self.item
+            ),
+        }
+    }
+
+    pub fn value_bool(&self) -> bool {
+        match &*self.item.expr {
+            Expr::Lit(ExprLit {
+                lit: Lit::Int(ref lit),
+                ..
+            }) => lit.base10_parse::<u8>().unwrap_or(1) != 0,
+            Expr::Lit(ExprLit {
+                lit: Lit::Bool(ref lit),
+                ..
+            }) => lit.value,
+            _ => panic!(
+                "Could not convert HAVE_* constant to bool: {:#?}",
+                self.item
+            ),
+        }
+    }
+}

data/vendor/rb-sys-build/src/cc.rs

@@ -0,0 +1,421 @@
+use crate::{
+    debug_log, rb_config,
+    utils::{is_msvc, shellsplit},
+};
+use std::{
+    collections::{hash_map::DefaultHasher, HashSet},
+    env,
+    ffi::{OsStr, OsString},
+    fs,
+    hash::Hasher,
+    path::{Path, PathBuf},
+    process::{Command, ExitStatus, Stdio},
+};
+
+type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+
+const WELL_KNOWN_WRAPPERS: &[&str] = &["sccache", "cachepot"];
+
+#[derive(Default, Debug)]
+pub struct Build {
+    files: Vec<PathBuf>,
+    flags: Vec<String>,
+}
+
+impl Build {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn default_cflags() -> Vec<String> {
+        let mut cflags = vec![];
+
+        if cfg!(target_os = "openbsd") {
+            cflags.push("-fdeclspec".into());
+        } else {
+            cflags.push("-fms-extensions".into());
+        };
+
+        cflags
+    }
+
+    pub fn file(&mut self, file: PathBuf) {
+        println!("cargo:rerun-if-changed={}", file.display());
+        self.files.push(file);
+    }
+
+    pub fn try_compile(self, name: &str) -> Result<()> {
+        let compiler = get_compiler();
+        let archiver = get_archiver();
+        let out_dir = PathBuf::from(env::var("OUT_DIR")?).join("cc");
+        fs::create_dir_all(&out_dir)?;
+        let rb = rb_config();
+
+        let object_files = self.compile_each_file(compiler, &rb, &out_dir)?;
+        debug_log!("INFO: compiled object files: {:?}", object_files);
+        let (lib_path, lib_name) =
+            self.archive_object_files(archiver.copied(), name, &out_dir, object_files)?;
+        if let Err(e) = self.strip_archived_objects(archiver, &lib_path) {
+            debug_log!("WARN: failed to strip archived objects: {:?}", e);
+        }
+
+        println!("cargo:rustc-link-search=native={}", out_dir.display());
+        println!("cargo:rustc-link-lib=static={}", lib_name);
+
+        Ok(())
+    }
+
+    fn compile_each_file(
+        &self,
+        compiler: Command,
+        rb: &rb_config::RbConfig,
+        out_dir: &Path,
+    ) -> Result<HashSet<PathBuf>> {
+        self.files
+            .iter()
+            .map(|f| self.compile_file(f, compiler.copied(), rb, out_dir))
+            .collect()
+    }
+
+    fn compile_file(
+        &self,
+        f: &Path,
+        compiler: Command,
+        rb: &rb_config::RbConfig,
+        out_dir: &Path,
+    ) -> Result<PathBuf> {
+        let mut hasher = DefaultHasher::new();
+        hasher.write(fs::read(f)?.as_slice());
+
+        let object_file = out_dir
+            .join(hasher.finish().to_string())
+            .with_extension("o");
+
+        let mut cmd = compiler;
+        cmd.args(get_include_args(rb))
+            .arg("-c")
+            .arg(f)
+            .args(&rb.cflags)
+            .args(get_common_args())
+            .args(&self.flags)
+            .args(get_output_file_flag(&object_file));
+
+        run_command(cmd)?;
+
+        Ok(object_file)
+    }
+
+    fn archive_object_files(
+        &self,
+        archiver: Command,
+        name: &str,
+        out_dir: &Path,
+        object_files: HashSet<PathBuf>,
+    ) -> Result<(PathBuf, String)> {
+        let mut cmd = archiver;
+        let mut hasher = DefaultHasher::new();
+        object_files
+            .iter()
+            .for_each(|f| hasher.write(f.to_str().expect("non-utf8 filename").as_bytes()));
+        let lib_name = format!("{}-{}", name, hasher.finish());
+        let lib_filename = format!("lib{}.a", lib_name);
+        let dst = out_dir.join(lib_filename);
+
+        // The argument structure differs for MSVC and GCC.
+        if is_msvc() {
+            cmd.arg(format!("/OUT:{}", dst.display()));
+            cmd.args(&object_files);
+        } else {
+            cmd.env("ZERO_AR_DATE", "1").arg("crs").arg(&dst);
+            cmd.args(&object_files);
+        }
+
+        run_command(cmd)?;
+
+        // The Rust compiler will look for libfoo.a and foo.lib, but the
+        // MSVC linker will also be passed foo.lib, so be sure that both
+        // exist for now.
+        if is_msvc() {
+            let lib_dst = dst.with_file_name(format!("{}.lib", lib_name));
+            let _ = fs::remove_file(&lib_dst);
+            match fs::hard_link(&dst, &lib_dst).or_else(|_| {
+                // if hard-link fails, just copy (ignoring the number of bytes written)
+                fs::copy(&dst, &lib_dst).map(|_| ())
+            }) {
+                Ok(_) => (),
+                Err(_) => {
+                    return Err(
+                        "Could not copy or create a hard-link to the generated lib file.".into(),
+                    );
+                }
+            };
+        }
+
+        Ok((dst, lib_name))
+    }
+
+    fn strip_archived_objects(&self, archiver: Command, libpath: &Path) -> Result<()> {
+        let mut cmd = archiver;
+
+        if is_msvc() {
+            cmd.arg("/LTCG").arg(libpath);
+        } else {
+            cmd.arg("s").arg(libpath);
+        }
+
+        run_command(cmd)?;
+
+        Ok(())
+    }
+}
+
+fn get_include_args(rb: &rb_config::RbConfig) -> Vec<String> {
+    let mut args = vec![];
+    if let Some(include_dir) = rb.get("rubyhdrdir") {
+        args.push(format!("-I{}", include_dir));
+    }
+    if let Some(arch_include_dir) = rb.get("rubyarchhdrdir") {
+        args.push(format!("-I{}", arch_include_dir));
+    }
+    if let Some(internal_include_dir) = rb.get("rubyhdrdir") {
+        args.push(format!("-I{}/include/internal", internal_include_dir));
+    }
+    if let Some(impl_include_dir) = rb.get("rubyhdrdir") {
+        args.push(format!("-I{}/include/impl", impl_include_dir));
+    }
+
+    args
+}
+
+fn get_common_args() -> Vec<String> {
+    fn add_debug_flags(flags: &mut Vec<String>) {
+        match env::var("DEBUG") {
+            Ok(val) if val == "true" => {
+                if is_msvc() {
+                    flags.push("-Z7".into());
+                } else if cfg!(target_os = "linux") {
+                    flags.push("-gdwarf-4".into());
+                } else {
+                    flags.push("-gdwarf-2".into());
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn add_opt_level(flags: &mut Vec<String>) {
+        if let Ok(val) = env::var("OPT_LEVEL") {
+            match val.as_str() {
+                // Msvc uses /O1 to enable all optimizations that minimize code size.
+                "z" | "s" | "1" if is_msvc() => flags.push("-O1".into()),
+                // -O3 is a valid value for gcc and clang compilers, but not msvc. Cap to /O2.
+                "2" | "3" if is_msvc() => flags.push("-O2".into()),
+                lvl => flags.push(format!("-O{}", lvl)),
+            }
+        }
+    }
+
+    fn add_compiler_flags(flags: &mut Vec<String>) {
+        if !is_msvc() {
+            flags.push("-ffunction-sections".into());
+            flags.push("-fdata-sections".into());
+            flags.push("-fPIC".into());
+            flags.push("-fno-omit-frame-pointer".into());
+        }
+
+        flags.extend(Build::default_cflags());
+    }
+
+    let mut items = vec![];
+
+    add_debug_flags(&mut items);
+    add_compiler_flags(&mut items);
+    add_opt_level(&mut items);
+
+    items
+}
+
+fn get_compiler() -> Command {
+    let cmd = get_tool("CC", "cc");
+    let cmd_program = cmd.get_program().to_str().unwrap_or_default();
+    let already_wrapped = WELL_KNOWN_WRAPPERS.iter().any(|w| cmd_program.contains(w));
+
+    match get_tool_from_rb_config_or_env("CC_WRAPPER") {
+        Some(wrapper) if !wrapper.is_empty() && !already_wrapped => {
+            debug_log!("INFO: using CC_WRAPPER ({:?})", wrapper);
+            cmd.wrapped(wrapper)
+        }
+        _ => match rustc_wrapper_fallback() {
+            Some(wrapper) if !already_wrapped => cmd.wrapped(wrapper),
+            _ => cmd,
+        },
+    }
+}
+
+pub fn rustc_wrapper_fallback() -> Option<String> {
+    let rustc_wrapper = std::env::var("RUSTC_WRAPPER").ok()?;
+    rustc_wrapper_fallback_detect(rustc_wrapper)
+}
+
+pub fn rustc_wrapper_fallback_detect(rustc_wrapper: String) -> Option<String> {
+    let wrapper_path = Path::new(&rustc_wrapper);
+    let wrapper_stem = wrapper_path.file_stem()?;
+
+    if WELL_KNOWN_WRAPPERS.contains(&wrapper_stem.to_str()?) {
+        debug_log!("INFO: using RUSTC_WRAPPER ({:?})", rustc_wrapper);
+        Some(rustc_wrapper)
+    } else {
+        None
+    }
+}
+
+fn get_archiver() -> Command {
+    let cmd = get_tool("AR", "ar");
+
+    if cmd.get_program() == "libtool" {
+        new_command("ar")
+    } else {
+        cmd
+    }
+}
+
+fn get_tool(env_var: &str, default: &str) -> Command {
+    let tool_args = get_tool_from_rb_config_or_env(env_var)
+        .unwrap_or_else(|| panic!("no {} tool found", env_var));
+
+    let mut tool_args = shellsplit(tool_args).into_iter();
+    let tool = tool_args.next().unwrap_or_else(|| default.to_string());
+
+    fn tool_exists(tool_name: &str) -> std::io::Result<bool> {
+        let path = PathBuf::from(tool_name);
+
+        if path.is_file() {
+            return Ok(true);
+        }
+
+        match Command::new(tool_name).spawn() {
+            Ok(_) => Ok(true),
+            Err(e) => {
+                if e.kind() == std::io::ErrorKind::NotFound {
+                    Ok(false)
+                } else {
+                    Err(e)
+                }
+            }
+        }
+    }
+
+    let mut cmd = if tool_exists(&tool).unwrap_or(false) {
+        debug_log!("[INFO] using {tool} for {env_var}");
+        new_command(&tool)
+    } else {
+        debug_log!("[WARN] {tool} tool not found, falling back to {default}");
+        new_command(default)
+    };
+
+    cmd.args(tool_args.clone());
+
+    debug_log!("INFO: found {:?} tool ({:?})", env_var, &cmd);
+
+    cmd
+}
+
+fn get_tool_from_rb_config_or_env(env_var: &str) -> Option<String> {
+    let rb = rb_config();
+
+    get_tool_from_env(env_var)
+        .filter(|s| !s.is_empty())
+        .or_else(|| rb.get(env_var))
+}
+
+fn get_tool_from_env(env_var: &str) -> Option<String> {
+    let target_slug = env::var("TARGET").ok()?.replace('-', "_");
+    let env_var_with_target = format!("{}_{}", env_var, target_slug);
+
+    println!("cargo:rerun-if-env-changed={}", env_var);
+    println!("cargo:rerun-if-env-changed={}", env_var_with_target);
+
+    env::var(env_var)
+        .or_else(|_| env::var(env_var_with_target))
+        .ok()
+}
+
+fn run_command(mut cmd: Command) -> Result<ExitStatus> {
+    debug_log!("INFO: running command ({:?})", cmd);
+    let status = cmd.status()?;
+
+    if !status.success() {
+        Err(format!("Command '{:?}' failed with status: {}", cmd, status).into())
+    } else {
+        Ok(status)
+    }
+}
+
+fn new_command(name: &str) -> Command {
+    let mut cmd = Command::new(name);
+    cmd.stderr(Stdio::inherit()).stdout(Stdio::inherit());
+    cmd
+}
+
+fn get_output_file_flag(file: &Path) -> Vec<OsString> {
+    if is_msvc() {
+        vec![format!("-Fo{}", file.display()).into()]
+    } else {
+        vec!["-o".into(), file.into()]
+    }
+}
+
+pub trait CommandExt {
+    fn copied(&self) -> Command;
+    fn wrapped<W: AsRef<OsStr>>(&self, wrapper: W) -> Command;
+}
+
+impl CommandExt for Command {
+    fn copied(&self) -> Command {
+        let mut cmd = Command::new(self.get_program());
+        cmd.args(self.get_args());
+
+        for (k, v) in self.get_envs() {
+            if let Some(v) = v {
+                cmd.env(k, v);
+            } else {
+                cmd.env_remove(k);
+            }
+        }
+        cmd
+    }
+
+    fn wrapped<W: AsRef<OsStr>>(&self, wrapper: W) -> Command {
+        let mut new_cmd = Command::new(wrapper);
+
+        new_cmd.arg(self.get_program());
+
+        for arg in self.get_args() {
+            new_cmd.arg(arg);
+        }
+
+        for (k, v) in self.get_envs() {
+            if let Some(v) = v {
+                new_cmd.env(k, v);
+            } else {
+                new_cmd.env_remove(k);
+            }
+        }
+
+        new_cmd
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rustc_wrapper_detect() {
+        let wrapper = "/usr/local/bin/sccache";
+        assert_eq!(
+            rustc_wrapper_fallback_detect(wrapper.to_owned()),
+            Some(wrapper.to_owned())
+        );
+    }
+}

data/vendor/rb-sys-build/src/lib.rs

@@ -0,0 +1,12 @@
+pub mod bindings;
+pub mod cc;
+pub mod utils;
+
+mod rb_config;
+
+pub use rb_config::*;
+
+/// The current RbConfig.
+pub fn rb_config() -> RbConfig {
+    RbConfig::current()
+}