Port askama to new filter_fn proc-macro-attr

Author: seijikun

askama/src/filters/escape.rs

@@ -256,6 +256,7 @@ impl<'a, T: HtmlSafe + ?Sized> AutoEscape for &AutoEscaper<'a, T, Html> {
 ///     use askama::{filters::MaybeSafe, Result, Values};
 ///
 ///     // Do not actually use this filter! It's an intentionally bad example.
+///     #[askama::filter_fn]
 ///     pub fn backdoor<T: std::fmt::Display>(
 ///         s: T,
 ///         _: &dyn Values,
@@ -386,6 +387,7 @@ const _: () = {
 ///     use askama::{filters::Safe, Result, Values};
 ///
 ///     // Do not actually use this filter! It's an intentionally bad example.
+///     #[askama::filter_fn]
 ///     pub fn strip_except_apos(s: impl ToString, _: &dyn Values) -> Result<Safe<String>> {
 ///         Ok(Safe(s
 ///             .to_string()

askama_derive/src/generator/filter.rs

@@ -76,16 +76,33 @@ impl<'a> Generator<'a, '_> {
         args: &[WithSpan<'a, Expr<'a>>],
         node: Span<'_>,
     ) -> Result<DisplayWrap, CompileError> {
-        ensure_no_named_arguments(ctx, path.last().unwrap().name, args, node)?;
-        self.visit_path(buf, path);
-        buf.write('(');
-        self.visit_arg(ctx, buf, &args[0])?;
-        buf.write(",__askama_values");
-        if args.len() > 1 {
-            buf.write(',');
-            self.visit_args(ctx, buf, &args[1..])?;
+        buf.write("{");
+        let prefix_path = &path[..path.len() - 1];
+        self.visit_path(buf, prefix_path);
+        let filter = path
+            .last()
+            .ok_or_else(|| ctx.generate_error("Filter invocations don't support generics", node))?;
+        if !prefix_path.is_empty() {
+            buf.write("::");
         }
-        buf.write(")?");
+        buf.write(format!("{}::default()", filter.name));
+
+        for (arg_idx, arg) in args[1..].iter().enumerate() {
+            let expr: &Expr<'a> = arg;
+            if let Expr::NamedArgument(name, arg) = expr {
+                buf.write(format!(".with_{name}("));
+                self.visit_arg(ctx, buf, arg)?;
+                buf.write(")");
+            } else {
+                buf.write(format!(".with_{arg_idx}("));
+                self.visit_arg(ctx, buf, arg)?;
+                buf.write(")");
+            }
+        }
+
+        buf.write(".execute(");
+        self.visit_arg(ctx, buf, &args[0])?;
+        buf.write(",__askama_values)?}");
         Ok(DisplayWrap::Unwrapped)
     }
 

askama_derive/src/tests.rs

@@ -1197,7 +1197,7 @@ fn test_filter_with_path() {
         r#"
         match (
             &((&&askama::filters::AutoEscaper::new(
-                &(b::c::d(&(self.a), __askama_values)?),
+                &({ b::c::d::default().execute(&(self.a), __askama_values)? }),
                 askama::filters::Text,
             ))
                 .askama_auto_escape()?),

testing/tests/book_example_runtime_values_in_custom_filters.rs

@@ -9,6 +9,7 @@ use askama::{Template, Values};
 mod filters {
     use super::*;
 
+    #[askama::filter_fn]
     pub fn cased(value: impl ToString, values: &dyn Values) -> askama::Result<String> {
         let value = value.to_string();
         let case = askama::get_value(values, "case").ok();

testing/tests/filters.rs

@@ -98,11 +98,13 @@ fn filter_fmt() {
 mod filters {
     use askama::Values;
 
+    #[askama::filter_fn]
     pub fn myfilter(s: &str, _: &dyn Values) -> ::askama::Result<String> {
         Ok(s.replace("oo", "aa"))
     }
 
     // for test_nested_filter_ref
+    #[askama::filter_fn]
     pub fn mytrim(s: &dyn std::fmt::Display, _: &dyn Values) -> ::askama::Result<String> {
         Ok(s.to_string().trim().to_owned())
     }
@@ -477,6 +479,7 @@ fn test_whitespace_around_filter_operator() {
     assert_eq!(S.render().unwrap(), "12\n8\n4");
 }
 
+#[askama::filter_fn]
 pub(crate) fn minus(value: &str, _: &dyn askama::Values) -> askama::Result<i32> {
     Ok(-value.parse().map_err(askama::Error::custom)?)
 }