feat: improving error display

Author: SilentVoid13

src/error.rs

@@ -5,18 +5,18 @@ pub type Result<T> = std::result::Result<T, RenderError>;
 
 #[derive(Error, Debug, PartialEq)]
 pub enum RenderError {
-    #[error("Syntax error inside command")]
-    SyntaxError,
+    #[error("Template syntax error: {0}")]
+    SyntaxError(String),
     #[error("Template function call error")]
     FunctionError,
-    #[error("Missing command type at `{0}`")]
+    #[error("Missing command type at {0}")]
     MissingCommandType(String),
-    #[error("Missing closing command tag at `{0}`")]
+    #[error("Missing closing command tag at {0}")]
     MissingClosingTag(String),
 }
 
 impl Into<JsValue> for RenderError {
     fn into(self) -> JsValue {
-        self.to_string().into()
+        js_sys::Error::new(&self.to_string()).into()
     }
 }

src/lib.rs

@@ -45,7 +45,7 @@ pub struct ParsingData {
 }
 
 #[wasm_bindgen]
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ParserConfig {
     opening_tag: String,
     closing_tag: String,
@@ -126,10 +126,10 @@ impl<'a> Parser<'a> {
             .content
             .split('\n')
             .take(d.line as usize)
-            .map(|l| l.len()+1)
+            .map(|l| l.len() + 1)
             .sum();
         let ch = d.ch - line_ch;
-        let mut spaces: String = (0..ch-1).map(|_| ' ').collect();
+        let mut spaces: String = (0..ch - 1).map(|_| ' ').collect();
         spaces += "^";
         let s = format!("line {} col {}:\n\n{}\n{}", d.line + 1, ch, line, spaces);
         s
@@ -283,6 +283,11 @@ impl<'a> Parser<'a> {
                 parsing_data.ch += text.len();
                 parsing_data.line += count_newlines(text);
             }
+            if i.is_empty() {
+                return Err(RenderError::MissingClosingTag(
+                    self.generate_backtrace(&mut parsing_data),
+                ));
+            }
 
             let (opening_whitespace, i) = self.parse_whitespace(i, &mut parsing_data)?;
             let (cmd_type, i) = self.parse_command_tag(i, &mut parsing_data)?;
@@ -300,7 +305,6 @@ impl<'a> Parser<'a> {
 
             parsing_data.ch += content.len();
             parsing_data.line += count_newlines(content);
-
             let command = Command {
                 r#type: cmd_type,
                 opening_whitespace,
@@ -407,7 +411,11 @@ impl Renderer {
             &JsValue::from(&fn_body).into(),
         ) {
             Ok(f) => f,
-            Err(_) => return Err(RenderError::SyntaxError),
+            Err(e) => {
+                let err = js_sys::Error::from(e);
+                let msg = err.message().as_string().unwrap();
+                return Err(RenderError::SyntaxError(msg));
+            }
         };
         let async_fn = js_sys::Function::from(async_fn);
         let res = match async_fn.call1(&JsValue::NULL, context) {

tests/error.rs

@@ -1,8 +1,8 @@
 #![cfg(target_arch = "wasm32")]
 
 extern crate wasm_bindgen_test;
-use wasm_bindgen_test::*;
 use wasm_bindgen::prelude::*;
+use wasm_bindgen_test::*;
 
 use rusty_engine::{error::RenderError, Parser, ParserConfig, Renderer};
 
@@ -18,6 +18,16 @@ testtest <% test2
     let parser = Parser::new(content, &config);
     let tokens = parser.parse_tokens();
     assert_eq!(tokens, Err(RenderError::MissingClosingTag(err.into())));
+
+    let content = "\ntest\n\n<%";
+    let err = r#"line 4 col 2:
+
+<%
+ ^"#;
+
+    let parser = Parser::new(content, &config);
+    let tokens = parser.parse_tokens();
+    assert_eq!(tokens, Err(RenderError::MissingClosingTag(err.into())));
 }
 
 #[wasm_bindgen_test]
@@ -39,8 +49,16 @@ test <% test %> test
 pub fn test_syntax_error() {
     let config = ParserConfig::new("<%".into(), "%>".into(), '\0', '*', '-', '_', "tR".into());
     let content = r#"test <%* / %> test"#;
+    let err = "Invalid regular expression: missing /";
+
+    let renderer = Renderer::new(config.clone());
+    let res = renderer.render_content(content, &JsValue::NULL);
+    assert_eq!(res, Err(RenderError::SyntaxError(err.into())));
+
+    let content = r#"test <% console.log('\'test\''); %> test"#;
+    let err = "missing ) after argument list";
 
-    let renderer = Renderer::new(config);
+    let renderer = Renderer::new(config.clone());
     let res = renderer.render_content(content, &JsValue::NULL);
-    assert_eq!(res, Err(RenderError::SyntaxError));
+    assert_eq!(res, Err(RenderError::SyntaxError(err.into())));
 }