pallet/src/app.rs

use std::{
    env::set_current_dir,
    path::{Path, PathBuf},
};

const MAIN_C: &str = include_str!("templates/main.c");

#[derive(clap::Parser)]
pub struct App {
    #[clap(subcommand)]
    command: Subcommand,
}

#[derive(clap::Subcommand)]
enum Subcommand {
    /// Create a new C project
    New {
        /// The name of the new project
        name: String,
    },
    /// Initialize a new C project
    Init,
    /// Run the local project
    Run {
        /// The build mode to use
        mode: Option<String>,
    },
    /// Build the local project
    Build {
        /// The build mode to use
        mode: Option<String>,
    },
}

impl App {
    pub fn run(self) {
        match self.command {
            Subcommand::New { name } => match create_project(&name) {
                Ok(_) => println!("Successfully created new project '{name}'."),
                Err(e) => {
                    eprintln!("Error creating project '{name}': {e}");
                    std::process::exit(1);
                }
            },
            Subcommand::Init => match create_project(".") {
                Ok(_) => println!("Successfully initialized new project."),
                Err(e) => {
                    eprintln!("Error initializing project: {e}");
                    std::process::exit(1);
                }
            },
            Subcommand::Run { mode } => todo!(),
            Subcommand::Build { mode } => todo!(),
        }
    }
}

fn create_project<P: AsRef<Path>>(directory: P) -> std::io::Result<()> {
    let pathdir = directory.as_ref();

    if pathdir.exists() && pathdir.to_string_lossy() != "." {
        return Err(std::io::Error::new(
            std::io::ErrorKind::AlreadyExists,
            "specified directory already exists",
        ));
    }

    if !pathdir.exists() && pathdir.to_string_lossy() != "." {
        std::fs::create_dir(pathdir)?;
    }

    set_current_dir(pathdir)?;

    std::fs::create_dir("src")?;

    std::fs::write("src/main.c", MAIN_C)?;

    let config = crate::config::Config::new(&pathdir.to_string_lossy());

    let serial = toml::to_string_pretty(&config).expect("a valid TOML structure");

    std::fs::write("Pallet.toml", &serial)?;

    Ok(())
}

fn get_config() -> Option<crate::config::Config> {
    let p = PathBuf::from("Pallet.toml");
    if !p.exists() {
        return None;
    }
    let raw = std::fs::read_to_string(&p).expect("A valid config file");

    toml::from_str(&raw).ok()
}

fn build(mode: Option<String>) -> std::io::Result<()> {
    let conf = match get_config() {
        Some(conf) => conf,
        None => {
            eprintln!("Error opening config file. No Pallet.toml in current directory.");
            std::process::exit(1);
        }
    };

    let build_config = conf.get_or_default(mode).ok_or(std::io::Error::new(
        std::io::ErrorKind::NotFound,
        "build layout not found",
    ))?;

    todo!()
}