pegase 0.1.0

cli to generate secret tree files from templates
Documentation
use garde::Validate;
use serde::{Deserialize, Serialize};

use crate::{
    generators::{GenerateSecret, GenerationError, Secret},
    internal::{garde::all_unique, secrets::pass::generate_pass},
};

#[derive(Debug, Serialize, Deserialize, Clone, Validate)]
#[serde(rename_all = "snake_case")]
pub enum PassSize {
    Length(#[garde(range(min = 1))] u32),
    AtLeastBits(#[garde(range(min = 1))] u32),
}

impl Default for PassSize {
    fn default() -> Self {
        Self::Length(40)
    }
}

#[derive(Debug, Serialize, Deserialize, Default, Clone, Validate)]
#[serde(rename_all = "snake_case")]
pub enum PassCharset {
    Num,
    Hex,
    #[default]
    AlNum,
    Rfc3986,
    AlNumSpec,
    Custom(#[garde(length(min = 2), custom(all_unique))] String),
}

impl PassCharset {
    pub fn charset(&self) -> &[u8] {
        match self {
            PassCharset::Num => b"0123456789",
            PassCharset::Hex => b"0123456789ABCDEF",
            PassCharset::AlNum => b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
            PassCharset::Rfc3986 => b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~",
            PassCharset::AlNumSpec => {
                b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
            }
            PassCharset::Custom(value) => value.as_bytes(),
        }
    }
}

#[derive(Debug, Serialize, Deserialize, Default, Clone, Validate)]
#[serde(deny_unknown_fields)]
pub struct PassSecretGeneratorConfig {
    #[serde(flatten)]
    #[garde(dive)]
    pub size: Option<PassSize>,
    #[garde(dive)]
    pub charset: Option<PassCharset>,
}

#[derive(Debug, Serialize, Deserialize, Clone, Default, Validate)]
#[serde(transparent)]
pub struct PassSecretGenerator {
    #[garde(dive)]
    pub config: PassSecretGeneratorConfig,
}

impl GenerateSecret for PassSecretGenerator {
    fn generate(&self) -> Result<Secret, GenerationError> {
        let config = self.config.clone();

        config.validate()?;

        let pass_charset = config.charset.unwrap_or_default();
        let charset = pass_charset.charset();

        let char_len = match config.size.unwrap_or_default() {
            PassSize::Length(length) => length,
            PassSize::AtLeastBits(bits) => {
                (bits as f64 * f64::log(2.0, charset.len() as f64)).ceil() as u32
            }
        };

        Ok(Secret::Sym(generate_pass(char_len, charset)?))
    }
}