Issue/#5 (#6)

Author: Heiko Alexander Weber

src/check_features.rs

@@ -0,0 +1,3 @@
+#[cfg(not(feature = "backend+cli"))]
+#[cfg(not(feature = "backend+ui"))]
+extern crate DO_NOT_COMPILE_WITHOUT_ANY_ENABLED_BACKEND;

src/config/mod.rs

@@ -8,7 +8,7 @@ pub struct Config {
 #[serde(rename_all = "snake_case")]
 pub struct Template {
     pub content: Content,
-    pub values: std::collections::BTreeMap<String, ValueDefinition>,
+    pub values: std::collections::BTreeMap<String, VariableDefinition>,
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
@@ -20,7 +20,7 @@ pub enum Content {
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
-pub enum ValueDefinition {
+pub enum VariableDefinition {
     Static(String),
     Prompt(String),
     Shell(String),

src/main.rs

@@ -1,117 +1,12 @@
-#[cfg(not(feature = "backend+cli"))]
-#[cfg(not(feature = "backend+ui"))]
-extern crate DO_NOT_COMPILE_WITHOUT_ANY_ENABLED_BACKEND;
-
-extern crate clap;
-#[cfg(feature = "backend+ui")]
-extern crate cursive;
-#[cfg(feature = "backend+cli")]
-extern crate dialoguer;
-#[cfg(feature = "backend+ui")]
-extern crate fui;
-extern crate handlebars;
-extern crate serde;
-extern crate serde_json;
-extern crate serde_yaml;
+include!("check_features.rs");
 
 use futures::executor::block_on;
-use std::collections::BTreeMap;
+
 use std::io::{Result, Write};
 
 pub mod args;
-use args::{Backend, ShellTrust};
 pub mod config;
-use config::{Config, Content, Template};
-pub mod print;
-use print::Print;
-
-#[allow(clippy::needless_lifetimes)]
-async fn select_template<'a>(config: &'a Config, backend: &Backend) -> Result<&'a Template> {
-    let keys: Vec<String> = config.templates.keys().map(|t| t.to_owned()).collect();
-
-    let be = backend.to_input()?;
-    let selection = be.select("", keys.as_slice()).await?;
-
-    match config.templates.get(&selection) {
-        Some(x) => Ok(x),
-        None => Err(std::io::Error::new(std::io::ErrorKind::Other, "failed")),
-    }
-}
-
-async fn get_values(
-    template: &Template,
-    shell_trust: &ShellTrust,
-    backend: &Backend,
-) -> Result<BTreeMap<String, String>> {
-    let mut values = BTreeMap::new();
-    for value in &template.values {
-        values.insert(
-            value.0.to_owned(),
-            value.1.execute(shell_trust, backend).await?,
-        );
-    }
-    Ok(values)
-}
-
-async fn replace(template: &str, values: &BTreeMap<String, String>) -> Result<String> {
-    fn recursive_add(
-        namespace: &mut std::collections::VecDeque<String>,
-        parent: &mut serde_json::Value,
-        value: &str,
-    ) {
-        let current_namespace = namespace.pop_front().unwrap();
-        match namespace.len() {
-            0 => {
-                parent
-                    .as_object_mut()
-                    .unwrap()
-                    .entry(&current_namespace)
-                    .or_insert(serde_json::Value::String(value.to_owned()));
-            }
-            _ => {
-                let p = parent
-                    .as_object_mut()
-                    .unwrap()
-                    .entry(&current_namespace)
-                    .or_insert(serde_json::Value::Object(serde_json::Map::new()));
-                recursive_add(namespace, p, value);
-            }
-        }
-    }
-
-    let mut hb = handlebars::Handlebars::new();
-    hb.set_strict_mode(true);
-
-    let mut values_json = serde_json::Value::Object(serde_json::Map::new());
-    for val in values {
-        let namespaces_vec: Vec<String> = val.0.split('.').map(|s| s.to_string()).collect();
-        let mut namespaces = std::collections::VecDeque::from(namespaces_vec);
-        recursive_add(&mut namespaces, &mut values_json, val.1);
-    }
-
-    let rendered_template = hb.render_template(template, &values_json).unwrap();
-    Ok(rendered_template)
-}
-
-async fn print(invoke_options: args::PrintArguments) -> Result<()> {
-    let cfg: Config = serde_yaml::from_str(&invoke_options.configuration).unwrap();
-
-    let template = select_template(&cfg, &invoke_options.backend).await?;
-    let template_str = match &template.content {
-        Content::Inline(x) => x.to_owned(),
-        Content::File(x) => std::fs::read_to_string(x)?,
-    };
-    let values = get_values(
-        &template,
-        &invoke_options.shell_trust,
-        &invoke_options.backend,
-    )
-    .await?;
-    let rendered = replace(&template_str, &values).await?;
-
-    std::io::stdout().write_all(rendered.as_bytes())?;
-    Ok(())
-}
+pub mod render;
 
 async fn default_config() -> String {
     r###"version: 0.6
@@ -165,7 +60,10 @@ async fn async_main() -> Result<()> {
             std::fs::write("./.complate/config.yml", default_config().await)?;
             Ok(())
         }
-        crate::args::Command::Print(x) => print(x).await,
+        crate::args::Command::Print(x) => {
+            std::io::stdout().write_all(crate::render::select_and_render(x).await?.as_bytes())?;
+            Ok(())
+        }
     }
 }
 

src/print/mod.rs src/render/mod.rssrc/print/mod.rs renamed to src/render/mod.rs

@@ -1,10 +1,93 @@
 use crate::args::{Backend, ShellTrust};
-use crate::config::ValueDefinition;
+use crate::config::{Config, Content, Template, VariableDefinition};
 use async_trait::async_trait;
+use std::collections::BTreeMap;
 use std::io::{Error, ErrorKind, Result};
 
+pub async fn render(template: &str, values: &BTreeMap<String, String>) -> Result<String> {
+    fn recursive_add(
+        namespace: &mut std::collections::VecDeque<String>,
+        parent: &mut serde_json::Value,
+        value: &str,
+    ) {
+        let current_namespace = namespace.pop_front().unwrap();
+        match namespace.len() {
+            0 => {
+                parent
+                    .as_object_mut()
+                    .unwrap()
+                    .entry(&current_namespace)
+                    .or_insert(serde_json::Value::String(value.to_owned()));
+            }
+            _ => {
+                let p = parent
+                    .as_object_mut()
+                    .unwrap()
+                    .entry(&current_namespace)
+                    .or_insert(serde_json::Value::Object(serde_json::Map::new()));
+                recursive_add(namespace, p, value);
+            }
+        }
+    }
+
+    let mut hb = handlebars::Handlebars::new();
+    hb.set_strict_mode(true);
+
+    let mut values_json = serde_json::Value::Object(serde_json::Map::new());
+    for val in values {
+        let namespaces_vec: Vec<String> = val.0.split('.').map(|s| s.to_string()).collect();
+        let mut namespaces = std::collections::VecDeque::from(namespaces_vec);
+        recursive_add(&mut namespaces, &mut values_json, val.1);
+    }
+
+    let rendered_template = hb.render_template(template, &values_json).unwrap();
+    Ok(rendered_template)
+}
+
+#[allow(clippy::needless_lifetimes)]
+pub async fn select_template<'a>(config: &'a Config, backend: &Backend) -> Result<&'a Template> {
+    let keys: Vec<String> = config.templates.keys().map(|t| t.to_owned()).collect();
+
+    let be = backend.to_input()?;
+    let selection = be.select("", keys.as_slice()).await?;
+
+    match config.templates.get(&selection) {
+        Some(x) => Ok(x),
+        None => Err(std::io::Error::new(std::io::ErrorKind::Other, "failed")),
+    }
+}
+
+pub async fn populate_variables(
+    vars: &std::collections::BTreeMap<String, VariableDefinition>,
+    shell_trust: &ShellTrust,
+    backend: &Backend,
+) -> Result<BTreeMap<String, String>> {
+    let mut values = BTreeMap::new();
+    for var in vars {
+        values.insert(var.0.to_owned(), var.1.execute(shell_trust, backend).await?);
+    }
+    Ok(values)
+}
+
+pub async fn select_and_render(invoke_options: crate::args::PrintArguments) -> Result<String> {
+    let cfg: Config = serde_yaml::from_str(&invoke_options.configuration).unwrap();
+
+    let template = select_template(&cfg, &invoke_options.backend).await?;
+    let template_str = match &template.content {
+        Content::Inline(x) => x.to_owned(),
+        Content::File(x) => std::fs::read_to_string(x)?,
+    };
+    let values = populate_variables(
+        &template.values,
+        &invoke_options.shell_trust,
+        &invoke_options.backend,
+    )
+    .await?;
+    render(&template_str, &values).await
+}
+
 #[async_trait]
