Skip to main content

hemplate_parser/
lib.rs

1#![warn(missing_docs)]
2//! hemplate-parser: Tree-sitter based parser for hemplate templates.
3
4use tree_sitter::{LanguageError, Tree};
5use tree_sitter_hemplate::LANGUAGE;
6
7/// A reusable hemplate parser for latency-sensitive or repeated parsing.
8///
9/// Constructing and configuring tree-sitter is materially more expensive than parsing small
10/// templates. Keep one parser per sequential parsing context, such as an editor document store.
11pub struct TemplateParser {
12    parser: tree_sitter::Parser,
13}
14
15impl TemplateParser {
16    /// Construct a parser configured for the hemplate grammar.
17    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    /// Parse source text, optionally using an edited previous tree for incremental parsing.
24    pub fn parse(&mut self, input: &str, old_tree: Option<&Tree>) -> Option<Tree> {
25        self.parser.parse(input, old_tree)
26    }
27}
28
29/// Parse one hemplate template into a tree-sitter `Tree`.
30///
31/// This convenience function configures a fresh parser. Repeated or latency-sensitive callers
32/// should retain a [`TemplateParser`] instead.
33pub 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                // Compare logical names, as the host extractor does. Token ranges
121                // may include leading whitespace trivia; attribute boundaries
122                // and the absence of a consumed value remain asserted separately.
123                .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}