pegase 0.1.0

cli to generate secret tree files from templates
Documentation
use std::{error::Error, fmt::Display, fs::create_dir_all, path::Path};

use garde::Validate;
use serde::{Deserialize, Serialize};

use crate::{generators::GenerationError, template::file_template::FileTemplate};

mod file_template;
mod generator_tree;

#[derive(Debug, Serialize, Deserialize, Validate)]
#[serde(deny_unknown_fields)]
pub struct Template {
    #[garde(dive)]
    pub files: Vec<FileTemplate>,
}

#[derive(Debug)]
pub enum TemplateError {
    IOError(std::io::Error),
    DeserializeError(serde_saphyr::Error),
}

impl From<std::io::Error> for TemplateError {
    fn from(err: std::io::Error) -> Self {
        TemplateError::IOError(err)
    }
}

impl From<serde_saphyr::Error> for TemplateError {
    fn from(err: serde_saphyr::Error) -> Self {
        TemplateError::DeserializeError(err)
    }
}

impl Display for TemplateError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TemplateError::IOError(err) => write!(f, "IO error: {}", err),
            TemplateError::DeserializeError(err) => write!(f, "Deserialize error: {}", err),
        }
    }
}

impl Error for TemplateError {}

#[derive(Debug)]
pub enum TemplateGenerationError {
    IOError(std::io::Error),
    SerializeError(serde_saphyr::ser::Error),
    GenerationError(GenerationError),
}

impl From<std::io::Error> for TemplateGenerationError {
    fn from(err: std::io::Error) -> Self {
        TemplateGenerationError::IOError(err)
    }
}

impl From<serde_saphyr::ser::Error> for TemplateGenerationError {
    fn from(err: serde_saphyr::ser::Error) -> Self {
        TemplateGenerationError::SerializeError(err)
    }
}

impl From<GenerationError> for TemplateGenerationError {
    fn from(err: GenerationError) -> Self {
        TemplateGenerationError::GenerationError(err)
    }
}

impl Display for TemplateGenerationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TemplateGenerationError::IOError(err) => write!(f, "IO error: {}", err),
            TemplateGenerationError::SerializeError(err) => write!(f, "Serialize error: {}", err),
            TemplateGenerationError::GenerationError(err) => write!(f, "Generation error: {}", err),
        }
    }
}

impl Error for TemplateGenerationError {}

impl Template {
    pub fn from_file(file: &Path) -> Result<Self, TemplateError> {
        let file = std::fs::File::open(file)?;

        Ok(serde_saphyr::from_reader_valid(file)?)
    }

    pub fn generate_files(&self) -> Result<(), TemplateGenerationError> {
        for file_template in &self.files {
            create_dir_all(
                file_template
                    .path
                    .parent()
                    .unwrap_or_else(|| std::path::Path::new(".")),
            )?;
            let mut file = std::fs::File::create(file_template.path.clone())?;

            let secret_tree = file_template.generate()?;

            serde_saphyr::to_io_writer(&mut file, &secret_tree)?;
        }

        Ok(())
    }
}