Addd flag to list used template variables

manager/src/peeker.rs

@@ -0,0 +1,98 @@
+use crate::builder::TEMPLATE_EXTENSION;
+use crate::error::{Error, ErrorLocation, Errors};
+use crate::Config;
+use async_recursion::async_recursion;
+use blueprint::parse_template;
+use futures::future::join_all;
+use std::ffi::OsStr;
+use std::path::PathBuf;
+use tokio::fs::{read_dir, read_to_string};
+use tokio::join;
+
+pub async fn peek_tree(cfg: &Config) -> Result<(), Errors> {
+    for var in dir(cfg, PathBuf::new()).await? {
+        println!("{}", var);
+    }
+
+    Ok(())
+}
+
+#[async_recursion]
+async fn dir(cfg: &Config, relative: PathBuf) -> Result<Vec<String>, Errors> {
+    let template_path = cfg.template_dir.join(&relative);
+
+    info!("traversing {:?}", template_path);
+
+    let mut walker = read_dir(&template_path)
+        .await
+        .with_location(&template_path)?;
+
+    let mut dir_tasks = vec![];
+    let mut file_tasks = vec![];
+
+    while let Some(entry) = walker.next_entry().await.with_location(&&template_path)? {
+        let meta = entry.metadata().await.with_location(&entry.path())?;
+        let new_relative = relative.join(entry.file_name());
+
+        if meta.is_dir() {
+            dir_tasks.push(dir(cfg, new_relative));
+        } else if meta.is_file() {
+            file_tasks.push(file(cfg, new_relative));
+        }
+    }
+
+    let dirs = async { join_all(dir_tasks).await.into_iter().collect::<Vec<_>>() };
+    let files = async { join_all(file_tasks).await.into_iter().collect::<Vec<_>>() };
+    let (dirs, files) = join!(dirs, files);
+
+    let mut vars = vec![];
+    let mut errors = vec![];
+
+    for result in files.into_iter() {
+        match result {
+            Ok(mut more_vars) => vars.append(&mut more_vars),
+            Err(error) => errors.push(error),
+        }
+    }
+
+    let mut errors: Errors = errors.into();
+
+    for result in dirs.into_iter() {
+        match result {
+            Ok(mut more_vars) => vars.append(&mut more_vars),
+            Err(error) => errors.join(error),
+        }
+    }
+
+    if errors.is_empty() {
+        vars.sort_unstable();
+        vars.dedup();
+        Ok(vars)
+    } else {
+        Err(errors)
+    }
+}
+
+async fn file(cfg: &Config, relative: PathBuf) -> Result<Vec<String>, Error> {
+    let template_path = cfg.template_dir.join(&relative);
+
+    if template_path.extension() != Some(OsStr::new(TEMPLATE_EXTENSION)) {
+        return Ok(vec![]);
+    }
+
+    debug!("reading {:?}", template_path);
+
+    // parse template
+    let file_str = read_to_string(&template_path)
+        .await
+        .with_location(&template_path)?;
+
+    let vars = parse_template(&file_str)
+        .with_location(&template_path)?
+        .list_variables()
+        .into_iter()
+        .map(|s| s.to_string())
+        .collect();
+
+    Ok(vars)
+}