Add regular expression to extract error position from liquid

Signed-off-by: Ryan Bottriell <[email protected]>

Author: rydrman

Cargo.lock

@@ -8,8 +8,10 @@ version = "0.36.0"
 migration-to-components = ["spk-schema-foundation/migration-to-components"]
 
 [dependencies]
+lazy_static = "1.4"
 liquid = "0.26.0"
 liquid-core = "0.26.0"
+format_serde_error = {version = "0.3", default_features = false, features = ["colored"]}
 regex = "1.6.0"
 serde = "1.0"
 serde_json = "1.0"

crates/spk-schema/crates/liquid/Cargo.toml

@@ -0,0 +1,52 @@
+use std::error::Error;
+
+use lazy_static::lazy_static;
+use regex::Regex;
+
+#[cfg(test)]
+#[path = "./error_test.rs"]
+mod error_test;
+
+#[derive(Debug)]
+struct ParsedError {
+    message: String,
+}
+
+impl std::fmt::Display for ParsedError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.message)
+    }
+}
+
+impl Error for ParsedError {}
+
+pub fn to_error_types(err: liquid::Error) -> format_serde_error::ErrorTypes {
+    lazy_static! {
+        static ref RE: Regex = Regex::new(r"(?ms)liquid:  --> (\d+):(\d+)\n.*^\s+= (.*)")
+            .expect("a valid regular expression");
+    }
+    let mut message = err.to_string();
+    let mut line = Option::<usize>::None;
+    let mut column = Option::<usize>::None;
+    if let Some(m) = RE.captures(&message) {
+        line = m.get(1).and_then(|line| line.as_str().parse().ok());
+        column = m
+            .get(2)
+            .and_then(|column| column.as_str().parse().ok())
+            // format_serde_error appears to use 0-based index for columns
+            // whereas the liquid crates uses a 1-based index
+            .map(|col: usize| col - 1);
+        message = m
+            .get(3)
+            .map(|msg| msg.as_str())
+            .unwrap_or("Invalid Template")
+            .trim()
+            .to_string();
+    }
+    let error = Box::new(ParsedError { message });
+    format_serde_error::ErrorTypes::Custom {
+        error,
+        line,
+        column,
+    }
+}

crates/spk-schema/crates/liquid/src/error.rs

@@ -0,0 +1,19 @@
+use rstest::rstest;
+use serde_json::json;
+
+#[rstest]
+fn test_error_position_extraction() {
+    // ensure that the source position of an error can be
+    // properly extracted and used for the returned serde_format_error
+
+    format_serde_error::never_color();
+    static TPL: &str = r#"{% default = data | replace ''%}"#;
+    let err =
+        crate::render_template(TPL, &json!({})).expect_err("expected template render to fail");
+    let expected = r#"
+ 1 | {% default = data | replace ''%}
+   |            ^ unexpected "="; expected Identifier
+"#;
+    let message = err.to_string();
+    assert_eq!(message, expected);
+}

crates/spk-schema/crates/liquid/src/error_test.rs

@@ -3,12 +3,13 @@
 // https://github.com/imageworks/spk
 //! Defines the default configuration for processing spec file templates in spk
 
+mod error;
 mod filter_compare_version;
 mod filter_parse_version;
 mod filter_replace_regex;
 mod tag_default;
 
-pub use liquid::Error;
+pub use format_serde_error::SerdeError as Error;
 
 /// Build the default template parser for spk
 ///
@@ -27,13 +28,16 @@ pub fn default_parser() -> liquid::Parser {
 }
 
 /// Render a template with the default configuration
-pub fn render_template<T, D>(tpl: T, data: &D) -> Result<String, liquid::Error>
+pub fn render_template<T, D>(tpl: T, data: &D) -> Result<String, Error>
 where
     T: AsRef<str>,
     D: serde::Serialize,
 {
+    let tpl = tpl.as_ref();
+    let map_err =
+        |err| format_serde_error::SerdeError::new(tpl.to_string(), error::to_error_types(err));
     let parser = default_parser();
-    let template = parser.parse(tpl.as_ref())?;
-    let globals = liquid::to_object(data)?;
-    template.render(&globals)
+    let template = parser.parse(tpl).map_err(map_err)?;
+    let globals = liquid::to_object(data).map_err(map_err)?;
+    template.render(&globals).map_err(map_err)
 }

crates/spk-schema/crates/liquid/src/lib.rs

@@ -46,7 +46,7 @@ pub enum Error {
     #[error(transparent)]
     InvalidYaml(#[from] format_serde_error::SerdeError),
     #[error(transparent)]
-    InvalidTemplate(spk_schema_liquid::Error),
+    InvalidTemplate(format_serde_error::SerdeError),
 }
 
 impl Error {