From 462c04c0a07da057878877777f7fb9505f5af66d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9=20Kijewski?= <rene.kijewski@fu-berlin.de>
Date: Sun, 28 Apr 2024 13:48:09 +0200
Subject: [PATCH 1/4] Make JSON prettifying optional

This PR adds an optional argument to the `|tojson` filter, which
controls if the serialized JSON data gets prettified or not. The
arguments works the same as flask's [`|tojson`][flask] filter, which
passes the argument to python's [`json.dumps()`][python]:

* Omitting the argument, providing a negative integer, or `None`, then
  compact JSON data is generated.
* Providing a non-negative integer, then this amount of ASCII spaces is
  used to indent the data. (Capped to 16 characters.)
* Providing a string, then this string is used as prefix. I attempts are
  made to ensure that the prefix actually consists of whitespaces,
  because chances are, that if you provide e.g. `&nsbp;`, then you are
  doing it intentionally.

This is a breaking change, because it changes the default behavior to
not prettify the data. This is done intentionally, because this is how
it works in flask.

[flask]: https://jinja.palletsprojects.com/en/3.1.x/templates/#jinja-filters.tojson
[python]: https://docs.python.org/3/library/json.html#json.dump
---
 book/src/filters.md                      |  12 ++
 rinja/benches/to-json.rs                 |   4 +-
 rinja/src/filters/json.rs                | 151 ++++++++++++++++++++---
 rinja/src/filters/mod.rs                 |   2 +-
 rinja_derive/src/generator.rs            |   8 +-
 testing/templates/allow-whitespaces.html |  10 +-
 testing/templates/json.html              |   4 -
 testing/tests/filters.rs                 |  72 ++++++++++-
 8 files changed, 233 insertions(+), 30 deletions(-)
 delete mode 100644 testing/templates/json.html

