Repurpose before, after filters to operate on date

Suggested-by: Vincent Prouillet <[email protected]>

Author: ccjmne

components/templates/src/filters.rs

@@ -168,63 +168,39 @@ pub fn before<S: BuildHasher>(
     value: &Value,
     args: &HashMap<String, Value, S>,
 ) -> TeraResult<Value> {
-    let inclusive = args.get("inclusive").and_then(Value::as_bool).unwrap_or(false);
-    filter_by_date(
-        value,
-        args,
-        "before",
-        if inclusive { |d: &str, t: &str| d <= t } else { |d: &str, t: &str| d < t },
-    )
-}
+    let date_str = try_get_value!("before", "value", String, value);
+    let threshold_str = match args.get("date") {
+        Some(val) => try_get_value!("before", "date", String, val),
+        None => return Err(TeraError::msg("Filter `before` expected an arg called `date`")),
+    };
+
+    let item_date = parse_filter_date(&date_str)
+        .ok_or_else(|| TeraError::msg(format!("Filter `before`: invalid date '{}'", date_str)))?;
+    let threshold_date = parse_filter_date(&threshold_str).ok_or_else(|| {
+        TeraError::msg(format!("Filter `before`: invalid date '{}'", threshold_str))
+    })?;
 
-pub fn after<S: BuildHasher>(value: &Value, args: &HashMap<String, Value, S>) -> TeraResult<Value> {
     let inclusive = args.get("inclusive").and_then(Value::as_bool).unwrap_or(false);
-    filter_by_date(
-        value,
-        args,
-        "after",
-        if inclusive { |d: &str, t: &str| d >= t } else { |d: &str, t: &str| d > t },
-    )
+    let result = if inclusive { item_date <= threshold_date } else { item_date < threshold_date };
+    Ok(to_value(result).unwrap())
 }
 
