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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use crate::error::Error;
use clap::ValueEnum;
use serde::Serialize;

/// Format of input/output text values.
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
#[clap(about = "")]
pub enum TextFormat {
    Json,
    Yaml,
}

impl TextFormat {
    /// Convert a [serializable](Serialize) value to a string according to the specified [format](TextFormat).
    pub fn serialize(self, value: &impl Serialize) -> Result<String, Error> {
        match self {
            TextFormat::Json => serde_json::to_string_pretty(value).map_err(Error::from),
            TextFormat::Yaml => serde_yaml::to_string(value).map_err(Error::from),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::TextFormat;
    use pretty_assertions::assert_eq;
    use serde::Serialize;
    use text_block_macros::text_block;

    #[derive(Debug, Serialize)]
    struct TestSubject {
        number: i32,
        string: &'static str,
        array: &'static [TestSubject],
    }

    const TEST_SUBJECT: TestSubject = TestSubject {
        number: 123,
        string: "text",
        array: &[
            TestSubject {
                number: 0,
                string: "a",
                array: &[],
            },
            TestSubject {
                number: 1,
                string: "a",
                array: &[TestSubject {
                    number: 0,
                    string: "b",
                    array: &[],
                }],
            },
        ],
    };

    #[test]
    fn json() {
        let received = TextFormat::Json
            .serialize(&TEST_SUBJECT)
            .expect("serialize test subject");
        let expected = text_block! {
            r#"{"#
            r#"  "number": 123,"#
            r#"  "string": "text","#
            r#"  "array": ["#
            r#"    {"#
            r#"      "number": 0,"#
            r#"      "string": "a","#
            r#"      "array": []"#
            r#"    },"#
            r#"    {"#
            r#"      "number": 1,"#
            r#"      "string": "a","#
            r#"      "array": ["#
            r#"        {"#
            r#"          "number": 0,"#
            r#"          "string": "b","#
            r#"          "array": []"#
            r#"        }"#
            r#"      ]"#
            r#"    }"#
            r#"  ]"#
            r#"}"#
        };
        eprintln!("RECEIVED:\n{received}");
        assert_eq!(received, expected);
    }

    #[test]
    fn yaml() {
        let received = TextFormat::Yaml
            .serialize(&TEST_SUBJECT)
            .expect("serialize test subject");
        let expected = text_block! {
            "number: 123"
            "string: text"
            "array:"
            "- number: 0"
            "  string: a"
            "  array: []"
            "- number: 1"
            "  string: a"
            "  array:"
            "  - number: 0"
            "    string: b"
            "    array: []"
            ""
        };
        eprintln!("RECEIVED:\n{received}");
        assert_eq!(received, expected);
    }
}