mecha10_templates/services/

node_generator.rs

//! Node generator service
//!
//! Generates custom node templates for Mecha10 projects.
//!
//! File content is rendered from `.template` files embedded at compile time via
//! `include_str!()` (see `crate::templates::render`) rather than built with hand-rolled
//! `format!()` string builders — see `crate::templates::render` for why (LAB-2015).

use crate::paths;
use crate::templates::render::render;
use anyhow::{Context, Result};
use std::path::Path;

/// `Cargo.toml` for a generated node — package/lib/bin sections plus dependencies.
const CARGO_TOML_TEMPLATE: &str = include_str!("../../templates/nodes/Cargo.toml.template");
/// `src/lib.rs` for a generated node — the node struct, its `NodeImpl`, and a demo topic.
const LIB_RS_TEMPLATE: &str = include_str!("../../templates/nodes/lib.rs.template");
/// `src/main.rs` for a generated node — the binary entrypoint.
const MAIN_RS_TEMPLATE: &str = include_str!("../../templates/nodes/main.rs.template");
/// `src/config.rs` for a generated node — the node's `Config` struct.
const CONFIG_RS_TEMPLATE: &str = include_str!("../../templates/nodes/config.rs.template");
/// `configs/nodes/<name>/config.json` for a generated node — static dev/production defaults,
/// with no `{{var}}` placeholders (no per-node variation needed), embedded as a template file
/// anyway for consistency with the other four generated files.
const CONFIG_JSON_TEMPLATE: &str = include_str!("../../templates/nodes/config.json.template");

/// Service for generating custom node templates
pub struct NodeGeneratorService;

impl NodeGeneratorService {
    /// Create a new NodeGeneratorService
    pub fn new() -> Self {
        Self
    }

    /// Generate a new node in the project
    ///
    /// Creates the following structure:
    /// ```text
    /// nodes/<name>/
    /// ├── Cargo.toml
    /// └── src/
    ///     ├── lib.rs
    ///     ├── main.rs
    ///     └── config.rs
    ///
    /// configs/nodes/<name>/
    /// └── config.json
    /// ```
    pub async fn generate_node(&self, project_root: &Path, name: &str, description: Option<&str>) -> Result<()> {
        // Validate name
        self.validate_node_name(name)?;

        // Check if node already exists
        let node_dir = project_root.join(paths::project::NODES_DIR).join(name);
        if node_dir.exists() {
            anyhow::bail!("Node '{}' already exists at {}", name, node_dir.display());
        }

        // Create node directory structure
        let src_dir = node_dir.join(paths::project::SRC_DIR);
        tokio::fs::create_dir_all(&src_dir)
            .await
            .context("Failed to create node directory")?;

        // Generate files
        self.create_cargo_toml(&node_dir, name).await?;
        self.create_lib_rs(&src_dir, name).await?;
        self.create_main_rs(&src_dir, name).await?;
        self.create_config_rs(&src_dir, name).await?;

        // Create config directory and file
        // Config path: configs/nodes/<name>/config.json (no @local prefix)
        let config_dir = project_root.join(paths::config::NODES_DIR).join(name);
        tokio::fs::create_dir_all(&config_dir)
            .await
            .context("Failed to create config directory")?;
        self.create_config_json(&config_dir).await?;

        // Update mecha10.json
        self.update_mecha10_json(project_root, name, description).await?;

        // Update Cargo.toml workspace members
        self.update_cargo_workspace(project_root, name).await?;

        Ok(())
    }

    /// Validate node name
    fn validate_node_name(&self, name: &str) -> Result<()> {
        if name.is_empty() {
            anyhow::bail!("Node name cannot be empty");
        }

        // Check for valid characters (alphanumeric, hyphens, underscores)
        if !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_') {
            anyhow::bail!(
                "Node name '{}' contains invalid characters. Use only letters, numbers, hyphens, and underscores.",
                name
            );
        }

