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(())
}
}