Implement simple build command

Author: filmor

cargo-rustler/Cargo.toml

@@ -3,7 +3,12 @@ name = "cargo-rustler"
 version = "0.1.0"
 edition = "2021"
 
+metadata = { msrv = "1.77" }
+
+
 [dependencies]
+cargo_metadata = "0.19.2"
 clap = { version = "4.5", features = [ "derive" ] }
 libloading = "0.8"
 rustler = { version = "0.36.1", path = "../rustler" }
+tempfile = "3.19.1"

cargo-rustler/snippets/on_load.erl

@@ -0,0 +1,19 @@
+-on_load(on_load/0).
+
+on_load() ->
+    PrivDir = case application:get_application(?MODULE) of
+        {ok, App} ->
+            code:priv_dir(App);
+        undefined ->
+            case code:which(?MODULE) of
+                non_existing ->
+                    error(nif_module_not_found);
+                BeamPath ->
+                    AbsDir = filename:dirname(filename:absname(BeamPath)), 
+                    filename:flatten(filename:join([AbsDir, "..", "priv"]))
+            end
+    end,
+
+    Filename = filename:join([PrivDir, "native", ?NIF_NAME]),
+    erlang:load_nif(Filename, ?NIF_LOAD_INFO).
+

cargo-rustler/src/erl_build.rs

@@ -0,0 +1,36 @@
+use std::fs::{self, File};
+use std::io::Write;
+use std::path::Path;
+use std::process::Command;
+
+use tempfile::TempDir;
+
+pub fn build(module_name: &str, module: &str, output: &Path) {
+    let dir = TempDir::new().expect("Failed to create temp dir");
+    let module_filename = dir.path().join(format!("{module_name}.erl"));
+    let out_dir = output.join("ebin");
+    fs::create_dir_all(&out_dir).expect("Failed to create output directory");
+
+    // println!("Writing module to: {module_filename:?}\n\n====\n{module}\n===");
+
+    {
+        let mut f = File::create_new(&module_filename).expect("Failed to create temp file");
+        f.write_all(module.as_bytes())
+            .expect("Failed to write to temp file");
+    }
+
+    let command = Command::new("erlc")
+        .arg("-o")
+        .arg(out_dir)
+        .arg(&module_filename)
+        .output()
+        .expect("Failed to execute erlc");
+
+    if !command.status.success() {
+        let stderr = String::from_utf8_lossy(&command.stdout);
+        panic!(
+            "Erlang compilation failed: {}",
+            stderr.trim_end_matches('\n')
+        );
+    }
+}

cargo-rustler/src/main.rs

@@ -1,20 +1,23 @@
+mod erl_build;
 #[cfg(unix)]
 mod fake_symbols;
 mod nif;
 mod nif_elixir;
 mod nif_erlang;
+mod rust_build;
 
 use std::path::PathBuf;
 
 use clap::{Parser, Subcommand};
+use rust_build::BuildArgs;
 
 use crate::nif::NifLibrary;
 
 #[derive(Parser)]
 #[command(version, about, long_about = None)]
 struct Cli {
     #[command(subcommand)]
-    command: Option<Commands>,
+    command: Commands,
 }
 
 #[derive(clap::ValueEnum, Clone, Default, Debug)]
@@ -33,13 +36,15 @@ enum Commands {
         #[arg(short, long, default_value_t, value_enum)]
         format: OutputFormat,
     },
