use std::io::Write;
use std::path::{Path, PathBuf};
use serde::Serialize;
use crate::error::CliError;
const NODE_CARGO_TOML: &str = include_str!("../templates/node/Cargo.toml.template");
const NODE_MAIN_RS: &str = include_str!("../templates/node/main.rs.template");
const NODE_DATAFLOW_YML: &str = include_str!("../templates/node/dataflow.yml.template");
const OPERATOR_CARGO_TOML: &str = include_str!("../templates/operator/Cargo.toml.template");
const OPERATOR_LIB_RS: &str = include_str!("../templates/operator/lib.rs.template");
const OPERATOR_DATAFLOW_YML: &str = include_str!("../templates/operator/dataflow.yml.template");
const OPERATOR_DYLIB_CARGO_TOML: &str =
include_str!("../templates/operator-dylib/Cargo.toml.template");
const OPERATOR_DYLIB_LIB_RS: &str = include_str!("../templates/operator-dylib/lib.rs.template");
const OPERATOR_DYLIB_DATAFLOW_YML: &str =
include_str!("../templates/operator-dylib/dataflow.yml.template");
const GRAPH_DATAFLOW_YML: &str = include_str!("../templates/graph/dataflow.yml.template");
const NAME_TOKEN: &str = "__ASTRS_PROJECT_NAME__";
const TYPE_TOKEN: &str = "__ASTRS_PROJECT_TYPE__";
const LIB_FILE_STEM_TOKEN: &str = "__ASTRS_PROJECT_LIB_FILE_STEM__";
#[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum)]
#[value(rename_all = "lower")]
pub enum NewKind {
Node,
Operator,
#[value(name = "operator-dylib")]
OperatorDylib,
Graph,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, clap::ValueEnum)]
#[value(rename_all = "lower")]
pub enum NewLang {
#[default]
Rust,
}
#[derive(Debug, Clone)]
pub struct NewArgs {
pub kind: NewKind,
pub name: String,
pub lang: NewLang,
pub dir: PathBuf,
pub force: bool,
pub json: bool,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct NewReport {
pub files: Vec<PathBuf>,
}
fn validate_name(name: &str) -> Result<(), CliError> {
let unsafe_path = || CliError::UnsafePath {
path: name.to_string(),
};
if name.is_empty() {
return Err(unsafe_path());
}
let path = Path::new(name);
let mut components = path.components();
match (components.next(), components.next()) {
(Some(std::path::Component::Normal(component)), None) if component == path.as_os_str() => {
Ok(())
}
_ => Err(unsafe_path()),
}
}
fn pascal_case_type_name(name: &str) -> String {
let mut out = String::new();
for segment in name.split(|c: char| !c.is_ascii_alphanumeric()) {
let mut chars = segment.chars();
if let Some(first) = chars.next() {
out.extend(first.to_uppercase());
out.extend(chars);
}
}
if out.chars().next().is_some_and(|c| c.is_ascii_digit()) {
format!("Op{out}")
} else if out.is_empty() {
"Op".to_string()
} else {
out
}
}
fn lib_file_stem(name: &str) -> String {
name.replace('-', "_")
}
fn render(template: &str, name: &str) -> String {
template
.replace(NAME_TOKEN, name)
.replace(TYPE_TOKEN, &pascal_case_type_name(name))
.replace(LIB_FILE_STEM_TOKEN, &lib_file_stem(name))
}
fn write_file(path: &Path, contents: &str, force: bool) -> Result<(), CliError> {
if !force && path.exists() {
return Err(CliError::TargetExists {
path: path.display().to_string(),
});
}
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).map_err(|err| CliError::io(parent, err))?;
}
std::fs::write(path, contents).map_err(|err| CliError::io(path, err))
}
pub fn run(out: &mut dyn Write, args: &NewArgs) -> Result<NewReport, CliError> {
validate_name(&args.name)?;
let _ = args.lang;
let files = match args.kind {
NewKind::Node => {
let root = args.dir.join(&args.name);
let entries = [
(root.join("Cargo.toml"), NODE_CARGO_TOML),
(root.join("src/main.rs"), NODE_MAIN_RS),
(root.join("dataflow.yml"), NODE_DATAFLOW_YML),
];
write_all(&entries, &args.name, args.force)?
}
NewKind::Operator => {
let root = args.dir.join(&args.name);
let entries = [
(root.join("Cargo.toml"), OPERATOR_CARGO_TOML),
(root.join("src/lib.rs"), OPERATOR_LIB_RS),
(root.join("dataflow.yml"), OPERATOR_DATAFLOW_YML),
];
write_all(&entries, &args.name, args.force)?
}
NewKind::OperatorDylib => {
let root = args.dir.join(&args.name);
let entries = [
(root.join("Cargo.toml"), OPERATOR_DYLIB_CARGO_TOML),
(root.join("src/lib.rs"), OPERATOR_DYLIB_LIB_RS),
(root.join("dataflow.yml"), OPERATOR_DYLIB_DATAFLOW_YML),
];
write_all(&entries, &args.name, args.force)?
}
NewKind::Graph => {
let path = args.dir.join(format!("{}.astrs.yml", args.name));
write_all(&[(path, GRAPH_DATAFLOW_YML)], &args.name, args.force)?
}
};
let report = NewReport { files };
if args.json {
let json = serde_json::to_string_pretty(&report).unwrap_or_else(|err| {
format!("{{\"error\": \"failed to serialize new report: {err}\"}}")
});
writeln!(out, "{json}").map_err(|e| CliError::io("<output>", e))?;
} else {
writeln!(
out,
"created {} file(s) for {} `{}`:",
report.files.len(),
kind_label(args.kind),
args.name
)
.map_err(|e| CliError::io("<output>", e))?;
for file in &report.files {
writeln!(out, " {}", file.display()).map_err(|e| CliError::io("<output>", e))?;
}
}
Ok(report)
}
fn kind_label(kind: NewKind) -> &'static str {
match kind {
NewKind::Node => "node",
NewKind::Operator => "operator",
NewKind::OperatorDylib => "dylib operator",
NewKind::Graph => "graph",
}
}
fn write_all(
entries: &[(PathBuf, &str)],
name: &str,
force: bool,
) -> Result<Vec<PathBuf>, CliError> {
let mut written = Vec::with_capacity(entries.len());
for (path, template) in entries {
write_file(path, &render(template, name), force)?;
written.push(path.clone());
}
Ok(written)
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
fn scratch_dir(name: &str) -> PathBuf {
static COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
let n = COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let dir = std::env::temp_dir().join(format!(
"astrs-cli-new-test-{}-{name}-{n}",
std::process::id()
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}
fn args(kind: NewKind, name: &str, dir: PathBuf) -> NewArgs {
NewArgs {
kind,
name: name.to_string(),
lang: NewLang::Rust,
dir,
force: false,
json: false,
}
}
#[test]
fn node_template_creates_cargo_toml_main_rs_and_dataflow_yml() {
let dir = scratch_dir("node");
let mut out = Vec::new();
let report = run(&mut out, &args(NewKind::Node, "my-node", dir.clone())).unwrap();
assert_eq!(report.files.len(), 3);
for file in &report.files {
assert!(file.exists(), "{} was not written", file.display());
}
let cargo_toml = std::fs::read_to_string(dir.join("my-node/Cargo.toml")).unwrap();
assert!(cargo_toml.contains("name = \"my-node\""));
assert!(!cargo_toml.contains(NAME_TOKEN));
let main_rs = std::fs::read_to_string(dir.join("my-node/src/main.rs")).unwrap();
assert!(main_rs.contains("my-node"));
let dataflow = std::fs::read_to_string(dir.join("my-node/dataflow.yml")).unwrap();
assert!(dataflow.contains("path: ./target/release/my-node"));
}
#[test]
fn json_flag_emits_a_structured_file_list_instead_of_the_human_summary() {
let dir = scratch_dir("json");
let mut out = Vec::new();
let mut a = args(NewKind::Node, "json-node", dir.clone());
a.json = true;
let report = run(&mut out, &a).unwrap();
let printed = String::from_utf8(out).unwrap();
let value: serde_json::Value = serde_json::from_str(printed.trim_end()).unwrap();
let files = value["files"].as_array().unwrap();
assert_eq!(files.len(), 3);
assert_eq!(files.len(), report.files.len());
for file in &report.files {
assert!(
files
.iter()
.any(|v| v.as_str() == Some(&file.display().to_string()))
);
}
assert!(!printed.contains("created"));
}
#[test]
fn node_dataflow_yml_validates_cleanly() {
let dir = scratch_dir("node-validates");
let mut out = Vec::new();
run(&mut out, &args(NewKind::Node, "camera-node", dir.clone())).unwrap();
let yaml = std::fs::read_to_string(dir.join("camera-node/dataflow.yml")).unwrap();
let manifest = astrs_manifest::Manifest::from_yaml_str(&yaml).unwrap();
manifest.validate().unwrap();
}
#[test]
fn operator_template_creates_lib_rs_with_a_pascal_case_type_and_validates() {
let dir = scratch_dir("operator");
let mut out = Vec::new();
let report = run(
&mut out,
&args(NewKind::Operator, "my-cool-op", dir.clone()),
)
.unwrap();
assert_eq!(report.files.len(), 3);
let lib_rs = std::fs::read_to_string(dir.join("my-cool-op/src/lib.rs")).unwrap();
assert!(lib_rs.contains("struct MyCoolOp"));
assert!(lib_rs.contains("register_operator!(MyCoolOp)"));
assert!(!lib_rs.contains(TYPE_TOKEN));
assert!(lib_rs.contains("OpEvent::Stop {"));
assert!(lib_rs.contains("Status::Finished"));
assert!(!lib_rs.contains("Status::Stop"));
assert!(lib_rs.contains("_ =>"));
assert!(lib_rs.contains("fn operator_entry()"));
let cargo_toml = std::fs::read_to_string(dir.join("my-cool-op/Cargo.toml")).unwrap();
assert!(cargo_toml.contains(r#"features = ["operator"]"#));
let yaml = std::fs::read_to_string(dir.join("my-cool-op/dataflow.yml")).unwrap();
let manifest = astrs_manifest::Manifest::from_yaml_str(&yaml).unwrap();
manifest.validate().unwrap();
assert_eq!(
manifest.nodes[0].operators.as_ref().unwrap()[0].operator,
"MyCoolOp"
);
}
#[test]
fn operator_dylib_template_creates_a_cdylib_crate_with_a_dylib_locator_and_validates() {
let dir = scratch_dir("operator-dylib");
let mut out = Vec::new();
let report = run(
&mut out,
&args(NewKind::OperatorDylib, "my-cool-dylib-op", dir.clone()),
)
.unwrap();
assert_eq!(report.files.len(), 3);
let cargo_toml = std::fs::read_to_string(dir.join("my-cool-dylib-op/Cargo.toml")).unwrap();
assert!(!cargo_toml.contains(NAME_TOKEN));
assert!(cargo_toml.contains(r#"crate-type = ["cdylib", "lib"]"#));
assert!(cargo_toml.contains(r#"features = ["dylib"]"#));
let lib_rs = std::fs::read_to_string(dir.join("my-cool-dylib-op/src/lib.rs")).unwrap();
assert!(!lib_rs.contains(TYPE_TOKEN));
assert!(lib_rs.contains("struct MyCoolDylibOp"));
assert!(lib_rs.contains("export_dylib_operator!(MyCoolDylibOp)"));
assert!(!lib_rs.contains("register_operator!"));
assert!(lib_rs.contains("OpEvent::Stop {"));
assert!(lib_rs.contains("Status::Finished"));
assert!(!lib_rs.contains("Status::Stop"));
assert!(lib_rs.contains("_ =>"));
let yaml = std::fs::read_to_string(dir.join("my-cool-dylib-op/dataflow.yml")).unwrap();
let manifest = astrs_manifest::Manifest::from_yaml_str(&yaml).unwrap();
manifest.validate().unwrap();
let operator = &manifest.nodes[0].operators.as_ref().unwrap()[0];
assert_eq!(operator.operator, "MyCoolDylibOp");
assert_eq!(
operator.dylib.as_deref(),
Some("./target/release/libmy_cool_dylib_op.so")
);
assert_eq!(operator.locator_kinds(), vec!["dylib"]);
}
#[test]
fn graph_template_creates_a_single_yaml_file_and_validates() {
let dir = scratch_dir("graph");
let mut out = Vec::new();
let report = run(&mut out, &args(NewKind::Graph, "perception", dir.clone())).unwrap();
assert_eq!(report.files, vec![dir.join("perception.astrs.yml")]);
let yaml = std::fs::read_to_string(&report.files[0]).unwrap();
let manifest = astrs_manifest::Manifest::from_yaml_str(&yaml).unwrap();
manifest.validate().unwrap();
assert_eq!(manifest.name.as_deref(), Some("perception"));
}
#[test]
fn path_traversal_in_name_is_rejected() {
let dir = scratch_dir("traversal");
for bad in ["../escape", "/etc/passwd", "a/b", "..", "."] {
let err = run(&mut Vec::new(), &args(NewKind::Node, bad, dir.clone())).unwrap_err();
assert!(
matches!(err, CliError::UnsafePath { .. }),
"name `{bad}` should be rejected, got {err:?}"
);
}
}
#[test]
fn empty_name_is_rejected() {
let dir = scratch_dir("empty");
let err = run(&mut Vec::new(), &args(NewKind::Node, "", dir)).unwrap_err();
assert!(matches!(err, CliError::UnsafePath { .. }));
}
#[test]
fn existing_target_without_force_is_rejected() {
let dir = scratch_dir("exists");
run(&mut Vec::new(), &args(NewKind::Node, "dup", dir.clone())).unwrap();
let err = run(&mut Vec::new(), &args(NewKind::Node, "dup", dir)).unwrap_err();
assert!(matches!(err, CliError::TargetExists { .. }));
}
#[test]
fn force_overwrites_an_existing_target() {
let dir = scratch_dir("force");
run(&mut Vec::new(), &args(NewKind::Node, "dup", dir.clone())).unwrap();
let mut a = args(NewKind::Node, "dup", dir);
a.force = true;
run(&mut Vec::new(), &a).unwrap();
}
#[test]
fn pascal_case_handles_hyphens_underscores_and_leading_digits() {
assert_eq!(pascal_case_type_name("my-cool-op"), "MyCoolOp");
assert_eq!(pascal_case_type_name("my_cool_op"), "MyCoolOp");
assert_eq!(pascal_case_type_name("3d-tracker"), "Op3dTracker");
assert_eq!(pascal_case_type_name("simple"), "Simple");
}
#[test]
fn lib_file_stem_turns_hyphens_into_underscores_and_leaves_everything_else_alone() {
assert_eq!(lib_file_stem("my-cool-op"), "my_cool_op");
assert_eq!(lib_file_stem("my_cool_op"), "my_cool_op");
assert_eq!(lib_file_stem("simple"), "simple");
assert_eq!(lib_file_stem("3d-tracker"), "3d_tracker");
}
#[test]
fn generated_cargo_toml_is_textually_well_formed() {
let dir = scratch_dir("cargo-toml-shape");
run(
&mut Vec::new(),
&args(NewKind::Node, "shape-check", dir.clone()),
)
.unwrap();
let cargo_toml = std::fs::read_to_string(dir.join("shape-check/Cargo.toml")).unwrap();
assert!(cargo_toml.contains("[package]"));
assert!(cargo_toml.contains("[dependencies]"));
assert!(
cargo_toml
.lines()
.any(|l| l.trim() == "name = \"shape-check\"")
);
assert!(!cargo_toml.contains("workspace = true"));
}
}