xert 0.2.0

A professional Rust project scaffolding tool for Web, CLI, and Embedded projects.
Documentation
use crate::deps;
use crate::templates;
use crate::Template;
use anyhow::{Context, Result};
use std::fs;
use std::io::Write;
use std::path::Path;

pub trait ProgressHandler {
    fn start_phase(&self, phase: &str);
    fn finish_phase(&self, phase: &str);
}

pub async fn create_project<P: ProgressHandler>(
    template: &Template,
    name: &str,
    handler: &P,
) -> Result<()> {
    let path = Path::new(name);
    if path.exists() {
        anyhow::bail!(
            "Directory '{}' already exists. Please choose a different name.",
            name
        );
    }

    // Resolve Dependencies
    handler.start_phase(&format!("Resolving latest dependencies for {}...", name));

    let crates_to_fetch = match template {
        Template::Web => vec![
            "axum",
            "tokio",
            "tracing",
            "tracing-subscriber",
            "serde",
            "serde_json",
            "dotenvy",
        ],
        Template::Cli => vec!["clap", "anyhow", "colored"],
        Template::Embedded => vec!["cortex-m", "cortex-m-rt", "panic-halt"],
    };

    let versions = deps::resolve_dependencies(&crates_to_fetch).await;
    handler.finish_phase("Dependencies resolved.");

    // Create Project Structure
    handler.start_phase("Scaffolding project structure...");

    fs::create_dir(path).context("Failed to initialize project directory")?;

    match template {
        Template::Web => {
            write_file_silent(
                path,
                "Cargo.toml",
                &templates::web::cargo_toml(name, &versions),
            )?;
            fs::create_dir(path.join("src"))?;
            write_file_silent(path, "src/main.rs", templates::web::MAIN_RS)?;
        }
        Template::Cli => {
            write_file_silent(
                path,
                "Cargo.toml",
                &templates::cli::cargo_toml(name, &versions),
            )?;
            fs::create_dir(path.join("src"))?;
            write_file_silent(path, "src/main.rs", templates::cli::MAIN_RS)?;
        }
        Template::Embedded => {
            write_file_silent(
                path,
                "Cargo.toml",
                &templates::embedded::cargo_toml(name, &versions),
            )?;
            fs::create_dir(path.join("src"))?;
            write_file_silent(path, "src/main.rs", templates::embedded::MAIN_RS)?;
        }
    }

    add_security_audit(path)?;

    handler.finish_phase("Project scaffolded.");

    Ok(())
}

fn write_file_silent(path: &Path, filename: &str, content: &str) -> Result<()> {
    let file_path = path.join(filename);
    let mut file =
        fs::File::create(&file_path).context(format!("Failed to create {}", filename))?;
    file.write_all(content.as_bytes())?;
    Ok(())
}

fn add_security_audit(path: &Path) -> Result<()> {
    let workflows_dir = path.join(".github").join("workflows");
    fs::create_dir_all(&workflows_dir)?;
    write_file_silent(&workflows_dir, "audit.yml", templates::security::AUDIT_YAML)?;
    Ok(())
}