Implement DefaultUnwrappable for {int}, str and bool

Author: Kijewski

askama/src/filters/builtin.rs

@@ -433,7 +433,7 @@ const _: () = {
 pub fn default<L: DefaultUnwrappable, R>(
     value: &L,
     default: R,
-) -> Result<Either<&L::Unwrapped, R>, L::Error> {
+) -> Result<Either<L::Unwrapped<'_>, R>, L::Error> {
     match value.try_unwrap()? {
         Some(value) => Ok(Either::Left(value)),
         None => Ok(Either::Right(default)),
@@ -447,64 +447,151 @@ pub fn default<L: DefaultUnwrappable, R>(
 )]
 pub trait DefaultUnwrappable {
     /// The wrapped value
-    type Unwrapped;
+    type Unwrapped<'a>
+    where
+        Self: 'a;
 
     /// An error that prevented [`try_unwrap()`](DefaultUnwrappable::try_unwrap) to succeed,
     /// e.g. a poisoned state or an unacquirable lock.
     type Error: Into<crate::Error>;
 
     /// Try to unwrap the contained value. Returns `Ok(None)` if the value could not be unwrapped.
-    fn try_unwrap(&self) -> Result<Option<&Self::Unwrapped>, Self::Error>;
+    fn try_unwrap(&self) -> Result<Option<Self::Unwrapped<'_>>, Self::Error>;
 }
 
-impl_for_ref! {
-    impl DefaultUnwrappable for T {
-        type Unwrapped = T::Unwrapped;
-        type Error = T::Error;
+const _: () = {
+    impl_for_ref! {
+        impl DefaultUnwrappable for T {
+            type Unwrapped<'a> = T::Unwrapped<'a>
+            where
+                Self: 'a;
+
+            type Error = T::Error;
+
+            #[inline]
+            fn try_unwrap(&self) -> Result<Option<Self::Unwrapped<'_>>, Self::Error> {
+                <T>::try_unwrap(self)
+            }
+        }
+    }
+
+    impl<T> DefaultUnwrappable for Pin<T>
+    where
+        T: Deref,
+        <T as Deref>::Target: DefaultUnwrappable,
+    {
+        type Unwrapped<'a>
+            = <<T as Deref>::Target as DefaultUnwrappable>::Unwrapped<'a>
+        where
+            Self: 'a;
+
+        type Error = <<T as Deref>::Target as DefaultUnwrappable>::Error;
 
         #[inline]
-        fn try_unwrap(&self) -> Result<Option<&Self::Unwrapped>, Self::Error> {
-            <T>::try_unwrap(self)
+        fn try_unwrap(&self) -> Result<Option<Self::Unwrapped<'_>>, Self::Error> {
+            self.as_ref().get_ref().try_unwrap()
         }
     }
-}
 
-impl<T> DefaultUnwrappable for Pin<T>
-where
-    T: Deref,
-    <T as Deref>::Target: DefaultUnwrappable,
-{
-    type Unwrapped = <<T as Deref>::Target as DefaultUnwrappable>::Unwrapped;
-    type Error = <<T as Deref>::Target as DefaultUnwrappable>::Error;
+    impl<T> DefaultUnwrappable for Option<T> {
+        type Unwrapped<'a>
+            = &'a T
+        where
+            Self: 'a;
 
-    #[inline]
-    fn try_unwrap(&self) -> Result<Option<&Self::Unwrapped>, Self::Error> {
-        self.as_ref().get_ref().try_unwrap()
+        type Error = Infallible;
+
+        #[inline]
+        fn try_unwrap(&self) -> Result<Option<Self::Unwrapped<'_>>, Self::Error> {
+            Ok(self.as_ref())
+        }
     }
-}
 
-impl<T> DefaultUnwrappable for Option<T> {
-    type Unwrapped = T;
-    type Error = Infallible;
+    impl<T, E> DefaultUnwrappable for Result<T, E> {
+        type Unwrapped<'a>
+            = &'a T
+        where
+            Self: 'a;
 
-    #[inline]
-    fn try_unwrap(&self) -> Result<Option<&Self::Unwrapped>, Self::Error> {
-        Ok(self.as_ref())
+        type Error = Infallible;
+
+        #[inline]
+        fn try_unwrap(&self) -> Result<Option<Self::Unwrapped<'_>>, Self::Error> {
+            match self {
+                Ok(value) => Ok(Some(value)),
+                Err(_) => Ok(None),
+            }
+        }
     }
-}
 
-impl<T, E> DefaultUnwrappable for Result<T, E> {
-    type Unwrapped = T;
-    type Error = Infallible;
+    impl DefaultUnwrappable for str {
+        type Unwrapped<'a>
+            = &'a str
+        where
+            Self: 'a;
 
-    #[inline]
-    fn try_unwrap(&self) -> Result<Option<&Self::Unwrapped>, Self::Error> {
-        match self {
-            Ok(value) => Ok(Some(value)),
-            Err(_) => Ok(None),
+        type Error = Infallible;
+
+        #[inline]
+        fn try_unwrap(&self) -> Result<Option<Self::Unwrapped<'_>>, Self::Error> {
+            match self.is_empty() {
+                false => Ok(Some(self)),
+                true => Ok(None),
+            }
         }
     }
-}
+
+    #[cfg(feature = "alloc")]
+    impl DefaultUnwrappable for alloc::string::String {
+        type Unwrapped<'a>
+            = &'a str
+        where
+            Self: 'a;
+
+        type Error = Infallible;
+
+        #[inline]
+        fn try_unwrap(&self) -> Result<Option<Self::Unwrapped<'_>>, Self::Error> {
+            self.as_str().try_unwrap()
+        }
+    }
+
+    macro_rules! impl_for_int {
+        ($($ty:ty)*) => { $(
+            impl DefaultUnwrappable for $ty {
+                type Unwrapped<'a> = Self;
+                type Error = Infallible;
+
+                #[inline]
+                fn try_unwrap(&self) -> Result<Option<Self::Unwrapped<'_>>, Self::Error> {
+                    match *self {
+                        0 => Ok(None),
+                        value => Ok(Some(value)),
+                    }
+                }
+            }
+        )* };
+    }
+
+    impl_for_int!(
+        u8 u16 u32 u64 u128 usize
+        i8 i16 i32 i64 i128 isize
+    );
+
+    impl DefaultUnwrappable for bool {
+        type Unwrapped<'a> = Self;
+
+        type Error = Infallible;
+
+        #[inline]
+        fn try_unwrap(&self) -> Result<Option<Self::Unwrapped<'_>>, Self::Error> {
+            match *self {
+                true => Ok(Some(true)),
+                false => Ok(None),
+            }
+        }
+    }
+};
 
 /// Render either `L` or `R`
 pub enum Either<L, R> {

testing/tests/filters.rs

@@ -3,6 +3,8 @@
 extern crate serde_json;
 
 use std::num::NonZeroU32;
+use std::pin::Pin;
+use std::sync::Arc;
 
 use askama::Template;
 use assert_matches::assert_matches;
@@ -595,3 +597,81 @@ fn test_default_expr_with_unwrap() {
     assert_eq!(AResult { value: b"H\xffllo" }.render().unwrap(), "unknown");
     assert_eq!(AResult { value: b"Hello" }.render().unwrap(), "Hello");
 }
+
+#[test]
+fn test_default_with_int() {
+    // In this test a default value should be returned for an integer value 0.
+
+    #[derive(Template)]
+    #[template(source = r#"{{ value | default("unknown", true) }}"#, ext = "html")]
+    struct U8 {
+        value: Arc<Pin<Box<u8>>>,
+    }
+
+    assert_eq!(
+        U8 {
+            value: Arc::new(Box::pin(0))
+        }
+        .render()
+        .unwrap(),
+        "unknown"
+    );
+    assert_eq!(
+        U8 {
+            value: Arc::new(Box::pin(42))
+        }
+        .render()
+        .unwrap(),
+        "42"
+    );
+}
+
+#[test]
+fn test_default_with_str() {
+    // In this test a default value should be returned for an empty string.
+
+    #[derive(Template)]
+    #[template(source = r#"{{ value | default("unknown", true) }}"#, ext = "html")]
+    struct Str<'a> {
+        value: &'a str,
+    }
+
+    assert_eq!(Str { value: "" }.render().unwrap(), "unknown");
+    assert_eq!(Str { value: "Hello" }.render().unwrap(), "Hello");
+    #[derive(Template)]
+    #[template(source = r#"{{ value | default("unknown", true) }}"#, ext = "html")]
+    struct AString {
+        value: String,
+    }
+
+    assert_eq!(
+        AString {
+            value: "".to_owned()
+        }
+        .render()
+        .unwrap(),
+        "unknown"
+    );
+    assert_eq!(
+        AString {
+            value: "Hello".to_owned()
+        }
+        .render()
+        .unwrap(),
+        "Hello"
+    );
+}
+
+#[test]
+fn test_default_with_bool() {
+    // In this test a default value should be returned for `false`.
+
+    #[derive(Template)]
+    #[template(source = r#"{{ value | default("unknown", true) }}"#, ext = "html")]
+    struct Bool {
+        value: bool,
+    }
+
+    assert_eq!(Bool { value: false }.render().unwrap(), "unknown");
+    assert_eq!(Bool { value: true }.render().unwrap(), "true");
+}