lyrs/src/templates.rs

use crate::{file_watcher::prelude::*, prelude::*};
use minijinja::Environment;
use pathdiff::diff_paths;
use std::{path::PathBuf, sync::Arc};
use tokio::sync::Mutex;
use tower_livereload::Reloader;
use tracing::{info, instrument};

#[derive(Clone, Debug)]
pub struct Templates {
    env: Arc<Mutex<Environment<'static>>>,
    dir: PathBuf,
}

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> {
        let result = Self::for_dir(dir);
        result.load_env().await?;
        Ok(result)
    }

    pub async fn start_watcher(
        self: Arc<Self>,
        reloader: Option<Reloader>,
    ) -> Result<Option<FileWatcher>> {
        if let Some(rl) = reloader {
            Ok(Some(self.watch(rl).await?))
        } else {
            Ok(None)
        }
    }

    async fn watch(self: Arc<Self>, reloader: Reloader) -> Result<FileWatcher> {
        // TODO: only reload template that changed?
        let watcher = file_monitor(self.dir.clone(), move || {
            futures::executor::block_on(async {
                self.load_env()
                    .await
                    .expect("Failed to reload templates after template changed during runtime");
                reloader.reload();
            });
        })?;
        Ok(watcher)
    }

    #[instrument]
    pub async fn load_env(&self) -> Result<()> {
        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!(),
            }
        }
        Ok(())
    }

    pub async fn render<S: serde::ser::Serialize>(
        &self,
        template_name: &str,
        context: S,
    ) -> Result<String> {
        Ok(self
            .env
            .lock()
            .await
            .get_template(template_name)?
            .render(context)?)
    }
}