fix: improve mustache delimiter parsing

Author: morugetsm

Cargo.lock

@@ -15,9 +15,8 @@ categories = ["template-engine"]
 boa_ast = "0.21"
 boa_engine = { version = "0.21", features = ["deser"] }
 boa_parser = "0.21"
-html5ever = "0.38.0"
-markup5ever_rcdom = "0.38.0"
-regex = "1.12"
+html5ever = "0.39.0"
+markup5ever_rcdom = "0.39.0"
 serde = "1.0"
 serde_json = { version = "1.0", features = ["preserve_order"] }
-thiserror = "2"
+thiserror = "2.0"

Cargo.toml

@@ -1,5 +1,3 @@
-use std::sync::atomic::AtomicUsize;
-
 use boa_ast::{
     Statement, StatementListItem,
     declaration::{Binding, Declaration},
@@ -26,17 +24,17 @@ pub(crate) struct ForBinding {
 pub(crate) struct Engine {
     pub context: Context,
     scope_keys: Vec<String>,
-    scope_next: AtomicUsize,
-    binding_next: AtomicUsize,
+    scope_next: usize,
+    binding_next: usize,
 }
 
 impl Engine {
     pub fn new(data: impl Serialize) -> Result<Self> {
         let mut engine = Self {
             context: Context::default(),
             scope_keys: Default::default(),
-            scope_next: AtomicUsize::new(0),
-            binding_next: AtomicUsize::new(0),
+            scope_next: 0,
+            binding_next: 0,
         };
 
         engine.enter_scope().map_err(|err| Error::Scope {
@@ -68,11 +66,8 @@ impl Engine {
     }
 
     pub fn enter_scope(&mut self) -> JsResult<()> {
-        let key = format!(
-            "__scope_{}",
-            self.scope_next
-                .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
-        );
+        let key = format!("__scope_{}", self.scope_next);
+        self.scope_next += 1;
         let scope = ObjectInitializer::new(&mut self.context).build();
         self.context.global_object().set(
             JsString::from(key.as_str()),
@@ -154,11 +149,8 @@ impl Engine {
         let Some(scope_key) = self.scope_keys.last().cloned() else {
             return false;
         };
-        let temp_key = format!(
-            "__temp_{}",
-            self.binding_next
-                .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
-        );
+        let temp_key = format!("__temp_{}", self.binding_next);
+        self.binding_next += 1;
 
         let slot_array = JsArray::from_iter(slots, &mut self.context);
 

src/engine.rs

@@ -42,6 +42,28 @@ impl fmt::Display for DirectiveErrorKind {
     }
 }
 
+fn format_field(field: &Option<String>) -> String {
+    match field {
+        Some(field) => format!(" field {field:?}"),
+        None => String::new(),
+    }
+}
+
+fn format_expression(expression: &Option<String>) -> String {
+    match expression {
+        Some(expression) if !expression.is_empty() => format!(" {expression:?}"),
+        _ => String::new(),
+    }
+}
+
+fn format_directives(directives: &[Directive]) -> String {
+    directives
+        .iter()
+        .map(ToString::to_string)
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("failed to parse template: {source}")]
@@ -68,13 +90,19 @@ pub enum Error {
         source: serde_json::Error,
     },
 
-    #[error("failed to convert render data to JavaScript: {message}")]
+    #[error(
+        "failed to convert render data{field} to JavaScript: {message}",
+        field = format_field(field)
+    )]
     DataToJs {
         field: Option<String>,
         message: String,
     },
 
-    #[error("failed to inject render data: {message}")]
+    #[error(
+        "failed to inject render data{field}: {message}",
+        field = format_field(field)
+    )]
     DataInject {
         field: Option<String>,
         message: String,
@@ -83,17 +111,23 @@ pub enum Error {
     #[error("failed to manage JavaScript scope: {message}")]
     Scope { message: String },
 
-    #[error("failed to execute prevue script: {message}")]
+    #[error("failed to execute <script type=\"prevue\">: {message}")]
     SetupScript { message: String },
 
-    #[error("invalid {directive}: {kind}")]
+    #[error(
+        "invalid {directive}: {kind}{expression}",
+        expression = format_expression(expression)
+    )]
     InvalidDirective {
         directive: Directive,
         kind: DirectiveErrorKind,
         expression: Option<String>,
     },
 
-    #[error("conflicting directives: {directives:?}")]
+    #[error(
+        "conflicting directives: {directives}",
+        directives = format_directives(directives)
+    )]
     ConflictingDirectives { directives: Vec<Directive> },
 }