Add support for filter chaining in filter blocks

Author: GuillaumeGomez

askama_derive/src/generator.rs

@@ -15,6 +15,14 @@ use parser::node::{
 use parser::{Expr, Node};
 use quote::quote;
 
+fn insert_variable_at_the_end(args: &mut Vec<Expr<'_>>, var_name: String) {
+    if let Some(Expr::Filter(_, ref mut args)) = args.first_mut() {
+        insert_variable_at_the_end(args, var_name);
+    } else {
+        args.insert(0, Expr::Generated(var_name.clone()));
+    }
+}
+
 pub(crate) struct Generator<'a> {
     // The template input state: original struct AST and attributes
     input: &'a TemplateInput<'a>,
@@ -736,10 +744,13 @@ impl<'a> Generator<'a> {
         mem::drop(mem::replace(&mut self.buf_writable, current_buf));
 
         let mut filter_buf = Buffer::new(buf.indent);
-        let mut args = filter.args.clone();
-        args.insert(0, Expr::Generated(var_name.clone()));
+        let (filter_name, mut args) = match &filter.filters {
+            Expr::Filter(filter_name, args) => (filter_name, args.clone()),
+            expr => panic!("Expected an `Expr::Filter`, found {expr:?}"),
+        };
+        insert_variable_at_the_end(&mut args, var_name.clone());
 
-        let wrap = self.visit_filter(&mut filter_buf, filter.filter_name, &args)?;
+        let wrap = self.visit_filter(&mut filter_buf, filter_name, &args)?;
 
         self.buf_writable
             .push(Writable::Generated(filter_buf.buf, wrap));

askama_parser/src/node.rs

@@ -563,25 +563,44 @@ impl<'a> Macro<'a> {
 #[derive(Debug, PartialEq)]
 pub struct FilterBlock<'a> {
     pub ws1: Ws,
-    pub filter_name: &'a str,
-    pub args: Vec<Expr<'a>>,
+    pub filters: Expr<'a>,
     pub nodes: Vec<Node<'a>>,
     pub ws2: Ws,
 }
 
 impl<'a> FilterBlock<'a> {
     fn parse(i: &'a str, s: &State<'_>) -> ParseResult<'a, Self> {
+        #[allow(clippy::type_complexity)]
+        fn filter(i: &str, level: crate::Level) -> ParseResult<'_, (&str, Option<Vec<Expr<'_>>>)> {
+            let (i, (_, fname, args)) = tuple((
+                char('|'),
+                ws(identifier),
+                opt(|i| Expr::arguments(i, level, false)),
+            ))(i)?;
+            Ok((i, (fname, args)))
+        }
+
         let mut start = tuple((
             opt(Whitespace::parse),
             ws(keyword("filter")),
             cut(tuple((
                 ws(identifier),
                 opt(|i| Expr::arguments(i, s.level.get(), false)),
+                many0(|i| filter(i, s.level.get())),
                 opt(Whitespace::parse),
                 |i| s.tag_block_end(i),
             ))),
         ));
-        let (i, (pws1, _, (filter_name, params, nws1, _))) = start(i)?;
+        let (i, (pws1, _, (filter_name, params, extra_filters, nws1, _))) = start(i)?;
+
+        let mut filters = Expr::Filter(filter_name, params.unwrap_or_default());
+        for (filter_name, args) in extra_filters {
+            filters = Expr::Filter(filter_name, {
+                let mut args = args.unwrap_or_default();
+                args.insert(0, filters);
+                args
+            });
+        }
 
         let mut end = cut(tuple((
             |i| Node::many(i, s),
@@ -598,8 +617,7 @@ impl<'a> FilterBlock<'a> {
             i,
             Self {
                 ws1: Ws(pws1, nws1),
-                filter_name,
-                args: params.unwrap_or_default(),
+                filters,
                 nodes,
                 ws2: Ws(pws2, nws2),
             },