special case jinja expressions and keep string type

Author: wolfv

src/recipe/custom_yaml.rs

@@ -161,6 +161,17 @@ impl Render<Node> for ScalarNode {
                 label = jinja_error_to_label(&err)
             )]
         })?;
+        println!("Rendered: {}", rendered);
+        if rendered.starts_with("\"") && rendered.ends_with("\"") {
+            // remove quotes and don't coerce string
+            let rendered = rendered[1..rendered.len() - 1].to_string();
+            println!("Rendered without quotes: {}", rendered);
+            return Ok(Node::from(ScalarNode::new(
+                *self.span(),
+                rendered,
+                false,
+            )));
+        }
 
         Ok(Node::from(ScalarNode::new(
             *self.span(),
@@ -184,6 +195,17 @@ impl Render<Option<ScalarNode>> for ScalarNode {
             )]
         })?;
 
+        // if rendered string starts with `"` and ends with `"` then remove them and turn may_coerce to false
+        if rendered.starts_with("\"") && rendered.ends_with("\"") {
+            // remove quotes and don't coerce string
+            let rendered = rendered[1..rendered.len() - 1].to_string();
+            return Ok(Some(ScalarNode::new(
+                *self.span(),
+                rendered,
+                false,
+            )));
+        }
+
         if rendered.is_empty() {
             Ok(None)
         } else {
@@ -228,6 +250,7 @@ impl Render<Node> for SequenceNode {
 
 impl Render<Node> for SequenceNodeInternal {
     fn render(&self, jinja: &Jinja, name: &str) -> Result<Node, Vec<PartialParsingError>> {
+        println!("Rendering: {:?}", self);
         match self {
             Self::Simple(n) => n.render(jinja, name),
             Self::Conditional(if_sel) => {

src/recipe/custom_yaml/rendered.rs

@@ -669,6 +669,18 @@ impl Render<RenderedNode> for ScalarNode {
                 label = jinja_error_to_label(&err),
             )]
         })?;
+
+        if rendered.starts_with("\"") && rendered.ends_with("\"") {
+            // remove quotes
+            let rendered = rendered[1..rendered.len() - 1].to_string();
+            return Ok(RenderedNode::Scalar(RenderedScalarNode::new(
+                *self.span(),
+                self.as_str().to_string(),
+                rendered,
+                false,
+            )));
+        }
+
         // unsure whether this should be allowed to coerce // check if it's quoted?
         let rendered = RenderedScalarNode::new(
             *self.span(),

src/recipe/jinja.rs

@@ -54,6 +54,11 @@ pub struct Jinja {
     context: BTreeMap<String, Value>,
 }
 
+struct ForceString {
+    value: String,
+    force: bool,
+}
+
 impl Jinja {
     /// Create a new Jinja instance with the given selector configuration.
     pub fn new(config: SelectorConfig) -> Self {
@@ -96,6 +101,22 @@ impl Jinja {
 
     /// Render a template with the current context.
     pub fn render_str(&self, template: &str) -> Result<String, minijinja::Error> {
+        if template.starts_with("${{") && template.ends_with("}}") {
+            // render as expression so that we know the type of the result, and can stringify accordingly
+            // If we find something like "${{ foo }}" then we want to evaluate it type-safely and make sure that the MiniJinja type is kept
+            println!("eval: {:?}", template);
+            let tmplt = &template[3..template.len() - 2];
+            let expr = self.env.compile_expression(tmplt)?;
+            let evaled = expr.eval(self.context())?;
+            if let Some(s) = evaled.to_str() {
+                // quote the string so that YAML is not getting confused
+                println!("evaled: {:?}", s);
+                return Ok(format!("\"{}\"", s));
+            } else {
+                return Ok(evaled.to_string());
+            }
+        }
+
         self.env.render_str(template, &self.context)
     }
 
@@ -741,7 +762,7 @@ impl Env {
         match std::env::var(env_var) {
             Ok(r) => Ok(Value::from(r)),
             Err(_) => match default_value {
-                Some(default_value) => Ok(Value::from(default_value)),
+                Some(default_value) => Ok(Value::from_safe_string(default_value)),
                 None => Err(minijinja::Error::new(
                     minijinja::ErrorKind::InvalidOperation,
                     format!("Environment variable {env_var} not found"),

src/recipe/parser.rs

@@ -182,8 +182,9 @@ impl Recipe {
 
         // add context values
         let mut context: IndexMap<String, Variable> = IndexMap::new();
-
         if let Some(context_map) = root_node.get("context") {
+            println!("Rendering context: {:#?}", context);
+
             let context_map = context_map.as_mapping().ok_or_else(|| {
                 vec![_partialerror!(
                     *context_map.span(),
@@ -234,6 +235,9 @@ impl Recipe {
                     continue;
                 };
                 context.insert(k.as_str().to_string(), variable.clone());
+
+                println!("Context variable with type: k {} {:#?}", k.as_str(), variable);
+
                 // also immediately insert into jinja context so that the value can be used
                 // in later jinja expressions
                 jinja