-fn filter_by_date<S: BuildHasher>(
-    value: &Value,
-    args: &HashMap<String, Value, S>,
-    dir: &str,
-    compare: impl Fn(&str, &str) -> bool,
-) -> TeraResult<Value> {
-    let date_str = match args.get("date") {
-        Some(val) => try_get_value!(dir, "date", String, val),
-        None => {
-            return Err(TeraError::msg(format!("Filter `{}` expected an arg called `date`", dir)));
-        }
+pub fn after<S: BuildHasher>(value: &Value, args: &HashMap<String, Value, S>) -> TeraResult<Value> {
+    let date_str = try_get_value!("after", "value", String, value);
+    let threshold_str = match args.get("date") {
+        Some(val) => try_get_value!("after", "date", String, val),
+        None => return Err(TeraError::msg("Filter `after` expected an arg called `date`")),
     };
 
-    let threshold_date = parse_filter_date(&date_str).ok_or_else(|| {
-        TeraError::msg(format!(
-            "Filter `{}`: invalid date format '{}'. Expected YYYY-MM-DD or RFC3339.",
-            dir, date_str
-        ))
+    let item_date = parse_filter_date(&date_str)
+        .ok_or_else(|| TeraError::msg(format!("Filter `after`: invalid date '{}'", date_str)))?;
+    let threshold_date = parse_filter_date(&threshold_str).ok_or_else(|| {
+        TeraError::msg(format!("Filter `after`: invalid date '{}'", threshold_str))
     })?;
 
-    let items = value
-        .as_array()
-        .ok_or_else(|| TeraError::msg(format!("Filter `{}` expected an array", dir)))?;
-
-    let filtered: Vec<Value> = items
-        .iter()
-        .filter(|item| {
-            item.as_object()
-                .and_then(|obj| obj.get("date"))
-                .and_then(Value::as_str)
-                .and_then(parse_filter_date)
-                .map(|item_date| compare(&item_date, &threshold_date))
-                .unwrap_or(false)
-        })
-        .cloned()
-        .collect();
-
-    Ok(to_value(filtered).unwrap())
+    let inclusive = args.get("inclusive").and_then(Value::as_bool).unwrap_or(false);
+    let result = if inclusive { item_date >= threshold_date } else { item_date > threshold_date };
+    Ok(to_value(result).unwrap())
 }
 
 fn parse_filter_date(date_str: &str) -> Option<String> {
@@ -442,75 +418,51 @@ mod tests {
 
     #[test]
     fn before_filter() {
-        use libs::serde_json::json;
-        let pages = vec![
-            json!({ "date": "2023-12-01T12:00:00Z" }),
-            json!({ "date": "2024-01-01" }),
-            json!({ "date": "2024-03-01" }),
-            json!({ "date": "2024-05-01T12:00:00Z" }),
-            json!({}),
-        ];
-        let [dec2023, jan2024, mar2024, may2024, none] = &pages[..] else { unreachable!() };
-
         let mut args = HashMap::new();
         args.insert("date".to_string(), to_value("2024-03-01").unwrap());
 
-        let result = super::before(&to_value(&pages).unwrap(), &args);
-        assert!(result.is_ok());
-        let filtered = result.unwrap().as_array().unwrap().clone();
-        assert_eq!(filtered.len(), 2);
-        assert!(filtered.contains(dec2023));
-        assert!(filtered.contains(jan2024));
-        assert!(!filtered.contains(mar2024));
-        assert!(!filtered.contains(may2024));
-        assert!(!filtered.contains(none));
+        assert_eq!(
+            super::before(&to_value("2024-01-01").unwrap(), &args).unwrap(),
+            to_value(true).unwrap()
+        );
+        assert_eq!(
+            super::before(&to_value("2024-05-01").unwrap(), &args).unwrap(),
+            to_value(false).unwrap()
+        );
+        assert_eq!(
+            super::before(&to_value("2024-03-01").unwrap(), &args).unwrap(),
+            to_value(false).unwrap()
+        );
 
         args.insert("inclusive".to_string(), to_value(true).unwrap());
-        let result = super::before(&to_value(&pages).unwrap(), &args);
-        assert!(result.is_ok());
-        let filtered = result.unwrap().as_array().unwrap().clone();
-        assert_eq!(filtered.len(), 3);
-        assert!(filtered.contains(dec2023));
-        assert!(filtered.contains(jan2024));
-        assert!(filtered.contains(mar2024));
-        assert!(!filtered.contains(may2024));
-        assert!(!filtered.contains(none));
+        assert_eq!(
+            super::before(&to_value("2024-03-01").unwrap(), &args).unwrap(),
+            to_value(true).unwrap()
+        );
     }
 
     #[test]
     fn after_filter() {
-        use libs::serde_json::json;
-        let pages = vec![
-            json!({ "date": "2023-12-01T12:00:00Z" }),
-            json!({ "date": "2024-01-01" }),
-            json!({ "date": "2024-03-01" }),
-            json!({ "date": "2024-05-01T12:00:00Z" }),
-            json!({}),
-        ];
-        let [dec2023, jan2024, mar2024, may2024, none] = &pages[..] else { unreachable!() };
-
         let mut args = HashMap::new();
         args.insert("date".to_string(), to_value("2024-03-01").unwrap());
 
-        let result = super::after(&to_value(&pages).unwrap(), &args);
-        assert!(result.is_ok());
-        let filtered = result.unwrap().as_array().unwrap().clone();
-        assert_eq!(filtered.len(), 1);
-        assert!(!filtered.contains(dec2023));
-        assert!(!filtered.contains(jan2024));
-        assert!(!filtered.contains(mar2024));
-        assert!(filtered.contains(may2024));
-        assert!(!filtered.contains(none));
+        assert_eq!(
+            super::after(&to_value("2024-01-01").unwrap(), &args).unwrap(),
+            to_value(false).unwrap()
+        );
+        assert_eq!(
+            super::after(&to_value("2024-05-01").unwrap(), &args).unwrap(),
+            to_value(true).unwrap()
+        );
+        assert_eq!(
+            super::after(&to_value("2024-03-01").unwrap(), &args).unwrap(),
+            to_value(false).unwrap()
+        );
 
         args.insert("inclusive".to_string(), to_value(true).unwrap());
-        let result = super::after(&to_value(&pages).unwrap(), &args);
-        assert!(result.is_ok());
-        let filtered = result.unwrap().as_array().unwrap().clone();
-        assert_eq!(filtered.len(), 2);
-        assert!(!filtered.contains(dec2023));
-        assert!(!filtered.contains(jan2024));
-        assert!(filtered.contains(mar2024));
-        assert!(filtered.contains(may2024));
-        assert!(!filtered.contains(none));
+        assert_eq!(
+            super::after(&to_value("2024-03-01").unwrap(), &args).unwrap(),
+            to_value(true).unwrap()
+        );
     }
 }

docs/content/documentation/templates/overview.md

@@ -112,35 +112,39 @@ To format a number for a specific locale, you can use the `locale` argument and
 ```
 
 ### before
-Filters an array of pages/sections to keep only items with a `date` field before the specified date.  Items without a `date` field are excluded.
+Returns `true` if a date is before the specified date, `false` otherwise.
 
-By default, the filter is exclusive (items matching the date are excluded). Set `inclusive=true` to include items matching the date.
+By default, the filter is exclusive (the boundary date returns `false`). Set `inclusive=true` to include the boundary date.
 
 ```jinja2
-{% for page in section.pages | before(date="2020-03-10") %}
-  <h2>{{ page.title }}</h2>
+{% for page in section.pages %}
+  {% if page.date | before(date="2020-03-10") %}
+    <h2>{{ page.title }}</h2>
+  {% endif %}
 {% endfor %}
 
-{# Include pages from 2020-03-10 and earlier #}
-{% for page in section.pages | before(date="2020-03-10", inclusive=true) %}
-  <h2>{{ page.title }}</h2>
-{% endfor %}
+{# Include the boundary date #}
+{% if page.date | before(date="2020-03-10", inclusive=true) %}
+  ...
+{% endif %}
 ```
 
 ### after
-Filters an array of pages/sections to keep only items with a `date` field after the specified date.  Items without a `date` field are excluded.
+Returns `true` if a date is after the specified date, `false` otherwise.
 
-By default, the filter is exclusive (items matching the date are excluded). Set `inclusive=true` to include items matching the date.
+By default, the filter is exclusive (the boundary date returns `false`). Set `inclusive=true` to include the boundary date.
 
 ```jinja2
-{% for page in section.pages | after(date="2020-03-10") %}
-  <h2>{{ page.title }}</h2>
+{% for page in section.pages %}
+  {% if page.date | after(date="2020-03-10") %}
+    <h2>{{ page.title }}</h2>
+  {% endif %}
 {% endfor %}
 
-{# Include pages from 2020-03-10 and later #}
-{% for page in section.pages | after(date="2020-03-10", inclusive=true) %}
-  <h2>{{ page.title }}</h2>
-{% endfor %}
+{# Include the boundary date #}
+{% if page.date | after(date="2020-03-10", inclusive=true) %}
+  ...
+{% endif %}
 ```
 
 ## Built-in functions