+
+    Build(BuildArgs),
 }
 
 fn main() {
     let cli = Cli::parse();
 
     match &cli.command {
-        Some(Commands::Nif { path, format }) => {
+        Commands::Nif { path, format } => {
             let lib = NifLibrary::load(path).unwrap();
 
             match format {
@@ -57,8 +62,20 @@ fn main() {
                 }
             }
         }
-        None => {
-            panic!("No command given")
+        Commands::Build(args) => {
+            println!("Building NIFs in {:?}", args.path);
+            let paths = rust_build::build(args);
+
+            println!("Got NIFs: {paths:?}");
+
+            for path in paths {
+                let lib = NifLibrary::load(&path).unwrap();
+                let erlang = nif_erlang::LibAsErlang(lib);
+                let module = format!("{erlang}");
+                let module_name = erlang.0.name;
+
+                erl_build::build(&module_name, &module, &args.out);
+            }
         }
     }
 }

cargo-rustler/src/nif.rs

@@ -6,7 +6,7 @@ use std::path::{Path, PathBuf};
 pub struct Nif {
     pub name: String,
     pub arity: usize,
-    pub flags: usize,
+    pub _flags: usize,
 }
 
 pub struct NifLibrary {
@@ -52,7 +52,7 @@ impl NifLibrary {
                     Some(Nif {
                         name: CStr::from_ptr(f.name).to_str().ok()?.to_string(),
                         arity: f.arity as usize,
-                        flags: f.flags as usize,
+                        _flags: f.flags as usize,
                     })
                 })
                 .collect();

cargo-rustler/src/nif_erlang.rs

@@ -5,23 +5,54 @@ pub struct LibAsErlang(pub NifLibrary);
 
 impl fmt::Display for LibAsErlang {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "-module({}).\n\n", string_to_erlang_atom(&self.0.name))?;
+        let nif_lib = &self.0;
+
+        let module_name = string_to_erlang_atom(&nif_lib.name);
+
+        let nifs: Vec<_> = nif_lib
+            .nifs
+            .iter()
+            .enumerate()
+            .map(|(n, nif)| (n, string_to_erlang_atom(&nif.name), nif.arity))
+            .collect();
+
+        let nif_name = nif_lib
+            .path
+            .with_extension("")
+            .file_name()
+            .unwrap()
+            .to_string_lossy()
+            .to_string();
+
+        writeln!(f, "-module({module_name}).\n")?;
         writeln!(f, "-export([")?;
-        let count = self.0.nifs.len();
-        for (n, nif) in self.0.nifs.iter().enumerate() {
-            write!(f, "    {}/{}", string_to_erlang_atom(&nif.name), nif.arity)?;
-            if n == count - 1 {
+        let count = nifs.len();
+        for (n, name, arity) in &nifs {
+            write!(f, "    {name}/{arity}")?;
+            if *n != count - 1 {
+                write!(f, ",")?;
+            }
+            writeln!(f)?;
+        }
+        write!(f, "]).\n\n")?;
+
+        writeln!(f, "-nifs([")?;
+        for (n, name, arity) in &nifs {
+            write!(f, "    {name}/{arity}")?;
+            if *n != count - 1 {
                 write!(f, ",")?;
             }
             writeln!(f)?;
         }
         write!(f, "]).\n\n")?;
 
-        // TODO: On Load function
+        writeln!(f, "-define(NIF_LOAD_INFO, 0).")?;
+        writeln!(f, "-define(NIF_NAME, \"{}\").", &nif_name)?;
+        write!(f, "{}", include_str!("../snippets/on_load.erl"))?;
 
-        for nif in &self.0.nifs {
-            write!(f, "{}(", string_to_erlang_atom(&nif.name))?;
-            for i in 0..nif.arity {
+        for (_, name, arity) in &nifs {
+            write!(f, "{name}(")?;
+            for i in 0..*arity {
                 if i > 0 {
                     write!(f, ", ")?;
                 }

cargo-rustler/src/rust_build.rs

@@ -0,0 +1,79 @@
+use std::fs;
+use std::io::BufReader;
+use std::path::PathBuf;
+use std::process::{Command, Stdio};
+
+use cargo_metadata::Message;
+use clap::Args;
+
+#[derive(Args)]
+pub struct BuildArgs {
+    #[arg(default_value = ".")]
+    pub path: PathBuf,
+
+    #[arg(default_value = "out")]
+    pub out: PathBuf,
+}
+
+pub fn build(args: &BuildArgs) -> Vec<PathBuf> {
+    let path = args.path.clone();
+
+    // Run `cargo build` in the specified directory
+    let mut command = Command::new("cargo")
+        .arg("build")
+        .arg("--release")
+        .arg("--message-format=json")
+        .current_dir(&path)
+        .stdout(Stdio::piped())
+        .spawn()
+        .expect("Failed to execute cargo build");
+
+    let reader = BufReader::new(command.stdout.take().unwrap());
+
+    let mut artifacts = vec![];
+
+    for message in Message::parse_stream(reader) {
+        if let Message::CompilerArtifact(artifact) = message.unwrap() {
+            // Check if the artifact is a library
+            if artifact.target.is_dylib() || artifact.target.is_cdylib() {
+                artifacts.push(artifact);
+            }
+        }
+    }
+
+    dbg!(&artifacts);
+
+    let output = command.wait().expect("Couldn't get cargo's exit status");
+
+    if !output.success() {
+        panic!("Cargo build failed with status: {}", output);
+    }
+
+    artifacts
+        .iter()
+        .map(|artifact| {
+            // Ensure the output directory exists
+            let out_dir = args.out.join("priv/native/");
+            fs::create_dir_all(&out_dir).expect("Failed to create output directory");
+
+            let name = &artifact.target.name;
+            let filename = &artifact.filenames[0];
+            let mut ext = filename.extension().unwrap();
+            // Erlang expects .so on macOS
+            if ext == "dylib" {
+                ext = "so";
+            }
+
+            // Stripping the "lib" prefix simplifies the load_nif call as it can be the same on all platforms
+            let output_name = format!("{}.{}", name, ext);
+            let destination = out_dir.join(&output_name);
+
+            println!("Copying artifact from {:?} to {:?}", filename, destination,);
+
+            // Copy the artifact to the output directory
+            fs::copy(filename, &destination).expect("Failed to copy artifact");
+
+            destination
+        })
+        .collect()
+}