parser: add type for `Node::Include`

2 files changed, 28 insertions, 14 deletions

diff --git a/askama_parser/src/lib.rs b/askama_parser/src/lib.rs
index 8e90802..6822233 100644
--- a/askama_parser/src/lib.rs
+++ b/askama_parser/src/lib.rs
@@ -16,8 +16,8 @@ use nom::{error_position, AsChar, IResult, InputTakeAtPosition};
 
 pub use self::expr::Expr;
 pub use self::node::{
-    BlockDef, Call, Cond, CondTest, If, Import, Let, Lit, Loop, Macro, Match, Node, Raw, Target,
-    When, Whitespace, Ws,
+    BlockDef, Call, Cond, CondTest, If, Import, Include, Let, Lit, Loop, Macro, Match, Node, Raw,
+    Target, When, Whitespace, Ws,
 };
 
 mod expr;
diff --git a/askama_parser/src/node.rs b/askama_parser/src/node.rs
index f7e51de..cb6da92 100644
--- a/askama_parser/src/node.rs
+++ b/askama_parser/src/node.rs
@@ -26,7 +26,7 @@ pub enum Node<'a> {
     Loop(Loop<'a>),
     Extends(&'a str),
     BlockDef(BlockDef<'a>),
-    Include(Ws, &'a str),
+    Include(Include<'a>),
     Import(Import<'a>),
     Macro(Macro<'a>),
     Raw(Raw<'a>),
@@ -54,7 +54,7 @@ impl<'a> Node<'a> {
                 |i| Self::r#for(i, s),
                 map(|i| Match::parse(i, s), Self::Match),
                 Self::extends,
-                Self::include,
+                map(Include::parse, Self::Include),
                 map(Import::parse, Self::Import),
                 map(|i| BlockDef::parse(i, s), Self::BlockDef),
                 map(|i| Macro::parse(i, s), Self::Macro),
@@ -140,16 +140,6 @@ impl<'a> Node<'a> {
         Ok((i, Self::Extends(name)))
     }
 
-    fn include(i: &'a str) -> IResult<&'a str, Self> {
-        let mut p = tuple((
-            opt(Whitespace::parse),
-            ws(keyword("include")),
-            cut(pair(ws(str_lit), opt(Whitespace::parse))),
-        ));
-        let (i, (pws, _, (name, nws))) = p(i)?;
-        Ok((i, Self::Include(Ws(pws, nws), name)))
-    }
-
     fn r#break(i: &'a str, s: &State<'_>) -> IResult<&'a str, Self> {
         let mut p = tuple((
             opt(Whitespace::parse),
@@ -843,6 +833,30 @@ impl<'a> If<'a> {
     }
 }
 
+#[derive(Debug, PartialEq)]
+pub struct Include<'a> {
+    pub ws: Ws,
+    pub path: &'a str,
+}
+
+impl<'a> Include<'a> {
+    fn parse(i: &'a str) -> IResult<&'a str, Self> {
+        let mut p = tuple((
+            opt(Whitespace::parse),
+            ws(keyword("include")),
+            cut(pair(ws(str_lit), opt(Whitespace::parse))),
+        ));
+        let (i, (pws, _, (path, nws))) = p(i)?;
+        Ok((
+            i,
+            Self {
+                ws: Ws(pws, nws),
+                path,
+            },
+        ))
+    }
+}
+
 /// First field is "minus/plus sign was used on the left part of the item".
 ///
 /// Second field is "minus/plus sign was used on the right part of the item".