Struct Seed 

pub struct Seed<'a> { /* private fields */ }

A Seed is responsible for parsing the template string, loading the values, and optionally making the replacements via the germinate method

Implementations

impl<'a> Seed<'a>

pub fn new(template: &'a str) -> Self

Create a new Seed with the given template string

pub fn add_custom_loader(&mut self, key: String, loader: Box<dyn Loader>)

Adds a custom loader to allow users of the library to add their own value sources

Example

use germinate::{Seed, Loader};

struct LanguageLoader {}

#[async_trait::async_trait]
impl Loader for LanguageLoader {
    async fn load(&self, key: &str) -> anyhow::Result<String> {
        // Add your logic for loading the value here

        Ok(match key {
            "go" => String::from("Go"),
            _ => String::from("Rust"),
        })
    }
}

#[tokio::main]
async fn main() {
    std::env::set_var("NAME", "John");

    let mut seed = Seed::new("Hi %env:NAME%, Welcome to %language:rust%! Say goodbye to %language:go%...");
    seed.add_custom_loader("language".into(), Box::new(LanguageLoader{}));
    let output = seed.germinate().await.unwrap();

    assert_eq!(String::from("Hi John, Welcome to Rust! Say goodbye to Go..."), output);
}

pub async fn parse(&mut self) -> Result<HashMap<String, String>>

Parses the template string and generates a HashMap of key value replacements, loading the value for each replacement as it goes. If it finds a template string with a custom source without a related loader, it will return an error. It will also return an error if a value fails to load

Examples

#[tokio::main]
async fn main() {
    std::env::set_var("NAME", "John");

    let mut seed = germinate::Seed::new("Hi %env:NAME%, Welcome to Rust!");
    let replacements = seed.parse().await.unwrap();

    assert_eq!(replacements.get("%env:NAME%").unwrap(), &String::from("John"));
}

pub async fn germinate(&mut self) -> Result<String>

The germinate is a wrapper around the parse function which follows up by actually making the replacements in the template string and returning the result.

Examples

#[tokio::main]
async fn main() {
    std::env::set_var("NAME", "John");

    let mut seed = germinate::Seed::new("Hi %env:NAME%, Welcome to Rust!");
    let output = seed.germinate().await.unwrap();

    assert_eq!(String::from("Hi John, Welcome to Rust!"), output);
}