Implemented display_some and display_some_or

askama/src/filters/mod.rs

@@ -336,6 +336,64 @@ pub fn wordcount<T: fmt::Display>(s: T) -> Result<usize> {
  Ok(s.split_whitespace().count())
 }
 
+pub struct DisplaySome<'a, T>(Option<&'a T>);
+
+impl<T> fmt::Display for DisplaySome<'_, T>
+where
+ T: fmt::Display,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if let Some(val) = self.0 {
+ write!(f, "{val}")?;
+ }
+ Ok(())
+ }
+}
+
+/// See [`display_some` in the Askama book] for more information.
+///
+/// See also [`display_some_or`].
+///
+/// [`display_some` in the Askama book]: https://djc.github.io/askama/filters.html#display_some
+pub fn display_some<T>(value: &Option<T>) -> Result<DisplaySome<'_, T>>
+where
+ T: fmt::Display,
+{
+ Ok(DisplaySome(value.as_ref()))
+}
+
+pub struct DisplaySomeOr<'a, T, U>(Option<&'a T>, U);
+
+impl<T, U> fmt::Display for DisplaySomeOr<'_, T, U>
+where
+ T: fmt::Display,
+ U: fmt::Display,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if let Some(val) = self.0 {
+ write!(f, "{val}")
+ } else {
+ write!(f, "{}", self.1)
+ }
+ }
+}
+
+/// See [`display_some_or` in the Askama book] for more information.
+///
+/// See also [`display_some`].
+///
+/// [`display_some_or` in the Askama book]: https://djc.github.io/askama/filters.html#display_some_or
+pub fn display_some_or<'a, T, U>(
+ value: &'a Option<T>,
+ otherwise: U,
+) -> Result<DisplaySomeOr<'a, T, U>>
+where
+ T: fmt::Display,
+ U: fmt::Display + 'a,
+{
+ Ok(DisplaySomeOr(value.as_ref(), otherwise))
+}
+
 #[cfg(test)]
 mod tests {
  use super::*;
@@ -582,4 +640,43 @@ mod tests {
  assert_eq!(wordcount("foo").unwrap(), 1);
  assert_eq!(wordcount("foo bar").unwrap(), 2);
  }
+
+ #[test]
+ fn test_display_some() {
+ assert_eq!(display_some(&None::<String>).unwrap().to_string(), "");
+ assert_eq!(display_some(&None::<i32>).unwrap().to_string(), "");
+
+ assert_eq!(
+ display_some(&Some("hello world")).unwrap().to_string(),
+ "hello world"
+ );
+ assert_eq!(display_some(&Some(123)).unwrap().to_string(), "123");
+ }
+
+ #[test]
+ fn test_display_some_or() {
+ assert_eq!(
+ display_some_or(&None::<String>, "default")
+ .unwrap()
+ .to_string(),
+ "default"
+ );
+ assert_eq!(
+ display_some_or(&None::<i32>, "default")
+ .unwrap()
+ .to_string(),
+ "default"
+ );
+
+ assert_eq!(
+ display_some_or(&Some("hello world"), "default")
+ .unwrap()
+ .to_string(),
+ "hello world"
+ );
+ assert_eq!(
+ display_some_or(&Some(123), "default").unwrap().to_string(),
+ "123"
+ );
+ }
 }

askama_derive/src/lib.rs

