1#![warn(missing_docs)]
2use tree_sitter::{LanguageError, Tree};
5use tree_sitter_hemplate::LANGUAGE;
6
7pub struct TemplateParser {
12 parser: tree_sitter::Parser,
13}
14
15impl TemplateParser {
16 pub fn new() -> Result<Self, LanguageError> {
18 let mut parser = tree_sitter::Parser::new();
19 parser.set_language(&LANGUAGE.into())?;
20 Ok(Self { parser })
21 }
22
23 pub fn parse(&mut self, input: &str, old_tree: Option<&Tree>) -> Option<Tree> {
25 self.parser.parse(input, old_tree)
26 }
27}
28
29pub fn parse_template<T: AsRef<str> + ?Sized>(input: &T, old_tree: Option<&Tree>) -> Option<Tree> {
34 TemplateParser::new().ok()?.parse(input.as_ref(), old_tree)
35}
36
37#[cfg(test)]
38mod tests {
39 use super::*;
40
41 #[test]
42 fn reusable_parser_parses_sequential_templates() {
43 let mut parser = TemplateParser::new().expect("hemplate grammar must load");
44 let first = parser.parse("<p>first</p>", None).expect("first parse");
45 let second = parser
46 .parse("<section>second</section>", None)
47 .expect("second parse");
48
49 assert_eq!(first.root_node().end_byte(), "<p>first</p>".len());
50 assert_eq!(
51 second.root_node().end_byte(),
52 "<section>second</section>".len()
53 );
54 }
55}
56
57#[cfg(test)]
58mod attribute_regressions {
59 use super::*;
60
61 #[test]
62 fn assignment_whitespace_preserves_values_and_boundaries() {
63 for source in [
64 r#"<input id = "query" disabled +data-id = "self.id" h-if = "self.visible">"#,
65 "<input id\t=\n'query' disabled +data-id\t=\n\"self.id\" h-if\t=\n\"self.visible\">",
66 ] {
67 let tree = parse_template(source, None).unwrap();
68 let root = tree.root_node();
69 assert!(!root.has_error(), "{source}: {}", root.to_sexp());
70 let mut found = Vec::new();
71 let mut pending = vec![root];
72 while let Some(node) = pending.pop() {
73 if matches!(
74 node.kind(),
75 "regular_attribute" | "dynamic_attribute" | "template_directive"
76 ) {
77 let name = node.named_child(0).unwrap();
78 let value = node
79 .named_child(1)
80 .map(|value| source[value.byte_range()].trim());
81 found.push((node.start_byte(), source[name.byte_range()].trim(), value));
82 }
83 pending.extend(node.named_children(&mut node.walk()));
84 }
85 found.sort_by_key(|item| item.0);
86 let names: Vec<_> = found.iter().map(|item| item.1).collect();
87 assert_eq!(names, ["id", "disabled", "data-id", "h-if"]);
88 assert!(matches!(found[0].2, Some("\"query\"" | "'query'")));
89 assert_eq!(found[1].2, None);
90 assert_eq!(found[2].2, Some("\"self.id\""));
91 assert_eq!(found[3].2, Some("\"self.visible\""));
92 }
93 }
94
95 #[test]
96 fn valueless_attributes_do_not_consume_following_names() {
97 for source in [
98 r#"<input disabled +checked="false">"#,
99 "<span data-cad-gesture-status hidden>idle</span>",
100 "<input disabled checked/>",
101 "<input disabled checked>",
102 "<input disabled checked required>",
103 "<input disabled data-next='ok'>",
104 "<input data-empty data-next=ok>",
105 ] {
106 let tree = parse_template(source, None).unwrap();
107 let root = tree.root_node();
108 assert!(!root.has_error(), "{source}: {}", root.to_sexp());
109 let mut attributes = Vec::new();
110 let mut pending = vec![root];
111 while let Some(node) = pending.pop() {
112 if matches!(node.kind(), "regular_attribute" | "dynamic_attribute") {
113 attributes.push(node);
114 }
115 pending.extend(node.named_children(&mut node.walk()));
116 }
117 attributes.sort_by_key(tree_sitter::Node::start_byte);
118 let names: Vec<_> = attributes
119 .iter()
120 .map(|node| source[node.named_child(0).unwrap().byte_range()].trim())
124 .collect();
125 let expected = if source.contains("gesture-status") {
126 vec!["data-cad-gesture-status", "hidden"]
127 } else if source.contains("required") {
128 vec!["disabled", "checked", "required"]
129 } else if source.contains("checked") {
130 vec!["disabled", "checked"]
131 } else if source.contains("data-empty") {
132 vec!["data-empty", "data-next"]
133 } else {
134 vec!["disabled", "data-next"]
135 };
136 assert_eq!(names, expected, "{source}: {}", root.to_sexp());
137 assert_eq!(
138 attributes[0].named_child_count(),
139 1,
140 "{source}: {}",
141 root.to_sexp()
142 );
143 }
144 }
145}