use std::path::{Path, PathBuf};
use std::process::Command;
use crate::config::KitConfig;
use crate::error::{KitError, KitResult};
use crate::install::remove_dir_if_exists;
use crate::manifest::PluginManifest;
use crate::wrapper::{self, cargo_metadata_json, declared_contract_dep, PluginSource};
mod naming;
use naming::wrapper_dir;
#[derive(Debug, Clone)]
pub struct PackOptions {
pub target_dir: Option<PathBuf>,
pub verify_export: bool,
}
impl Default for PackOptions {
fn default() -> Self {
Self {
target_dir: None,
verify_export: true,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PackedAssets {
pub crate_name: String,
pub version: String,
pub target: String,
pub library: PathBuf,
pub manifest: PathBuf,
}
impl PackedAssets {
pub fn base_name(&self) -> String {
format!("{}-{}-{}", self.crate_name, self.version, self.target)
}
}
pub fn build(
cfg: &KitConfig,
plugin_dir: impl AsRef<Path>,
out_dir: impl AsRef<Path>,
options: &PackOptions,
) -> KitResult<PackedAssets> {
let cargo = which::which("cargo").map_err(|_| KitError::CargoNotFound)?;
let plugin_dir = plugin_dir.as_ref().canonicalize()?;
let manifest_path = plugin_dir.join("Cargo.toml");
if !manifest_path.is_file() {
return Err(KitError::NoManifest { dir: plugin_dir });
}
let metadata = cargo_metadata_json(&cargo, &manifest_path)?;
let (crate_name, version) = wrapper::package_identity(&metadata, &manifest_path)?;
let plugin_manifest = plugin_dir.join(&cfg.manifest_name);
let manifest = PluginManifest::read(&plugin_manifest)?;
if manifest.plugin.version != version {
return Err(KitError::VersionMismatch {
path: plugin_manifest,
declared: manifest.plugin.version,
crate_version: version,
});
}
let target = cfg.effective_target().to_string();
let target_dir = options
.target_dir
.clone()
.unwrap_or_else(|| plugin_dir.join("target"));
let wrapper_dir = wrapper_dir(cfg, &crate_name);
std::fs::create_dir_all(wrapper_dir.join("src"))?;
let stem = cfg.lib_stem(&crate_name);
let contract = declared_contract_dep(&metadata, &crate_name, &cfg.contract_crate);
wrapper::write(
cfg,
&wrapper_dir,
&crate_name,
&stem,
PluginSource::Path { dir: &plugin_dir },
contract.as_ref(),
)?;
let status = Command::new(&cargo)
.arg("build")
.arg("--release")
.arg("--manifest-path")
.arg(wrapper_dir.join("Cargo.toml"))
.arg("--target")
.arg(&target)
.arg("--target-dir")
.arg(&target_dir)
.status()
.map_err(KitError::Io)?;
if !status.success() {
return Err(KitError::BuildFailed {
code: status.code(),
});
}
let release_dir = target_dir.join(&target).join("release");
let built =
crate::loader::find_library_for_target(&release_dir, &stem, &target).map_err(|_| {
KitError::BuildArtifactMissing {
stem: stem.clone(),
dir: release_dir.display().to_string(),
}
})?;
let out_dir = out_dir.as_ref();
std::fs::create_dir_all(out_dir)?;
let base = format!("{crate_name}-{version}-{target}");
let library = out_dir.join(format!(
"{base}.{}",
crate::loader::lib_ext_for_target(&target)
));
std::fs::copy(&built, &library)?;
let manifest_out = out_dir.join(format!("{base}.toml"));
std::fs::copy(&plugin_manifest, &manifest_out)?;
if options.verify_export && target == crate::TARGET_TRIPLE {
let _loaded = unsafe { crate::loader::open::<()>(&library, &cfg.entry_symbol) }?;
}
if let Some(run_root) = wrapper_dir.parent() {
let _ = remove_dir_if_exists(run_root);
}
Ok(PackedAssets {
crate_name,
version,
target,
library,
manifest: manifest_out,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn base_name_is_crate_version_target() {
let assets = PackedAssets {
crate_name: "bmux-plugin-cargo".to_string(),
version: "0.1.0".to_string(),
target: "x86_64-pc-windows-msvc".to_string(),
library: PathBuf::from("a.dll"),
manifest: PathBuf::from("a.toml"),
};
assert_eq!(
assets.base_name(),
"bmux-plugin-cargo-0.1.0-x86_64-pc-windows-msvc"
);
}
#[test]
fn verify_export_is_on_by_default() {
assert!(PackOptions::default().verify_export);
assert!(PackOptions::default().target_dir.is_none());
}
#[test]
fn a_missing_manifest_is_reported_as_such() {
let tmp = tempfile::tempdir().unwrap();
let cfg = KitConfig::new("myapp");
let err = build(
&cfg,
tmp.path(),
tmp.path().join("dist"),
&PackOptions::default(),
)
.unwrap_err();
assert!(matches!(err, KitError::NoManifest { .. }), "{err:?}");
}
}