103 lines
3 KiB
Rust
103 lines
3 KiB
Rust
use std::{path::PathBuf, sync::Arc};
|
|
|
|
use minijinja::Environment;
|
|
use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
|
|
use pathdiff::diff_paths;
|
|
use tokio::sync::{mpsc::channel, Mutex};
|
|
use tower_livereload::Reloader;
|
|
use tracing::{error, info};
|
|
|
|
use crate::{file_watcher::file_watcher, Besult};
|
|
|
|
#[derive(Clone)]
|
|
pub struct Templates {
|
|
env: Arc<Mutex<Environment<'static>>>,
|
|
dir: PathBuf,
|
|
}
|
|
|
|
pub type Error = Box<dyn std::error::Error>;
|
|
|
|
impl Templates {
|
|
pub fn for_dir<P: Into<PathBuf>>(dir: P) -> Self {
|
|
let env = Arc::new(Mutex::new(Environment::new()));
|
|
Self {
|
|
env,
|
|
dir: dir.into(),
|
|
}
|
|
}
|
|
|
|
pub async fn try_load<P: Into<PathBuf>>(dir: P) -> Result<Self, Error> {
|
|
let result = Self::for_dir(dir);
|
|
result.load_env().await?;
|
|
Ok(result)
|
|
}
|
|
|
|
pub async fn start_watcher(
|
|
self: Arc<Self>,
|
|
reloader: Option<Reloader>,
|
|
) -> Besult<Option<RecommendedWatcher>> {
|
|
if let Some(rl) = reloader {
|
|
Ok(Some(self.watch(rl).await?))
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
async fn watch(self: Arc<Self>, reloader: Reloader) -> Besult<RecommendedWatcher> {
|
|
let (tx, mut rx) = channel(1);
|
|
let watcher = file_watcher(self.dir.clone(), move |ev| {
|
|
info!("Template File Watcher Event: {ev:#?}");
|
|
match tx.blocking_send(ev) {
|
|
Ok(_) => {}
|
|
Err(err) => error!("Error sending template file watcher event: {err}"),
|
|
};
|
|
})?;
|
|
let us = self.clone();
|
|
tokio::spawn(async move {
|
|
while let Some(_) = rx.recv().await {
|
|
us.load_env()
|
|
.await
|
|
.expect("Failed to reload templates after template changed during runtime");
|
|
reloader.reload()
|
|
}
|
|
});
|
|
Ok(watcher)
|
|
}
|
|
|
|
pub async fn load_env(&self) -> Result<(), Error> {
|
|
info!("Loading templates...");
|
|
for d in walkdir::WalkDir::new(&self.dir) {
|
|
match d {
|
|
Ok(d) => {
|
|
if d.file_type().is_dir() {
|
|
continue;
|
|
}
|
|
let filename: String = diff_paths(d.path(), "src/templates")
|
|
.unwrap()
|
|
.to_string_lossy()
|
|
.into_owned();
|
|
info!("Loading template {filename:#?} ({d:#?})");
|
|
self.env
|
|
.lock()
|
|
.await
|
|
.add_template_owned(filename, std::fs::read_to_string(d.path())?)?;
|
|
}
|
|
Err(_) => todo!(),
|
|
}
|
|
}
|
|
info!("Done loading templates!");
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn render<S: serde::ser::Serialize>(
|
|
&self,
|
|
template_name: &str,
|
|
context: S,
|
|
) -> Result<String, minijinja::Error> {
|
|
self.env
|
|
.lock()
|
|
.await
|
|
.get_template(template_name)?
|
|
.render(context)
|
|
}
|
|
}
|