From 85ad2e6ba3a205e9b648431318aac0e75c027a82 Mon Sep 17 00:00:00 2001
From: René Kijewski <Kijewski@users.noreply.github.com>
Date: Fri, 28 Jan 2022 10:48:46 +0100
Subject:  Implement error propagation expression: `?` (#590)

This change allows using the operator `?` in askama expressions. It
works like the same operator in Rust: if a `Result` is `Ok`, it is
unwrapped. If it is an error, then the `render()` method fails with this
error value.
---
 askama_shared/src/error.rs     | 15 ++++++++++-----
 askama_shared/src/generator.rs | 12 ++++++++++++
 askama_shared/src/parser.rs    |  9 ++++++++-
 3 files changed, 30 insertions(+), 6 deletions(-)

(limited to 'askama_shared')

diff --git a/askama_shared/src/error.rs b/askama_shared/src/error.rs
index 4394eea..98f2703 100644
--- a/askama_shared/src/error.rs
+++ b/askama_shared/src/error.rs
@@ -1,6 +1,6 @@
 use std::fmt::{self, Display};
 
-pub type Result<I> = ::std::result::Result<I, Error>;
+pub type Result<I, E = Error> = ::std::result::Result<I, E>;
 
 /// askama error type
 ///
@@ -28,6 +28,9 @@ pub enum Error {
     /// formatting error
     Fmt(fmt::Error),
 
+    /// an error raised by using `?` in a template
+    Custom(Box<dyn std::error::Error + Send + Sync>),
+
     /// json conversion error
     #[cfg(feature = "serde_json")]
     Json(::serde_json::Error),
@@ -41,6 +44,7 @@ impl std::error::Error for Error {
     fn cause(&self) -> Option<&dyn std::error::Error> {
         match *self {
             Error::Fmt(ref err) => err.source(),
+            Error::Custom(ref err) => Some(err.as_ref()),
             #[cfg(feature = "serde_json")]
             Error::Json(ref err) => err.source(),
             #[cfg(feature = "serde_yaml")]
@@ -51,12 +55,13 @@ impl std::error::Error for Error {
 
 impl Display for Error {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            Error::Fmt(ref err) => write!(formatter, "formatting error: {}", err),
+        match self {
+            Error::Fmt(err) => write!(formatter, "formatting error: {}", err),
+            Error::Custom(err) => write!(formatter, "{}", err),
             #[cfg(feature = "serde_json")]
-            Error::Json(ref err) => write!(formatter, "json conversion error: {}", err),
+            Error::Json(err) => write!(formatter, "json conversion error: {}", err),
             #[cfg(feature = "serde_yaml")]
-            Error::Yaml(ref err) => write!(formatter, "yaml conversion error: {}", err),
+            Error::Yaml(err) => write!(formatter, "yaml conversion error: {}", err),
         }
     }
 }
diff --git a/askama_shared/src/generator.rs b/askama_shared/src/generator.rs
index fabe277..de2fdcb 100644
--- a/askama_shared/src/generator.rs
+++ b/askama_shared/src/generator.rs
@@ -1060,9 +1060,21 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             Expr::Group(ref inner) => self.visit_group(buf, inner)?,
             Expr::Call(ref obj, ref args) => self.visit_call(buf, obj, args)?,
             Expr::RustMacro(name, args) => self.visit_rust_macro(buf, name, args),
+            Expr::Try(ref expr) => self.visit_try(buf, expr.as_ref())?,
         })
     }
 
+    fn visit_try(
+        &mut self,
+        buf: &mut Buffer,
+        expr: &Expr<'_>,
+    ) -> Result<DisplayWrap, CompileError> {
+        buf.write("::core::result::Result::map_err(");
+        self.visit_expr(buf, expr)?;
+        buf.write(", |err| ::askama::shared::Error::Custom(::core::convert::Into::into(err)))?");
+        Ok(DisplayWrap::Unwrapped)
+    }
+
     fn visit_rust_macro(&mut self, buf: &mut Buffer, name: &str, args: &str) -> DisplayWrap {
         buf.write(name);
         buf.write("!(");
diff --git a/askama_shared/src/parser.rs b/askama_shared/src/parser.rs
index f429628..63cea0c 100644
--- a/askama_shared/src/parser.rs
+++ b/askama_shared/src/parser.rs
@@ -63,6 +63,7 @@ pub enum Expr<'a> {
     Group(Box<Expr<'a>>),
     Call(Box<Expr<'a>>, Vec<Expr<'a>>),
     RustMacro(&'a str, &'a str),
+    Try(Box<Expr<'a>>),
 }
 
 impl Expr<'_> {
@@ -510,6 +511,7 @@ enum Suffix<'a> {
     Attr(&'a str),
     Index(Expr<'a>),
     Call(Vec<Expr<'a>>),
+    Try,
 }
 
 fn expr_attr(i: &str) -> IResult<&str, Suffix<'_>> {
@@ -533,6 +535,10 @@ fn expr_call(i: &str) -> IResult<&str, Suffix<'_>> {
     map(arguments, Suffix::Call)(i)
 }
 
+fn expr_try(i: &str) -> IResult<&str, Suffix<'_>> {
+    map(preceded(take_till(not_ws), char('?')), |_| Suffix::Try)(i)
+}
+
 fn filter(i: &str) -> IResult<&str, (&str, Option<Vec<Expr<'_>>>)> {
     let (i, (_, fname, args)) = tuple((char('|'), ws(identifier), opt(arguments)))(i)?;
     Ok((i, (fname, args)))
@@ -567,12 +573,13 @@ fn expr_prefix(i: &str) -> IResult<&str, Expr<'_>> {
 fn expr_suffix(i: &str) -> IResult<&str, Expr<'_>> {
     let (mut i, mut expr) = expr_single(i)?;
     loop {
-        let (j, suffix) = opt(alt((expr_attr, expr_index, expr_call)))(i)?;
+        let (j, suffix) = opt(alt((expr_attr, expr_index, expr_call, expr_try)))(i)?;
         i = j;
         match suffix {
             Some(Suffix::Attr(attr)) => expr = Expr::Attr(expr.into(), attr),
             Some(Suffix::Index(index)) => expr = Expr::Index(expr.into(), index.into()),
             Some(Suffix::Call(args)) => expr = Expr::Call(expr.into(), args),
+            Some(Suffix::Try) => expr = Expr::Try(expr.into()),
             None => break,
         }
     }
-- 
cgit