try some more jinja type fixes

wolfv · wolfv · commit e1ae3b74b5d6 · 2025-05-03T15:44:17.000+02:00
diff --git a/src/recipe/custom_yaml.rs b/src/recipe/custom_yaml.rs
@@ -154,29 +154,18 @@ impl Render<Node> for Node {
 
 impl Render<Node> for ScalarNode {
     fn render(&self, jinja: &Jinja, _name: &str) -> Result<Node, Vec<PartialParsingError>> {
-        let rendered = jinja.render_str(self.as_str()).map_err(|err| {
+        let (rendered, may_coerce) = jinja.render_str(self.as_str()).map_err(|err| {
             vec![_partialerror!(
                 *self.span(),
                 ErrorKind::JinjaRendering(err),
                 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(),
             rendered,
-            self.may_coerce,
+            self.may_coerce && may_coerce,
         )))
     }
 }
@@ -187,32 +176,21 @@ impl Render<Option<ScalarNode>> for ScalarNode {
         jinja: &Jinja,
         _name: &str,
     ) -> Result<std::option::Option<ScalarNode>, Vec<PartialParsingError>> {
-        let rendered = jinja.render_str(self.as_str()).map_err(|err| {
+        let (rendered, may_coerce) = jinja.render_str(self.as_str()).map_err(|err| {
             vec![_partialerror!(
                 *self.span(),
                 ErrorKind::JinjaRendering(err),
                 label = jinja_error_to_label(&err)
             )]
         })?;
 
-        // 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 {
             Ok(Some(ScalarNode::new(
                 *self.span(),
                 rendered,
-                self.may_coerce,
+                self.may_coerce && may_coerce,
             )))
         }
     }
diff --git a/src/recipe/custom_yaml/rendered.rs b/src/recipe/custom_yaml/rendered.rs
@@ -662,31 +662,20 @@ impl Render<RenderedNode> for Node {
 
 impl Render<RenderedNode> for ScalarNode {
     fn render(&self, jinja: &Jinja, _name: &str) -> Result<RenderedNode, Vec<PartialParsingError>> {
-        let rendered = jinja.render_str(self.as_str()).map_err(|err| {
+        let (rendered, may_coerce) = jinja.render_str(self.as_str()).map_err(|err| {
             vec![_partialerror!(
                 *self.span(),
                 ErrorKind::JinjaRendering(err),
                 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(),
             self.as_str().to_string(),
             rendered,
-            self.may_coerce,
+            self.may_coerce && may_coerce,
         );
 
         if rendered.is_empty() {
@@ -703,7 +692,7 @@ impl Render<Option<RenderedNode>> for ScalarNode {
         jinja: &Jinja,
         _name: &str,
     ) -> Result<Option<RenderedNode>, Vec<PartialParsingError>> {
-        let rendered = jinja.render_str(self.as_str()).map_err(|err| {
+        let (rendered, may_coerce) = jinja.render_str(self.as_str()).map_err(|err| {
             vec![_partialerror!(
                 *self.span(),
                 ErrorKind::JinjaRendering(err),
@@ -715,7 +704,7 @@ impl Render<Option<RenderedNode>> for ScalarNode {
             *self.span(),
             self.as_str().to_string(),
             rendered,
-            self.may_coerce,
+            self.may_coerce && may_coerce,
         );
 
         if rendered.is_empty() {
diff --git a/src/recipe/jinja.rs b/src/recipe/jinja.rs
@@ -54,11 +54,6 @@ 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 {
@@ -100,24 +95,23 @@ impl Jinja {
     }
 
     /// Render a template with the current context.
-    pub fn render_str(&self, template: &str) -> Result<String, minijinja::Error> {
+    pub fn render_str(&self, template: &str) -> Result<(String, bool), 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));
+                // Make sure that the string stays a string by returning can_coerce: false
+                return Ok((s.to_string(), false));
             } else {
-                return Ok(evaled.to_string());
+                return Ok((evaled.to_string(), true));
             }
         }
 
-        self.env.render_str(template, &self.context)
+        let rendered = self.env.render_str(template, &self.context)?;
+        Ok((rendered, !template.contains("${{")))
     }
 
     /// Render, compile and evaluate a expr string with the current context.
diff --git a/src/recipe/parser.rs b/src/recipe/parser.rs
@@ -183,8 +183,6 @@ 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(),
@@ -236,8 +234,6 @@ impl Recipe {
                 };
                 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
diff --git a/src/recipe/parser/build.rs b/src/recipe/parser/build.rs
@@ -172,7 +172,7 @@ impl BuildString {
     pub fn resolve(&self, hash: &HashInfo, build_number: u64, jinja: &Jinja) -> Cow<'_, str> {
         match self {
             // TODO
-            BuildString::UserSpecified(template) => jinja.render_str(template).unwrap().into(),
+            BuildString::UserSpecified(template) => jinja.render_str(template).unwrap().0.into(),
             BuildString::Resolved(s) => s.as_str().into(),
             BuildString::Derived => Self::compute(hash, build_number).into(),
         }
diff --git a/src/script/mod.rs b/src/script/mod.rs
@@ -219,7 +219,7 @@ impl Script {
         if let Some(jinja_context) = jinja_context {
             match script_content? {
                 ResolvedScriptContents::Inline(script) => {
-                    let rendered = jinja_context.render_str(&script).map_err(|e| {
+                    let (rendered, _) = jinja_context.render_str(&script).map_err(|e| {
                         std::io::Error::new(
                             std::io::ErrorKind::Other,
                             format!("Failed to render jinja template in build `script`: {}", e),

Original file line number	Diff line number	Diff line change
`@@ -172,7 +172,7 @@ impl BuildString {`
`172`	`172`	`pub fn resolve(&self, hash: &HashInfo, build_number: u64, jinja: &Jinja) -> Cow<'_, str> {`
`173`	`173`	`match self {`
`174`	`174`	`// TODO`
`175`		`- BuildString::UserSpecified(template) => jinja.render_str(template).unwrap().into(),`
	`175`	`+ BuildString::UserSpecified(template) => jinja.render_str(template).unwrap().0.into(),`
`176`	`176`	`BuildString::Resolved(s) => s.as_str().into(),`
`177`	`177`	`BuildString::Derived => Self::compute(hash, build_number).into(),`
`178`	`178`	`}`