        // Must start with a letter
        if !name.chars().next().map(|c| c.is_ascii_alphabetic()).unwrap_or(false) {
            anyhow::bail!("Node name must start with a letter");
        }

        Ok(())
    }

    /// Convert name to PascalCase (handles both kebab-case and snake_case)
    fn to_pascal_case(&self, name: &str) -> String {
        name.split(['-', '_'])
            .filter(|s| !s.is_empty())
            .map(|word| {
                let mut chars = word.chars();
                match chars.next() {
                    None => String::new(),
                    Some(first) => first.to_uppercase().chain(chars).collect(),
                }
            })
            .collect()
    }

    /// Convert name to snake_case for Rust crate name
    fn to_snake_case(&self, name: &str) -> String {
        name.replace('-', "_")
    }

    /// Create Cargo.toml for the node
    async fn create_cargo_toml(&self, node_dir: &Path, name: &str) -> Result<()> {
        let content = render(
            CARGO_TOML_TEMPLATE,
            &[("name", name), ("crate_name", &self.to_snake_case(name))],
        );

        tokio::fs::write(node_dir.join(paths::rust::CARGO_TOML), content).await?;
        Ok(())
    }

    /// Write generated `content` to `path`, creating/truncating the file.
    ///
    /// Shared by the `create_*_rs` methods below so each one only needs to
    /// build its template string and hand it off, instead of repeating the
    /// `tokio::fs::write(...).await?; Ok(())` boilerplate.
    async fn write_generated(&self, path: &Path, content: String) -> Result<()> {
        tokio::fs::write(path, content).await?;
        Ok(())
    }

    /// Create src/lib.rs with node implementation
    async fn create_lib_rs(&self, src_dir: &Path, name: &str) -> Result<()> {
        let pascal_name = self.to_pascal_case(name);
        let content = render(LIB_RS_TEMPLATE, &[("name", name), ("pascal_name", &pascal_name)]);

        self.write_generated(&src_dir.join("lib.rs"), content).await
    }

    /// Create src/main.rs binary entrypoint
    async fn create_main_rs(&self, src_dir: &Path, name: &str) -> Result<()> {
        let crate_name = self.to_snake_case(name);
        let content = render(MAIN_RS_TEMPLATE, &[("name", name), ("crate_name", &crate_name)]);

        tokio::fs::write(src_dir.join("main.rs"), content).await?;
        Ok(())
    }

    /// Create src/config.rs with configuration struct
    async fn create_config_rs(&self, src_dir: &Path, name: &str) -> Result<()> {
        let pascal_name = self.to_pascal_case(name);
        let content = render(CONFIG_RS_TEMPLATE, &[("name", name), ("pascal_name", &pascal_name)]);

        self.write_generated(&src_dir.join("config.rs"), content).await
    }

    /// Create configs/nodes/<name>/config.json with dev/production sections
    async fn create_config_json(&self, config_dir: &Path) -> Result<()> {
        tokio::fs::write(config_dir.join("config.json"), CONFIG_JSON_TEMPLATE).await?;
        Ok(())
    }

    /// Update mecha10.json to add the new node
    async fn update_mecha10_json(&self, project_root: &Path, name: &str, _description: Option<&str>) -> Result<()> {
        let config_path = project_root.join(paths::PROJECT_CONFIG);

        // Read existing config
        let content = tokio::fs::read_to_string(&config_path)
            .await
            .context("Failed to read mecha10.json")?;

        let mut config: serde_json::Value = serde_json::from_str(&content).context("Failed to parse mecha10.json")?;

        // Node identifier: just the name (no @local/ prefix)
        let node_identifier = name.to_string();

        // Add to nodes array
        if let Some(nodes) = config.get_mut("nodes") {
            if let Some(arr) = nodes.as_array_mut() {
                // Check if node already exists
                let exists = arr.iter().any(|n| n.as_str() == Some(&node_identifier));
                if exists {
                    anyhow::bail!("Node '{}' already exists in mecha10.json", name);
                }
                arr.push(serde_json::Value::String(node_identifier.clone()));
            }
        } else {
            // Create nodes section
            config["nodes"] = serde_json::json!([node_identifier.clone()]);
        }

        // Also add to lifecycle.modes.dev.nodes for immediate use in dev mode
        if let Some(lifecycle) = config.get_mut("lifecycle") {
            if let Some(modes) = lifecycle.get_mut("modes") {
                if let Some(dev) = modes.get_mut("dev") {
                    if let Some(dev_nodes) = dev.get_mut("nodes") {
                        if let Some(arr) = dev_nodes.as_array_mut() {
                            let exists = arr.iter().any(|n| n.as_str() == Some(&node_identifier));
                            if !exists {
                                arr.push(serde_json::Value::String(node_identifier));
                            }
                        }
                    }
                }
            }
        }

        // Write updated config
        let updated_content = serde_json::to_string_pretty(&config)?;
        tokio::fs::write(&config_path, updated_content).await?;

        Ok(())
    }

    /// Update Cargo.toml workspace members to include the new node
    async fn update_cargo_workspace(&self, project_root: &Path, name: &str) -> Result<()> {
        crate::services::cargo_workspace::add_workspace_member(project_root, &format!("nodes/{}", name)).await
    }
}

