1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use serde::{Deserialize, Serialize};

use crate::{liquid_json::LiquidJson, Error};

#[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq)]
/// A Liquid JSON value that implements Serialize/Deserialize.
#[must_use]
pub struct LiquidJsonValue(
    #[serde(serialize_with = "ser_with", deserialize_with = "deser_with")] LiquidJson,
);

impl LiquidJsonValue {
    /// Create a new Liquid JSON value from a JSON value.
    pub fn new(raw_template: serde_json::Value) -> Self {
        LiquidJsonValue(LiquidJson::new(raw_template))
    }
    /// Render the JSON template with the given data.
    pub fn render(&self, data: &serde_json::Value) -> Result<serde_json::Value, Error> {
        self.0.render(data)
    }
}

impl From<serde_json::Value> for LiquidJsonValue {
    fn from(value: serde_json::Value) -> Self {
        LiquidJsonValue::new(value)
    }
}

fn ser_with<S>(tpl: &LiquidJson, s: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    tpl.raw_template.serialize(s)
}

fn deser_with<'de, D>(deserializer: D) -> Result<LiquidJson, D::Error>
where
    D: serde::de::Deserializer<'de>,
{
    let raw_template = serde_json::Value::deserialize(deserializer)?;
    Ok(LiquidJson::new(raw_template))
}
#[cfg(test)]
mod tests {
    use ::serde::{Deserialize, Serialize};
    use rstest::rstest;
    use serde_json::{json, Value};

    use super::*;
    use anyhow::Result;

    #[derive(Serialize, Deserialize, Debug, PartialEq)]
    struct TestSerde {
        inner_liquid: LiquidJsonValue,
    }

    #[rstest]
    #[case(json!({"inner_liquid":"{{myval}}"}), json!({"myval": 5}), json!(5))]
    #[case(json!({"inner_liquid":{"key":"{{myval}}"}}), json!({"myval": 5}), json!({"key":5}))]
    #[case(json!({"inner_liquid":{"key":"{{myval}}"}}), json!({"myval": {"deeper":10}}), json!({"key":{"deeper":10}}))]
    fn serde(#[case] from_json: Value, #[case] data: Value, #[case] expected: Value) -> Result<()> {
        let deser: TestSerde = serde_json::from_value(from_json.clone())?;
        let actual = deser.inner_liquid.render(&data)?;
        assert_eq!(actual, expected);
        let to_json = serde_json::to_value(deser)?;
        assert_eq!(to_json, from_json);
        Ok(())
    }
}