implement process variable lookup via the functions processEnv or process_env or the virtuell object env

## examples
- `{{ processEnv("USER") }}`
- `{{ process_env("USER") }}`
- `{{ env.USER }}`

Signed-off-by: Sven Kanoldt <[email protected]>

Author: sassman

Cargo.lock

@@ -21,14 +21,15 @@ dialoguer = "0.10"
 filenamify = "0.1"
 chrono = { version = "0.4", default-features = false, features = ["clock"] }
 
-minijinja = "0.29"
+minijinja = "0.30"
 
 jsonwebtoken = "8.1"
 serde_json = { version = "1.0", features = ["preserve_order"] }
 
 ## experimental
 pest = { version = "2.4", optional = true }
 pest_derive = { version = "2.4", optional = true }
+minijinja-stack-ref = "0.30"
 
 [features]
 "x-http-lang" = ['dep:pest', 'dep:pest_derive']

curlz/Cargo.toml

@@ -1,29 +1,34 @@
-use minijinja::value::Value;
-use minijinja::{Error, ErrorKind, State};
-use std::env::VarError;
+use minijinja::value::{StructObject, Value};
+use minijinja::{Error, State};
 
-pub fn process_env(_state: &State, var_name: &Value) -> Result<String, Error> {
-    let var_name = var_name.as_str().ok_or_else(|| {
-        Error::new(
-            ErrorKind::MissingArgument,
-            "The argument `var_name` for function `processEnv(var_name)` is missing.",
-        )
-    })?;
+pub struct ProcessEnv;
+impl StructObject for ProcessEnv {
+    fn get_field(&self, field: &str) -> Option<Value> {
+        // std::env::var(var_name)
+        //     .map(|v| Value::from_safe_string(v))
+        //     .map_err(|e| match e {
+        //         VarError::NotPresent => Error::new(
+        //             ErrorKind::NonKey,
+        //             format!("The process env variable `{var_name}` is not defined."),
+        //         ),
+        //         VarError::NotUnicode(_) => Error::new(
+        //             ErrorKind::UndefinedError,
+        //             format!("The process env variable `{var_name}` has an invalid unicode value."),
+        //         ),
+        //     })
+        std::env::var(field).map(Value::from_safe_string).ok()
+    }
+}
 
-    std::env::var(var_name).map_err(|e| match e {
-        VarError::NotPresent => Error::new(
-            ErrorKind::NonKey,
-            format!("The process env variable `{var_name}` is not defined."),
-        ),
-        VarError::NotUnicode(_) => Error::new(
-            ErrorKind::UndefinedError,
-            format!("The process env variable `{var_name}` has an invalid unicode value."),
-        ),
-    })
+/// function for minijinja
+pub fn process_env(_: &State, var_name: &str) -> Result<Value, Error> {
+    Ok(ProcessEnv.get_field(var_name).unwrap_or_default())
 }
 
 #[cfg(test)]
 mod tests {
+    use crate::domain::environment::Environment;
+    use crate::template::Renderer;
     use crate::test_utils::RenderBuilder;
     use std::collections::HashMap;
 
@@ -51,6 +56,21 @@ mod tests {
         );
     }
 
+    #[test]
+    fn should_resolve_lazy_via_env_virtuell_object() {
+        let mut r = Renderer::new(&Environment::default());
+        #[cfg(not(windows))]
+        assert_eq!(
+            r.render(r#"{{ env.USER }}"#, "template").unwrap(),
+            std::env::var("USER").unwrap()
+        );
+        #[cfg(windows)]
+        assert_eq!(
+            r.render(r#"{{ env.USERNAME }}"#, "template").unwrap(),
+            std::env::var("USERNAME").unwrap()
+        );
+    }
+
     #[test]
     fn should_provide_process_env_var_via_env_object() {
         // TODO: this is just a toy around case

curlz/src/curlz/template/functions/process_env.rs

@@ -6,6 +6,8 @@ use functions::process_env::process_env;
 use functions::prompt::{prompt_for, prompt_password};
 
 use crate::domain::environment::Environment;
+use crate::template::functions::process_env::ProcessEnv;
+
 use minijinja::value::Value;
 use minijinja::Environment as MEnvironment;
 
@@ -31,6 +33,9 @@ impl<'source> Renderer<'source> {
         env.add_function("prompt_for", prompt_for);
         env.add_function("jwt", jwt);
 
+        // this provides lazy env var lookup
+        env.add_global("env", Value::from_struct_object(ProcessEnv));
+
         Self { env, ctx }
     }