-pub trait Print {
+pub trait Resolve {
     async fn execute(&self, shell_trust: &ShellTrust, backend: &Backend) -> Result<String>;
 }
 
@@ -28,16 +111,18 @@ impl Backend {
 }
 
 #[async_trait]
-impl Print for ValueDefinition {
+impl Resolve for VariableDefinition {
     async fn execute(&self, shell_trust: &ShellTrust, backend: &Backend) -> Result<String> {
         let backend_impl = backend.to_input()?;
 
         match self {
-            ValueDefinition::Static(v) => Ok(v.to_owned()),
-            ValueDefinition::Prompt(v) => backend_impl.prompt(v).await,
-            ValueDefinition::Shell(cmd) => backend_impl.shell(cmd, shell_trust).await,
-            ValueDefinition::Select { text, options } => backend_impl.select(text, options).await,
-            ValueDefinition::Check { text, options } => backend_impl.check(text, options).await,
+            VariableDefinition::Static(v) => Ok(v.to_owned()),
+            VariableDefinition::Prompt(v) => backend_impl.prompt(v).await,
+            VariableDefinition::Shell(cmd) => backend_impl.shell(cmd, shell_trust).await,
+            VariableDefinition::Select { text, options } => {
+                backend_impl.select(text, options).await
+            }
+            VariableDefinition::Check { text, options } => backend_impl.check(text, options).await,
         }
     }
 }