impl Default for NodeGeneratorService {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    /// Set up a minimal fixture project root with a valid mecha10.json and
    /// Cargo.toml, so `generate_node` can update both without erroring.
    async fn setup_project() -> TempDir {
        let temp = TempDir::new().unwrap();

        let mecha10_json = r#"{
  "nodes": [],
  "lifecycle": {
    "modes": {
      "dev": {
        "nodes": []
      }
    }
  }
}
"#;
        tokio::fs::write(temp.path().join("mecha10.json"), mecha10_json)
            .await
            .unwrap();

        let cargo_toml = "[workspace]\nmembers = []\n";
        tokio::fs::write(temp.path().join("Cargo.toml"), cargo_toml)
            .await
            .unwrap();
        // Sanity-check the fixture is actually parseable TOML before any test
        // relies on it — a bare `[workspace]` header with no following
        // key would silently produce an empty table and mask real bugs.
        let _: toml::Value = toml::from_str(cargo_toml).expect("fixture Cargo.toml must be valid TOML");

        temp
    }

    #[test]
    fn validate_node_name_rejects_empty() {
        let service = NodeGeneratorService::new();
        let err = service.validate_node_name("").unwrap_err();
        assert!(err.to_string().contains("cannot be empty"));
    }

    #[test]
    fn validate_node_name_rejects_invalid_characters() {
        let service = NodeGeneratorService::new();
        let err = service.validate_node_name("my node!").unwrap_err();
        assert!(err.to_string().contains("invalid characters"));
    }

    #[test]
    fn validate_node_name_rejects_leading_digit() {
        let service = NodeGeneratorService::new();
        let err = service.validate_node_name("1motor").unwrap_err();
        assert!(err.to_string().contains("must start with a letter"));
    }

    #[test]
    fn validate_node_name_accepts_kebab_and_snake_case() {
        let service = NodeGeneratorService::new();
        assert!(service.validate_node_name("my-motor_node").is_ok());
        assert!(service.validate_node_name("Motor2").is_ok());
    }

    #[test]
    fn to_pascal_case_handles_kebab_case() {
        let service = NodeGeneratorService::new();
        assert_eq!(service.to_pascal_case("my-motor-node"), "MyMotorNode");
    }

    #[test]
    fn to_pascal_case_handles_snake_case() {
        let service = NodeGeneratorService::new();
        assert_eq!(service.to_pascal_case("my_motor_node"), "MyMotorNode");
    }

    #[test]
    fn to_snake_case_replaces_hyphens() {
        let service = NodeGeneratorService::new();
        assert_eq!(service.to_snake_case("my-motor-node"), "my_motor_node");
    }

    #[tokio::test]
    async fn generate_node_rejects_invalid_name_before_touching_disk() {
        let temp = setup_project().await;
        let service = NodeGeneratorService::new();

        let err = service
            .generate_node(temp.path(), "1-bad-name", None)
            .await
            .unwrap_err();

        assert!(err.to_string().contains("must start with a letter"));
        assert!(!temp.path().join("nodes").exists());
    }

    #[tokio::test]
    async fn generate_node_creates_expected_file_structure() {
        let temp = setup_project().await;
        let service = NodeGeneratorService::new();

        service.generate_node(temp.path(), "motor", Some("desc")).await.unwrap();

        let node_dir = temp.path().join("nodes").join("motor");
        assert!(node_dir.join("Cargo.toml").exists());
        assert!(node_dir.join("src/lib.rs").exists());
        assert!(node_dir.join("src/main.rs").exists());
        assert!(node_dir.join("src/config.rs").exists());

        let config_dir = temp.path().join("configs/nodes/motor");
        assert!(config_dir.join("config.json").exists());
    }

    /// Regression test for LAB-2015: converting `create_cargo_toml`/`create_lib_rs`/
    /// `create_main_rs`/`create_config_rs` from hand-rolled `format!()` builders to
    /// `.template`-file rendering must not change a single byte of the generated output
    /// (modulo the `{name}`/`{crate_name}`/`{pascal_name}` variable substitution itself) — this
    /// is a refactor of *how* the content is produced, not a behavior change. These are the
    /// exact strings the old hand-rolled builders produced for node name "my-motor".
    #[tokio::test]
    async fn generate_node_output_is_byte_identical_to_hand_rolled_generator() {
        let temp = setup_project().await;
        let service = NodeGeneratorService::new();

        service.generate_node(temp.path(), "my-motor", None).await.unwrap();

        let node_dir = temp.path().join("nodes/my-motor");

        let cargo_toml = tokio::fs::read_to_string(node_dir.join("Cargo.toml")).await.unwrap();
        assert_eq!(
            cargo_toml,
            r#"[package]
name = "my-motor"
version = "0.1.0"
edition = "2021"

[lib]
name = "my_motor"
path = "src/lib.rs"

[[bin]]
name = "my-motor"
path = "src/main.rs"

[dependencies]
anyhow = "1.0"
async-trait = "0.1"
mecha10-core = "0.1"
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.40", features = ["full"] }
tracing = "0.1"
"#
        );

        let main_rs = tokio::fs::read_to_string(node_dir.join("src/main.rs")).await.unwrap();
        assert_eq!(
            main_rs,
            r#"//! my-motor Node Binary
//!
//! Runs the my-motor node as a standalone binary.

use mecha10_core::prelude::*;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    init_logging();

    // Uses auto-generated run() from #[derive(Node)]
    my_motor::run().await.map_err(|e| anyhow::anyhow!(e))
}
"#
        );

        let config_rs = tokio::fs::read_to_string(node_dir.join("src/config.rs")).await.unwrap();
        assert_eq!(
            config_rs,
            r#"//! my-motor node configuration

use mecha10_core::prelude::*;

/// MyMotor node configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MyMotorConfig {
    /// Rate at which to publish messages (Hz)
    #[serde(default = "default_rate_hz")]
    pub rate_hz: f32,
}