@@ -142,6 +142,8 @@ const BUILT_IN_FILTERS: &[&str] = &[
  "abs",
  "capitalize",
  "center",
+ "display_some",
+ "display_some_or",
  "e",
  "escape",
  "filesizeformat",

book/src/filters.md

@@ -24,6 +24,8 @@ Enable it with Cargo features (see below for more information).
  [`as_ref`][#as_ref],
  [`capitalize`][#capitalize],
  [`center`][#center],
+ [`display_some`][#display_some],
+ [`display_some_or`][#display_some_or],
  [`escape|e`][#escape],
  [`filesizeformat`][#filesizeformat],
  [`fmt`][#fmt],
@@ -108,6 +110,46 @@ Output:
 - a -
 ```
 
+### display_some
+
+[#display_some]: #display_some
+
+The `display_some` filter is essentially a shorthand for:
+
+```text
+{% if let Some(value) = value %}{{ value }}{% endif %}
+```
+
+It can be used like this:
+
+```text
+<title>{{ title|display_some }}</title>
+```
+
+Where `title` can be any `Option<T>` as long as `T` implements [`fmt::Display`].
+
+### display_some_or
+
+[#display_some_or]: #display_some_or
+
+The `display_some_or` filter is similar to `display_some`, but allows providing
+a default value to render for `None`. In short, instead of the following:
+
+```text
+{% if let Some(value) = value %}{{ value }}{% else %}My default title{% endif %}
+```
+
+Then `display_some_or` can be used like this:
+
+```text
+<title>{{ title|display_some_or("My default title") }}</title>
+```
+
+Where `title` can be any `Option<T>` as long as `T` implements [`fmt::Display`].
+While the `default` value can be any `U` implementing [`fmt::Display`].
+
+[`fmt::Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html
+
 ### escape | e
 [#escape]: #escape--e
 

book/src/template_syntax.md

@@ -464,6 +464,20 @@ mirror Rust's [`if let` expressions]:
 {% endif %}
 ```
 
+See also the [`display_some`] and [`display_some_or`] filters, which
+can be used to simplify _"render `Some` or nothing/default"_.
+
+```text
+<title>{{ title|display_some }}</title>
+
+<title>{{ title|display_some_or("My default title") }}</title>
+```
+
+_Assuming `title` is `Option<String>`._
+
+[`display_some`]: filters.html#display_some
+[`display_some_or`]: filters.html#display_some_or
+
 [`if let` expressions]: https://doc.rust-lang.org/reference/expressions/if-expr.html#if-let-expressions
 
 ### Match

testing/tests/filters.rs

@@ -323,3 +323,76 @@ fn test_let_borrow() {
  };
  assert_eq!(template.render().unwrap(), "hello")
 }
+
+#[derive(askama::Template)]
+#[template(
+ source = "|{{ a|display_some }}|{{ b|display_some }}|{{ c|display_some }}|",
+ ext = "html"
+)]
+struct DisplaySome {
+ a: Option<String>,
+ b: Option<i32>,
+ c: Option<bool>,
+}
+
+#[test]
+fn test_display_some() {
+ let template = DisplaySome {
+ a: None,
+ b: None,
+ c: None,
+ };
+ assert_eq!(template.render().unwrap(), "||||");
+
+ let template = DisplaySome {
+ a: Some(String::from("Hello World")),
+ b: Some(12345),
+ c: Some(true),
+ };
+ assert_eq!(template.render().unwrap(), "|Hello World|12345|true|");
+}
+
+#[derive(askama::Template)]
+#[template(
+ source = "|{{ a|display_some_or(\"default\") }}|{{ b|display_some_or(0) }}|{{ c|display_some_or(\"none\") }}|",
+ ext = "html"
+)]
+struct DisplaySomeOr {
+ a: Option<String>,
+ b: Option<i32>,
+ c: Option<bool>,
+}
+
+#[test]
+fn test_display_some_or() {
+ let template = DisplaySomeOr {
+ a: None,
+ b: None,
+ c: None,
+ };
+ assert_eq!(template.render().unwrap(), "|default|0|none|");
+
+ let template = DisplaySomeOr {
+ a: Some(String::from("Hello World")),
+ b: Some(12345),
+ c: Some(true),
+ };
+ assert_eq!(template.render().unwrap(), "|Hello World|12345|true|");
+}
+
+#[derive(askama::Template)]
+#[template(
+ source = "\
+ {% set val = Some(\"Hello World\") %}|{{ val|display_some }}|\
+ {% set val = Some(123) %}{{ val|display_some }}|\
+ {% set val = Some(true) %}{{ val|display_some }}|\
+ ",
+ ext = "html"
+)]
+struct DisplaySomeUsingSet;
+
+#[test]
+fn test_display_some_using_set() {
+ let template = DisplaySomeUsingSet;
+ assert_eq!(template.render().unwrap(), "|Hello World|123|true|");
+}