pegase 0.1.0

cli to generate secret tree files from templates
Documentation
use std::fmt::Display;

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

pub mod pass;

#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Secret {
    Sym(String),
    Asym { public: String, private: String },
    Hash { plain: String, hash: String },
}

#[derive(Debug)]
pub enum GenerationError {
    RngError(rand::rngs::SysError),
    InvalidConfig(garde::error::Report),
}

impl From<rand::rngs::SysError> for GenerationError {
    fn from(err: rand::rngs::SysError) -> Self {
        GenerationError::RngError(err)
    }
}

impl From<garde::error::Report> for GenerationError {
    fn from(err: garde::error::Report) -> Self {
        GenerationError::InvalidConfig(err)
    }
}

impl Display for GenerationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            GenerationError::RngError(err) => write!(f, "RNG error: {}", err),
            GenerationError::InvalidConfig(err) => write!(f, "Invalid config: {}", err),
        }
    }
}

impl std::error::Error for GenerationError {}

#[enum_dispatch(SecretGenerator)]
pub trait GenerateSecret {
    fn generate(&self) -> Result<Secret, GenerationError>;
}

#[enum_dispatch]
#[derive(Debug, Serialize, Deserialize, Validate)]
#[serde(rename_all = "snake_case")]
#[serde(tag = "generator")]
pub enum SecretGenerator {
    Pass(#[garde(dive)] pass::PassSecretGenerator),
}