diff --git a/book/src/filters.md b/book/src/filters.md
index 95b92f07..e52f97e6 100644
--- a/book/src/filters.md
+++ b/book/src/filters.md
@@ -468,6 +468,18 @@ Ugly: <script>var data = "{{data|json}}";</script>
 Ugly: <script>var data = '{{data|json|safe}}';</script>
 ```
 
+By default, a compact representation of the data is generated, i.e. no whitespaces are generated
+between individual values. To generate a readable representation, you can either pass an integer
+how many spaces to use as indentation, or you can pass a string that gets used as prefix:
+
+```jinja2
+Prefix with four spaces:
+<textarea>{{data|tojson(4)}}</textarea>
+
+Prefix with two &nbsp; characters:
+<p>{{data|tojson("\u{a0}\u{a0}")}}</p>
+```
+
 ## Custom Filters
 [#custom-filters]: #custom-filters
 
diff --git a/rinja/benches/to-json.rs b/rinja/benches/to-json.rs
index da6444f3..cb6ea877 100644
--- a/rinja/benches/to-json.rs
+++ b/rinja/benches/to-json.rs
@@ -13,7 +13,7 @@ fn functions(c: &mut Criterion) {
 fn escape_json(b: &mut criterion::Bencher<'_>) {
     b.iter(|| {
         for &s in STRINGS {
-            format!("{}", json(s).unwrap());
+            format!("{}", json(s, ()).unwrap());
         }
     });
 }
@@ -21,7 +21,7 @@ fn escape_json(b: &mut criterion::Bencher<'_>) {
 fn escape_json_for_html(b: &mut criterion::Bencher<'_>) {
     b.iter(|| {
         for &s in STRINGS {
-            format!("{}", MarkupDisplay::new_unsafe(json(s).unwrap(), Html));
+            format!("{}", MarkupDisplay::new_unsafe(json(s, ()).unwrap(), Html));
         }
     });
 }
diff --git a/rinja/src/filters/json.rs b/rinja/src/filters/json.rs
index 93091824..a108ccfc 100644
--- a/rinja/src/filters/json.rs
+++ b/rinja/src/filters/json.rs
@@ -2,7 +2,7 @@ use std::convert::Infallible;
 use std::{fmt, io, str};
 
 use serde::Serialize;
-use serde_json::to_writer_pretty;
+use serde_json::ser::{to_writer, PrettyFormatter, Serializer};
 
 /// Serialize to JSON (requires `json` feature)
 ///
@@ -19,17 +19,105 @@ use serde_json::to_writer_pretty;
 /// or in apostrophes with the (optional) safe filter `'{{data|json|safe}}'`.
 /// In HTML texts the output of e.g. `<pre>{{data|json|safe}}</pre>` is safe, too.
 #[inline]
-pub fn json<S: Serialize>(s: S) -> Result<impl fmt::Display, Infallible> {
-    Ok(ToJson(s))
+pub fn json(value: impl Serialize, indent: impl AsIndent) -> Result<impl fmt::Display, Infallible> {
+    Ok(ToJson { value, indent })
+}
+
+pub trait AsIndent {
+    fn as_indent(&self) -> Option<&str>;
+}
+
+impl AsIndent for str {
+    #[inline]
+    fn as_indent(&self) -> Option<&str> {
+        Some(self)
+    }
+}
+
+impl AsIndent for String {
+    #[inline]
+    fn as_indent(&self) -> Option<&str> {
+        Some(self)
+    }
+}
+
+impl AsIndent for isize {
+    fn as_indent(&self) -> Option<&str> {
+        const SPACES: &str = "                ";
+        match *self < 0 {
+            true => None,
+            false => Some(&SPACES[..(*self as usize).min(SPACES.len())]),
+        }
+    }
+}
+
+impl AsIndent for () {
+    #[inline]
+    fn as_indent(&self) -> Option<&str> {
+        None
+    }
+}
+
+impl<T: AsIndent + ?Sized> AsIndent for &T {
+    #[inline]
+    fn as_indent(&self) -> Option<&str> {
+        T::as_indent(self)
+    }
+}
+
+impl<T: AsIndent> AsIndent for Option<T> {
+    #[inline]
+    fn as_indent(&self) -> Option<&str> {
+        self.as_ref().and_then(T::as_indent)
+    }
+}
+
+impl<T: AsIndent + ?Sized> AsIndent for Box<T> {
+    #[inline]
+    fn as_indent(&self) -> Option<&str> {
+        T::as_indent(self.as_ref())
+    }
+}
+
+impl<T: AsIndent + ToOwned + ?Sized> AsIndent for std::borrow::Cow<'_, T> {
+    #[inline]
+    fn as_indent(&self) -> Option<&str> {
+        T::as_indent(self.as_ref())
+    }
+}
+
+impl<T: AsIndent + ?Sized> AsIndent for std::rc::Rc<T> {
+    #[inline]
+    fn as_indent(&self) -> Option<&str> {
+        T::as_indent(self.as_ref())
+    }
+}
+
+impl<T: AsIndent + ?Sized> AsIndent for std::sync::Arc<T> {
+    #[inline]
+    fn as_indent(&self) -> Option<&str> {
+        T::as_indent(self.as_ref())
+    }
 }
 
 #[derive(Debug, Clone)]
-struct ToJson<S: Serialize>(S);
+struct ToJson<S, I> {
+    value: S,
+    indent: I,
+}
 
-impl<S: Serialize> fmt::Display for ToJson<S> {
-    #[inline]
+impl<S: Serialize, I: AsIndent> fmt::Display for ToJson<S, I> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        to_writer_pretty(JsonWriter(f), &self.0).map_err(|_| fmt::Error)
+        let f = JsonWriter(f);
+        if let Some(indent) = self.indent.as_indent() {
+            let formatter = PrettyFormatter::with_indent(indent.as_bytes());
+            let mut serializer = Serializer::with_formatter(f, formatter);
+            self.value
+                .serialize(&mut serializer)
+                .map_err(|_| fmt::Error)
+        } else {
+            to_writer(f, &self.value).map_err(|_| fmt::Error)
+        }
     }
 }
 
@@ -77,20 +165,55 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_json() {
-        assert_eq!(json(true).unwrap().to_string(), "true");
-        assert_eq!(json("foo").unwrap().to_string(), r#""foo""#);
-        assert_eq!(json(true).unwrap().to_string(), "true");
-        assert_eq!(json("foo").unwrap().to_string(), r#""foo""#);
+    fn test_ugly() {
+        assert_eq!(json(true, ()).unwrap().to_string(), "true");
+        assert_eq!(json("foo", ()).unwrap().to_string(), r#""foo""#);
+        assert_eq!(json(true, ()).unwrap().to_string(), "true");
+        assert_eq!(json("foo", ()).unwrap().to_string(), r#""foo""#);
         assert_eq!(
-            json("<script>").unwrap().to_string(),
+            json("<script>", ()).unwrap().to_string(),
             r#""\u003cscript\u003e""#
         );
         assert_eq!(
-            json(vec!["foo", "bar"]).unwrap().to_string(),
+            json(vec!["foo", "bar"], ()).unwrap().to_string(),
+            r#"["foo","bar"]"#
+        );
+        assert_eq!(json(true, -1).unwrap().to_string(), "true");
+        assert_eq!(json(true, Some(())).unwrap().to_string(), "true");
+        assert_eq!(
+            json(true, &Some(None::<isize>)).unwrap().to_string(),
+            "true"
+        );
+    }
+
+    #[test]
+    fn test_pretty() {
+        assert_eq!(json(true, "").unwrap().to_string(), "true");
+        assert_eq!(
+            json("<script>", Some("")).unwrap().to_string(),
+            r#""\u003cscript\u003e""#
+        );
+        assert_eq!(
+            json(vec!["foo", "bar"], Some("")).unwrap().to_string(),
+            r#"[
+"foo",
+"bar"
+]"#
+        );
+        assert_eq!(
+            json(vec!["foo", "bar"], 2).unwrap().to_string(),
             r#"[
   "foo",
   "bar"
+]"#
+        );
+        assert_eq!(
+            json(vec!["foo", "bar"], &Some(&"————"))
+                .unwrap()
+                .to_string(),
+            r#"[
+————"foo",
+————"bar"
 ]"#
         );
     }
diff --git a/rinja/src/filters/mod.rs b/rinja/src/filters/mod.rs
index e30baf22..3e4a0e3f 100644
--- a/rinja/src/filters/mod.rs
+++ b/rinja/src/filters/mod.rs
@@ -10,7 +10,7 @@ use std::fmt::{self, Write};
 #[cfg(feature = "serde_json")]
 mod json;
 #[cfg(feature = "serde_json")]
-pub use self::json::json;
+pub use self::json::{json, AsIndent};
 
 #[cfg(feature = "humansize")]
 use humansize::{ISizeFormatter, ToF64, DECIMAL};
diff --git a/rinja_derive/src/generator.rs b/rinja_derive/src/generator.rs
index ec088c5a..9afc9110 100644
--- a/rinja_derive/src/generator.rs
+++ b/rinja_derive/src/generator.rs
@@ -1364,12 +1364,14 @@ impl<'a> Generator<'a> {
             ));
         }
 
-        if args.len() != 1 {
-            return Err(ctx.generate_error("unexpected argument(s) in `json` filter", node));
-        }
         buf.write(CRATE);
         buf.write("::filters::json(");
         self._visit_args(ctx, buf, args)?;
+        match args.len() {
+            1 => buf.write(", ()"),
+            2 => {}
+            _ => return Err(ctx.generate_error("unexpected argument(s) in `json` filter", node)),
+        }
         buf.write(")?");
         Ok(DisplayWrap::Unwrapped)
     }
diff --git a/testing/templates/allow-whitespaces.html b/testing/templates/allow-whitespaces.html
index dbe65537..f31bbce5 100644
--- a/testing/templates/allow-whitespaces.html
+++ b/testing/templates/allow-whitespaces.html
@@ -25,11 +25,11 @@
 {% let hash = &nested_1.nested_2.hash %}
 #}
 
-{{ array| json }}
-{{ array[..]| json }}{{ array [ .. ]| json }}
-{{ array[1..2]| json }}{{ array [ 1 .. 2 ]| json }}
-{{ array[1..=2]| json }}{{ array [ 1 ..= 2 ]| json }}
-{{ array[(0+1)..(3-1)]| json }}{{ array [ ( 0 + 1 ) .. ( 3 - 1 ) ]| json }}
+{{ array| json(2) }}
+{{ array[..]| json(2) }}{{ array [ .. ]| json(2) }}
+{{ array[1..2]| json(2) }}{{ array [ 1 .. 2 ]| json(2) }}
+{{ array[1..=2]| json(2) }}{{ array [ 1 ..= 2 ]| json(2) }}
+{{ array[(0+1)..(3-1)]| json(2) }}{{ array [ ( 0 + 1 ) .. ( 3 - 1 ) ]| json(2) }}
 
 {{-1}}{{ -1 }}{{ - 1 }}
 {{1+2}}{{ 1+2 }}{{ 1 +2 }}{{ 1+ 2 }} {{ 1 + 2 }}
diff --git a/testing/templates/json.html b/testing/templates/json.html
deleted file mode 100644
index a1855ca8..00000000
--- a/testing/templates/json.html
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "foo": "{{ foo }}",
-  "bar": {{ bar|json|safe }}
-}
diff --git a/testing/tests/filters.rs b/testing/tests/filters.rs
index 7e24fe7d..0d249c3e 100644
--- a/testing/tests/filters.rs
+++ b/testing/tests/filters.rs
@@ -164,7 +164,13 @@ fn test_vec_join() {
 
 #[cfg(feature = "serde_json")]
 #[derive(Template)]
-#[template(path = "json.html")]
+#[template(
+    source = r#"{
+  "foo": "{{ foo }}",
+  "bar": {{ bar|json|safe }}
+}"#,
+    ext = "txt"
+)]
 struct JsonTemplate<'a> {
     foo: &'a str,
     bar: &'a Value,
@@ -178,6 +184,37 @@ fn test_json() {
         foo: "a",
         bar: &val,
     };
+    assert_eq!(
+        t.render().unwrap(),
+        r#"{
+  "foo": "a",
+  "bar": {"arr":["one",2,true,null]}
+}"#
+    );
+}
+
+#[cfg(feature = "serde-json")]
+#[derive(Template)]
+#[template(
+    source = r#"{
+  "foo": "{{ foo }}",
+  "bar": {{ bar|json(2)|safe }}
+}"#,
+    ext = "txt"
+)]
+struct PrettyJsonTemplate<'a> {
+    foo: &'a str,
+    bar: &'a Value,
+}
+
+#[cfg(feature = "serde-json")]
+#[test]
+fn test_pretty_json() {
+    let val = json!({"arr": [ "one", 2, true, null ]});
+    let t = PrettyJsonTemplate {
+        foo: "a",
+        bar: &val,
+    };
     // Note: the json filter lacks a way to specify initial indentation
     assert_eq!(
         t.render().unwrap(),
@@ -195,6 +232,39 @@ fn test_json() {
     );
 }
 
+#[cfg(feature = "serde-json")]
+#[derive(Template)]
+#[template(source = r#"{{ bar|json(indent)|safe }}"#, ext = "txt")]
+struct DynamicJsonTemplate<'a> {
+    bar: &'a Value,
+    indent: Option<&'a str>,
+}
+
+#[cfg(feature = "serde-json")]
+#[test]
+fn test_dynamic_json() {
+    let val = json!({"arr": ["one", 2]});
+    let t = DynamicJsonTemplate {
+        bar: &val,
+        indent: Some("?"),
+    };
+    assert_eq!(
+        t.render().unwrap(),
+        r#"{
+?"arr": [
+??"one",
+??2
+?]
+}"#
+    );
+
+    let t = DynamicJsonTemplate {
+        bar: &val,
+        indent: None,
+    };
+    assert_eq!(t.render().unwrap(), r#"{"arr":["one",2]}"#);
+}
+
 #[derive(Template)]
 #[template(source = "{{ x|mytrim|safe }}", ext = "html")]
 struct NestedFilterTemplate {

From f7710a94d6f2f1d1db9f9fa8021d44c5fc0d77ed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9=20Kijewski?= <rene.kijewski@fu-berlin.de>
Date: Tue, 25 Jun 2024 00:42:28 +0200
Subject: [PATCH 2/4] Add "json: too many args" ui test

---
 testing/Cargo.toml                         |  1 +
 testing/tests/ui/json-too-many-args.rs     | 10 ++++++++++
 testing/tests/ui/json-too-many-args.stderr |  9 +++++++++
 3 files changed, 20 insertions(+)
 create mode 100644 testing/tests/ui/json-too-many-args.rs
 create mode 100644 testing/tests/ui/json-too-many-args.stderr

diff --git a/testing/Cargo.toml b/testing/Cargo.toml
index 7fcfff9c..76f8ca24 100644
--- a/testing/Cargo.toml
+++ b/testing/Cargo.toml
@@ -17,6 +17,7 @@ phf = { version = "0.11", features = ["macros" ]}
 serde_json = { version = "1.0", optional = true }
 
 [dev-dependencies]
+rinja = { path = "../rinja", version = "0.13", features = ["serde_json"] }
 criterion = "0.5"
 trybuild = "1.0.76"
 
diff --git a/testing/tests/ui/json-too-many-args.rs b/testing/tests/ui/json-too-many-args.rs
new file mode 100644
index 00000000..a58bfce5
--- /dev/null
+++ b/testing/tests/ui/json-too-many-args.rs
@@ -0,0 +1,10 @@
+#![cfg(feature = "serde_json")]
+
+use rinja::Template;
+
+#[derive(Template)]
+#[template(ext = "txt", source = "{{ 1|json(2, 3) }}")]
+struct OneTwoThree;
+
+fn main() {
+}
diff --git a/testing/tests/ui/json-too-many-args.stderr b/testing/tests/ui/json-too-many-args.stderr
new file mode 100644
index 00000000..6ecd1c41
--- /dev/null
+++ b/testing/tests/ui/json-too-many-args.stderr
@@ -0,0 +1,9 @@
+error: unexpected argument(s) in `json` filter
+ --> OneTwoThree.txt:1:3
+       "1|json(2, 3) }}"
+ --> tests/ui/json-too-many-args.rs:5:10
+  |
+5 | #[derive(Template)]
+  |          ^^^^^^^^
+  |
+  = note: this error originates in the derive macro `Template` (in Nightly builds, run with -Z macro-backtrace for more info)

From 64a8094aaff1f9d224b32852e4c493ab826c3f99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9=20Kijewski?=
 <kijewski@library.vetmed.fu-berlin.de>
Date: Wed, 26 Jun 2024 12:57:14 +0200
Subject: [PATCH 3/4] Split pretty and ugly JSON filter impl

---
 rinja/benches/to-json.rs      |  28 ++++++-
 rinja/src/filters/json.rs     | 139 ++++++++++++++++++----------------
 rinja/src/filters/mod.rs      |   2 +-
 rinja_derive/src/generator.rs |  14 ++--
 testing/tests/filters.rs      |  10 +--
 5 files changed, 108 insertions(+), 85 deletions(-)

diff --git a/rinja/benches/to-json.rs b/rinja/benches/to-json.rs
index cb6ea877..46759fa3 100644
--- a/rinja/benches/to-json.rs
+++ b/rinja/benches/to-json.rs
@@ -1,5 +1,5 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use rinja::filters::json;
+use rinja::filters::{json, json_pretty};
 use rinja_escape::{Html, MarkupDisplay};
 
 criterion_main!(benches);
@@ -7,13 +7,24 @@ criterion_group!(benches, functions);
 
 fn functions(c: &mut Criterion) {
     c.bench_function("escape JSON", escape_json);
+    c.bench_function("escape JSON (pretty)", escape_json_pretty);
     c.bench_function("escape JSON for HTML", escape_json_for_html);
+    c.bench_function("escape JSON for HTML (pretty)", escape_json_for_html);
+    c.bench_function("escape JSON for HTML (pretty)", escape_json_for_html_pretty);
 }
 
 fn escape_json(b: &mut criterion::Bencher<'_>) {
     b.iter(|| {
         for &s in STRINGS {
-            format!("{}", json(s, ()).unwrap());
+            format!("{}", json(s).unwrap());
+        }
+    });
+}
+
+fn escape_json_pretty(b: &mut criterion::Bencher<'_>) {
+    b.iter(|| {
+        for &s in STRINGS {
+            format!("{}", json_pretty(s, 2).unwrap());
         }
     });
 }
@@ -21,7 +32,18 @@ fn escape_json(b: &mut criterion::Bencher<'_>) {
 fn escape_json_for_html(b: &mut criterion::Bencher<'_>) {
     b.iter(|| {
         for &s in STRINGS {
-            format!("{}", MarkupDisplay::new_unsafe(json(s, ()).unwrap(), Html));
+            format!("{}", MarkupDisplay::new_unsafe(json(s).unwrap(), Html));
+        }
+    });
+}
+
+fn escape_json_for_html_pretty(b: &mut criterion::Bencher<'_>) {
+    b.iter(|| {
+        for &s in STRINGS {
+            format!(
+                "{}",
+                MarkupDisplay::new_unsafe(json_pretty(s, 2).unwrap(), Html),
+            );
         }
     });
 }
diff --git a/rinja/src/filters/json.rs b/rinja/src/filters/json.rs
index a108ccfc..14b3f40b 100644
--- a/rinja/src/filters/json.rs
+++ b/rinja/src/filters/json.rs
@@ -19,105 +19,120 @@ use serde_json::ser::{to_writer, PrettyFormatter, Serializer};
 /// or in apostrophes with the (optional) safe filter `'{{data|json|safe}}'`.
 /// In HTML texts the output of e.g. `<pre>{{data|json|safe}}</pre>` is safe, too.
 #[inline]
-pub fn json(value: impl Serialize, indent: impl AsIndent) -> Result<impl fmt::Display, Infallible> {
-    Ok(ToJson { value, indent })
+pub fn json(value: impl Serialize) -> Result<impl fmt::Display, Infallible> {
+    Ok(ToJson { value })
+}
+
+/// Serialize to formatted/prettified JSON (requires `json` feature)
+///
+/// This filter works the same as [`json()`], but it formats the data for human readability.
+/// It has an additional "indent" argument, which can either be an integer how many spaces to use
+/// for indentation (capped to 16 characters), or a string (e.g. `"\u{A0}\u{A0}"` for two
+/// non-breaking spaces).
+///
+/// ### Note
+///
+/// In rinja's template language, this filter is called `|json`, too. The right function is
+/// automatically selected depending on whether an `indent` argument was provided or not.
+#[inline]
+pub fn json_pretty(
+    value: impl Serialize,
+    indent: impl AsIndent,
+) -> Result<impl fmt::Display, Infallible> {
+    Ok(ToJsonPretty { value, indent })
+}
+
+#[derive(Debug, Clone)]
+struct ToJson<S> {
+    value: S,
+}
+
+#[derive(Debug, Clone)]
+struct ToJsonPretty<S, I> {
+    value: S,
+    indent: I,
 }
 
 pub trait AsIndent {
-    fn as_indent(&self) -> Option<&str>;
+    fn as_indent(&self) -> &str;
 }
 
 impl AsIndent for str {
     #[inline]
-    fn as_indent(&self) -> Option<&str> {
-        Some(self)
+    fn as_indent(&self) -> &str {
+        self
     }
 }
 
 impl AsIndent for String {
     #[inline]
-    fn as_indent(&self) -> Option<&str> {
-        Some(self)
+    fn as_indent(&self) -> &str {
+        self
     }
 }
 
-impl AsIndent for isize {
-    fn as_indent(&self) -> Option<&str> {
-        const SPACES: &str = "                ";
-        match *self < 0 {
-            true => None,
-            false => Some(&SPACES[..(*self as usize).min(SPACES.len())]),
-        }
-    }
-}
-
-impl AsIndent for () {
+impl AsIndent for usize {
     #[inline]
-    fn as_indent(&self) -> Option<&str> {
-        None
+    fn as_indent(&self) -> &str {
+        const MAX_SPACES: usize = 16;
+        const SPACES: &str = match str::from_utf8(&[b' '; MAX_SPACES]) {
+            Ok(spaces) => spaces,
+            Err(_) => panic!(),
+        };
+
+        &SPACES[..(*self).min(SPACES.len())]
     }
 }
 
 impl<T: AsIndent + ?Sized> AsIndent for &T {
     #[inline]
-    fn as_indent(&self) -> Option<&str> {
+    fn as_indent(&self) -> &str {
         T::as_indent(self)
     }
 }
 
-impl<T: AsIndent> AsIndent for Option<T> {
-    #[inline]
-    fn as_indent(&self) -> Option<&str> {
-        self.as_ref().and_then(T::as_indent)
-    }
-}
-
 impl<T: AsIndent + ?Sized> AsIndent for Box<T> {
     #[inline]
-    fn as_indent(&self) -> Option<&str> {
+    fn as_indent(&self) -> &str {
         T::as_indent(self.as_ref())
     }
 }
 
 impl<T: AsIndent + ToOwned + ?Sized> AsIndent for std::borrow::Cow<'_, T> {
     #[inline]
-    fn as_indent(&self) -> Option<&str> {
+    fn as_indent(&self) -> &str {
         T::as_indent(self.as_ref())
     }
 }
 
 impl<T: AsIndent + ?Sized> AsIndent for std::rc::Rc<T> {
     #[inline]
-    fn as_indent(&self) -> Option<&str> {
+    fn as_indent(&self) -> &str {
         T::as_indent(self.as_ref())
     }
 }
 
 impl<T: AsIndent + ?Sized> AsIndent for std::sync::Arc<T> {
     #[inline]
-    fn as_indent(&self) -> Option<&str> {
+    fn as_indent(&self) -> &str {
         T::as_indent(self.as_ref())
     }
 }
 
-#[derive(Debug, Clone)]
-struct ToJson<S, I> {
-    value: S,
-    indent: I,
+impl<S: Serialize> fmt::Display for ToJson<S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        to_writer(JsonWriter(f), &self.value).map_err(|_| fmt::Error)
+    }
 }
 
-impl<S: Serialize, I: AsIndent> fmt::Display for ToJson<S, I> {
+impl<S: Serialize, I: AsIndent> fmt::Display for ToJsonPretty<S, I> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let f = JsonWriter(f);
-        if let Some(indent) = self.indent.as_indent() {
-            let formatter = PrettyFormatter::with_indent(indent.as_bytes());
-            let mut serializer = Serializer::with_formatter(f, formatter);
-            self.value
-                .serialize(&mut serializer)
-                .map_err(|_| fmt::Error)
-        } else {
-            to_writer(f, &self.value).map_err(|_| fmt::Error)
-        }
+        let indent = self.indent.as_indent();
+        let formatter = PrettyFormatter::with_indent(indent.as_bytes());
+        let mut serializer = Serializer::with_formatter(JsonWriter(f), formatter);
+        self.value
+            .serialize(&mut serializer)
+            .map_err(|_| fmt::Error)
     }
 }
 
@@ -166,51 +181,43 @@ mod tests {
 
     #[test]
     fn test_ugly() {
-        assert_eq!(json(true, ()).unwrap().to_string(), "true");
-        assert_eq!(json("foo", ()).unwrap().to_string(), r#""foo""#);
-        assert_eq!(json(true, ()).unwrap().to_string(), "true");
-        assert_eq!(json("foo", ()).unwrap().to_string(), r#""foo""#);
+        assert_eq!(json(true).unwrap().to_string(), "true");
+        assert_eq!(json("foo").unwrap().to_string(), r#""foo""#);
+        assert_eq!(json(true).unwrap().to_string(), "true");
+        assert_eq!(json("foo").unwrap().to_string(), r#""foo""#);
         assert_eq!(
-            json("<script>", ()).unwrap().to_string(),
+            json("<script>").unwrap().to_string(),
             r#""\u003cscript\u003e""#
         );
         assert_eq!(
-            json(vec!["foo", "bar"], ()).unwrap().to_string(),
+            json(vec!["foo", "bar"]).unwrap().to_string(),
             r#"["foo","bar"]"#
         );
-        assert_eq!(json(true, -1).unwrap().to_string(), "true");
-        assert_eq!(json(true, Some(())).unwrap().to_string(), "true");
-        assert_eq!(
-            json(true, &Some(None::<isize>)).unwrap().to_string(),
-            "true"
-        );
     }
 
     #[test]
     fn test_pretty() {
-        assert_eq!(json(true, "").unwrap().to_string(), "true");
+        assert_eq!(json_pretty(true, "").unwrap().to_string(), "true");
         assert_eq!(
-            json("<script>", Some("")).unwrap().to_string(),
+            json_pretty("<script>", "").unwrap().to_string(),
             r#""\u003cscript\u003e""#
         );
         assert_eq!(
-            json(vec!["foo", "bar"], Some("")).unwrap().to_string(),
+            json_pretty(vec!["foo", "bar"], "").unwrap().to_string(),
             r#"[
 "foo",
 "bar"
 ]"#
         );
         assert_eq!(
-            json(vec!["foo", "bar"], 2).unwrap().to_string(),
+            json_pretty(vec!["foo", "bar"], 2).unwrap().to_string(),
             r#"[
   "foo",
   "bar"
 ]"#
         );
         assert_eq!(
-            json(vec!["foo", "bar"], &Some(&"————"))
-                .unwrap()
-                .to_string(),
+            json_pretty(vec!["foo", "bar"], "————").unwrap().to_string(),
             r#"[
 ————"foo",
 ————"bar"
diff --git a/rinja/src/filters/mod.rs b/rinja/src/filters/mod.rs
index 3e4a0e3f..2405ccc0 100644
--- a/rinja/src/filters/mod.rs
+++ b/rinja/src/filters/mod.rs
@@ -10,7 +10,7 @@ use std::fmt::{self, Write};
 #[cfg(feature = "serde_json")]
 mod json;
 #[cfg(feature = "serde_json")]
-pub use self::json::{json, AsIndent};
+pub use self::json::{json, json_pretty, AsIndent};
 
 #[cfg(feature = "humansize")]
 use humansize::{ISizeFormatter, ToF64, DECIMAL};
diff --git a/rinja_derive/src/generator.rs b/rinja_derive/src/generator.rs
index 9afc9110..9e7ed9fd 100644
--- a/rinja_derive/src/generator.rs
+++ b/rinja_derive/src/generator.rs
@@ -1364,14 +1364,14 @@ impl<'a> Generator<'a> {
             ));
         }
 
-        buf.write(CRATE);
-        buf.write("::filters::json(");
-        self._visit_args(ctx, buf, args)?;
-        match args.len() {
-            1 => buf.write(", ()"),
-            2 => {}
+        let filter = match args.len() {
+            1 => "json",
+            2 => "json_pretty",
             _ => return Err(ctx.generate_error("unexpected argument(s) in `json` filter", node)),
-        }
+        };
+
+        buf.write(format_args!("{CRATE}::filters::{filter}("));
+        self._visit_args(ctx, buf, args)?;
         buf.write(")?");
         Ok(DisplayWrap::Unwrapped)
     }
diff --git a/testing/tests/filters.rs b/testing/tests/filters.rs
index 0d249c3e..57cdc71e 100644
--- a/testing/tests/filters.rs
+++ b/testing/tests/filters.rs
@@ -237,7 +237,7 @@ fn test_pretty_json() {
 #[template(source = r#"{{ bar|json(indent)|safe }}"#, ext = "txt")]
 struct DynamicJsonTemplate<'a> {
     bar: &'a Value,
-    indent: Option<&'a str>,
+    indent: &'a str,
 }
 
 #[cfg(feature = "serde-json")]
@@ -246,7 +246,7 @@ fn test_dynamic_json() {
     let val = json!({"arr": ["one", 2]});
     let t = DynamicJsonTemplate {
         bar: &val,
-        indent: Some("?"),
+        indent: "?",
     };
     assert_eq!(
         t.render().unwrap(),
@@ -257,12 +257,6 @@ fn test_dynamic_json() {
 ?]
 }"#
     );
-
-    let t = DynamicJsonTemplate {
-        bar: &val,
-        indent: None,
-    };
-    assert_eq!(t.render().unwrap(), r#"{"arr":["one",2]}"#);
 }
 
 #[derive(Template)]

From dcabf0cf1a92c0285ddeaa0dd33a8116bd7364af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ren=C3=A9=20Kijewski?=
 <kijewski@library.vetmed.fu-berlin.de>
Date: Wed, 26 Jun 2024 13:01:27 +0200
Subject: [PATCH 4/4] =?UTF-8?q?feature:=20serde-json=20=E2=86=92=20serde?=
 =?UTF-8?q?=5Fjson?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 testing/tests/filters.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/testing/tests/filters.rs b/testing/tests/filters.rs
index 57cdc71e..b6d84ae2 100644
--- a/testing/tests/filters.rs
+++ b/testing/tests/filters.rs
@@ -193,7 +193,7 @@ fn test_json() {
     );
 }
 
-#[cfg(feature = "serde-json")]
+#[cfg(feature = "serde_json")]
 #[derive(Template)]
 #[template(
     source = r#"{
@@ -207,7 +207,7 @@ struct PrettyJsonTemplate<'a> {
     bar: &'a Value,
 }
 
-#[cfg(feature = "serde-json")]
+#[cfg(feature = "serde_json")]
 #[test]
 fn test_pretty_json() {
     let val = json!({"arr": [ "one", 2, true, null ]});
@@ -232,7 +232,7 @@ fn test_pretty_json() {
     );
 }
 
-#[cfg(feature = "serde-json")]
+#[cfg(feature = "serde_json")]
 #[derive(Template)]
 #[template(source = r#"{{ bar|json(indent)|safe }}"#, ext = "txt")]
 struct DynamicJsonTemplate<'a> {
@@ -240,7 +240,7 @@ struct DynamicJsonTemplate<'a> {
     indent: &'a str,
 }
 
-#[cfg(feature = "serde-json")]
+#[cfg(feature = "serde_json")]
 #[test]
 fn test_dynamic_json() {
     let val = json!({"arr": ["one", 2]});