fn default_rate_hz() -> f32 {
    1.0
}

impl Default for MyMotorConfig {
    fn default() -> Self {
        Self {
            rate_hz: default_rate_hz(),
        }
    }
}
"#
        );

        let config_json = tokio::fs::read_to_string(temp.path().join("configs/nodes/my-motor/config.json"))
            .await
            .unwrap();
        assert_eq!(
            config_json,
            r#"{
  "dev": {
    "rate_hz": 1.0,
    "topics": {
      "publishes": [],
      "subscribes": []
    }
  },
  "production": {
    "rate_hz": 1.0,
    "topics": {
      "publishes": [],
      "subscribes": []
    }
  }
}
"#
        );
    }

    #[tokio::test]
    async fn generate_node_fails_if_node_already_exists() {
        let temp = setup_project().await;
        let service = NodeGeneratorService::new();

        service.generate_node(temp.path(), "motor", None).await.unwrap();
        let err = service.generate_node(temp.path(), "motor", None).await.unwrap_err();

        assert!(err.to_string().contains("already exists"));
    }

    #[tokio::test]
    async fn generate_node_lib_rs_uses_pascal_case_struct_name() {
        let temp = setup_project().await;
        let service = NodeGeneratorService::new();

        service.generate_node(temp.path(), "my-motor", None).await.unwrap();

        let lib_rs = tokio::fs::read_to_string(temp.path().join("nodes/my-motor/src/lib.rs"))
            .await
            .unwrap();
        assert!(lib_rs.contains("pub struct MyMotorNode"));
        assert!(lib_rs.contains("MyMotorConfig"));
        assert!(lib_rs.contains("Topic::new(\"/my-motor/hello\")"));
    }

    #[tokio::test]
    async fn generate_node_cargo_toml_uses_snake_case_lib_name() {
        let temp = setup_project().await;
        let service = NodeGeneratorService::new();

        service.generate_node(temp.path(), "my-motor", None).await.unwrap();

        let cargo_toml = tokio::fs::read_to_string(temp.path().join("nodes/my-motor/Cargo.toml"))
            .await
            .unwrap();
        assert!(cargo_toml.contains("name = \"my-motor\""));
        assert!(cargo_toml.contains("name = \"my_motor\""));
    }

    #[tokio::test]
    async fn generate_node_updates_mecha10_json_nodes_and_dev_lifecycle() {
        let temp = setup_project().await;
        let service = NodeGeneratorService::new();

        service.generate_node(temp.path(), "motor", None).await.unwrap();

        let content = tokio::fs::read_to_string(temp.path().join("mecha10.json"))
            .await
            .unwrap();
        let config: serde_json::Value = serde_json::from_str(&content).unwrap();
        assert_eq!(config["nodes"], serde_json::json!(["motor"]));
        assert_eq!(
            config["lifecycle"]["modes"]["dev"]["nodes"],
            serde_json::json!(["motor"])
        );
    }

    #[tokio::test]
    async fn generate_node_fails_if_node_already_in_mecha10_json() {
        let temp = setup_project().await;
        let mecha10_json = r#"{
  "nodes": ["motor"],
  "lifecycle": {
    "modes": {
      "dev": {
        "nodes": []
      }
    }
  }
}
"#;
        tokio::fs::write(temp.path().join("mecha10.json"), mecha10_json)
            .await
            .unwrap();

        let service = NodeGeneratorService::new();
        let err = service.generate_node(temp.path(), "motor", None).await.unwrap_err();
        assert!(err.to_string().contains("already exists in mecha10.json"));
    }

    #[tokio::test]
    async fn generate_node_updates_cargo_workspace_members() {
        let temp = setup_project().await;
        let service = NodeGeneratorService::new();

        service.generate_node(temp.path(), "motor", None).await.unwrap();

        let content = tokio::fs::read_to_string(temp.path().join("Cargo.toml")).await.unwrap();
        let doc: toml::Value = toml::from_str(&content).unwrap();
        let members = doc["workspace"]["members"].as_array().unwrap();
        assert!(members.iter().any(|m| m.as_str() == Some("nodes/motor")));
    }

    #[tokio::test]
    async fn generate_node_errors_when_mecha10_json_missing() {
        let temp = TempDir::new().unwrap();
        // No mecha10.json written.
        tokio::fs::write(temp.path().join("Cargo.toml"), "[workspace]\nmembers = []\n")
            .await
            .unwrap();

        let service = NodeGeneratorService::new();
        let err = service.generate_node(temp.path(), "motor", None).await.unwrap_err();
        assert!(err.to_string().contains("Failed to read mecha10.json"));
    }
}