feat: parsing utilities for custom nodes

Author: ModProg

src/node/mod.rs

@@ -11,6 +11,7 @@ mod attribute;
 mod node_name;
 mod node_value;
 pub mod parse;
+mod parser_ext;
 mod raw_text;
 
 pub use attribute::{

src/node/parse.rs

@@ -114,8 +114,11 @@ impl ParseRecoverable for NodeDoctype {
     }
 }
 
-impl ParseRecoverable for OpenTag {
-    fn parse_recoverable(parser: &mut RecoverableContext, input: ParseStream) -> Option<Self> {
+impl OpenTag {
+    pub fn parse_start_tag(
+        parser: &mut RecoverableContext,
+        input: ParseStream,
+    ) -> Option<Token![<]> {
         let token_lt = parser.parse_simple::<Token![<]>(input)?;
         // Found closing tag when open tag was expected
         // keep parsing it as open tag.
@@ -131,6 +134,13 @@ impl ParseRecoverable for OpenTag {
                 "close tag was parsed while waiting for open tag",
             ));
         }
+        Some(token_lt)
+    }
+}
+
+impl ParseRecoverable for OpenTag {
+    fn parse_recoverable(parser: &mut RecoverableContext, input: ParseStream) -> Option<Self> {
+        let token_lt = Self::parse_start_tag(parser, input)?;
         let name = parser.parse_simple(input)?;
         let generics = parser.parse_simple(input)?;
 
@@ -150,23 +160,14 @@ impl ParseRecoverable for OpenTag {
     }
 }
 
-impl<C: CustomNode> ParseRecoverable for NodeElement<C> {
-    fn parse_recoverable(parser: &mut RecoverableContext, input: ParseStream) -> Option<Self> {
-        let open_tag: OpenTag = parser.parse_recoverable(input)?;
-        let is_known_self_closed =
-            |name| parser.config().always_self_closed_elements.contains(name);
-        let is_raw = |name| parser.config().raw_text_elements.contains(name);
-
-        let tag_name_str = &*open_tag.name.to_string();
-        if open_tag.is_self_closed() || is_known_self_closed(tag_name_str) {
-            return Some(NodeElement {
-                open_tag,
-                children: vec![],
-                close_tag: None,
-            });
-        }
-
-        let (children, close_tag) = if is_raw(tag_name_str) {
+impl<C: CustomNode> NodeElement<C> {
+    pub fn parse_children(
+        parser: &mut RecoverableContext,
+        input: ParseStream,
+        raw: bool,
+        open_tag: &OpenTag,
+    ) -> Option<(Vec<Node<C>>, Option<CloseTag>)> {
+        let (children, close_tag) = if raw {
             let (child, closed_tag) =
                 parser.parse_with_ending(input, |_, t| RawText::from(t), CloseTag::parse);
             // don't keep empty RawText
@@ -208,11 +209,7 @@ impl<C: CustomNode> ParseRecoverable for NodeElement<C> {
             }
 
             parser.push_diagnostic(diagnostic);
-            return Some(NodeElement {
-                open_tag,
-                children,
-                close_tag: None,
-            });
+            return Some((children, None));
         };
 
         if close_tag.name != open_tag.name {
@@ -247,10 +244,31 @@ impl<C: CustomNode> ParseRecoverable for NodeElement<C> {
             );
             parser.push_diagnostic(diagnostic)
         }
+        Some((children, Some(close_tag)))
+    }
+}
+
+impl<C: CustomNode> ParseRecoverable for NodeElement<C> {
+    fn parse_recoverable(parser: &mut RecoverableContext, input: ParseStream) -> Option<Self> {
+        let open_tag: OpenTag = parser.parse_recoverable(input)?;
+        let is_known_self_closed =
+            |name| parser.config().always_self_closed_elements.contains(name);
+        let is_raw = |name| parser.config().raw_text_elements.contains(name);
+
+        let tag_name_str = &*open_tag.name.to_string();
+        if open_tag.is_self_closed() || is_known_self_closed(tag_name_str) {
+            return Some(NodeElement {
+                open_tag,
+                children: vec![],
+                close_tag: None,
+            });
+        }
+        let (children, close_tag) =
+            Self::parse_children(parser, input, is_raw(tag_name_str), &open_tag)?;
         let element = NodeElement {
             open_tag,
             children,
-            close_tag: Some(close_tag),
+            close_tag,
         };
         Some(element)
     }

src/node/parser_ext.rs

@@ -0,0 +1,40 @@
+use proc_macro2::{TokenStream, TokenTree};
+use syn::parse::{discouraged::Speculative, Parse, ParseStream};
+
+use crate::recoverable::RecoverableContext;
+
+impl RecoverableContext {
+    /// Like [`parse_simple`], but splits the tokenstream at `E` first only
+    /// parsing the tokens before it as `T`.
+    ///
+    /// [`parse_simple`]: #method.parse_simple
+    pub fn parse_simple_with_ending<T: Parse, E: Parse>(
+        &mut self,
+        input: ParseStream,
+    ) -> Option<(T, E)> {
+        let mut tokens = TokenStream::new();
+        let res = loop {
+            // Use fork, because we can't limit separator to be only Peekable for custom
+            // tokens but we also need to parse complex expressions like
+            // "foo=x/y" or "/>"
+            let fork = input.fork();
+            if let Ok(end) = fork.parse() {
+                input.advance_to(&fork);
+                break Some(end);
+            }
+
+            if input.is_empty() {
+                break None;
+            }
+
+            let next: TokenTree = self
+                .parse_simple(input)
+                .expect("TokenTree should always be parsable");
+            tokens.extend([next]);
+        };
+        res.and_then(|res| {
+            self.save_diagnostics(syn::parse2(tokens))
+                .map(|val| (val, res))
+        })
+    }
+}

tests/custom_node.rs

@@ -0,0 +1,78 @@
+use quote::{ToTokens, TokenStreamExt};
+use rstml::{
+    atoms::{self, OpenTag, OpenTagEnd},
+    node::{CustomNode, Node, NodeElement},
+    recoverable::Recoverable,
+};
+use syn::{parse_quote, Expr, Token};
+
+#[derive(Debug, syn_derive::ToTokens)]
+struct If {
+    token_lt: Token![<],
+    token_if: Token![if],
+    condition: Expr,
+    open_tag_end: OpenTagEnd,
+    #[to_tokens(TokenStreamExt::append_all)]
+    body: Vec<Node>,
+    close_tag: Option<atoms::CloseTag>,
+}
+
+impl CustomNode for If {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        ToTokens::to_tokens(&self, tokens)
+    }
+
+    fn peek_element(input: syn::parse::ParseStream) -> bool {
+        input.peek(Token![<]) && input.peek2(Token![if])
+    }
+
+    fn parse_element(
+        parser: &mut rstml::recoverable::RecoverableContext,
+        input: syn::parse::ParseStream,
+    ) -> Option<Self> {
+        let token_lt = OpenTag::parse_start_tag(parser, input)?;
+        let token_if = parser.parse_simple(input)?;
+        let (condition, open_tag_end): (_, OpenTagEnd) = parser.parse_simple_with_ending(input)?;
+        let (body, close_tag) = if open_tag_end.token_solidus.is_none() {
+            // Passed to allow parsing of close_tag
+            NodeElement::parse_children(
+                parser,
+                input,
+                false,
+                &OpenTag {
+                    token_lt,
+                    name: parse_quote!(#token_if),
+                    generics: Default::default(),
+                    attributes: Default::default(),
+                    end_tag: open_tag_end.clone(),
+                },
+            )?
+        } else {
+            (Vec::new(), None)
+        };
+        Some(Self {
+            token_lt,
+            token_if,
+            condition,
+            open_tag_end,
+            body,
+            close_tag,
+        })
+    }
+}
+
+#[test]
+fn custom_node() {
+    let actual: Recoverable<Node<If>> = parse_quote! {
+        <if just && an || expression>
+            <a regular="html" component/>
+            <div>
+            </div>
+        </if>
+    };
+    let Node::Custom(actual) = actual.inner() else {
+        panic!()
+    };
+
+    assert_eq!(actual.condition, parse_quote!(just && an || expression));
+}