fson 1.0.0

Flexible Serialized Object Notation
Documentation 
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

use super::{
    stringify_json,
    types::{ReferenceAsValue, Value},
    TemplateValue,
};

pub fn sanitize_string(str: String) -> String {
    str.replace('\"', "\\\"")
        .replace("\\'", "'")
        .replace("\\`", "`")
        .replace("\\n", "\n")
        .replace("\\t", "\t")
        .replace("\\r", "\n")
}

pub fn stringify_value(value: Value, ident: usize, minify: bool) -> String {
    match value {
        Value::Number(num) => num.to_string(),
        Value::Boolean(bool) => bool.to_string(),
        Value::Infinity => String::from("Infinity"),
        Value::NegativeInfinity => String::from("-Infinity"),
        Value::Null => String::from("null"),
        Value::NaN => String::from("NaN"),
        Value::String(str) => format!("\"{}\"", sanitize_string(str)),

        Value::Array(arr) => {
            let mut str = String::from("[");
            for (i, e) in arr.iter().enumerate() {
                str.push_str(
                    format!(
                        "{}{}",
                        stringify_value(e.clone(), ident, minify),
                        if i == arr.len() - 1 {
                            ""
                        } else if minify {
                            ","
                        } else {
                            ", "
                        }
                    )
                    .as_str(),
                );
            }
            str + "]"
        }

        Value::Object(_) => stringify_json::stringify(value, ident, minify),

        Value::TemplateString(val) => {
            let mut str = String::from("`");
            for e in val {
                match e {
                    TemplateValue::String(s) => str += &s,
                    TemplateValue::Interpolation(interpolation) => {
                        str += format!("${{{}}}", stringify_value(interpolation, ident, minify))
                            .as_str();
                    }
                }
            }
            str + "`"
        }

        Value::ReferenceDeclaration { id, value } => {
            let whitespace = if minify { "" } else { " " };
            format!(
                "#{{{}#id:{}{};{}#value:{}{};{}}}",
                whitespace,
                whitespace,
                stringify_value(Value::String(id), ident, minify),
                whitespace,
                whitespace,
                stringify_value(*value, ident, minify),
                whitespace,
            )
        }
        Value::Reference(reference_value) => match reference_value {
            ReferenceAsValue::Id(id) => {
                format!("#\"{}\"", sanitize_string(id))
            }
            ReferenceAsValue::Path(path) => {
                let mut sanitized_path: Vec<String> = vec![];
                for e in path {
                    sanitized_path.push(format!("\"{}\"", sanitize_string(e)));
                }
                format!("#/{}", sanitized_path.join("/"))
            }
        },

        _ => String::new(),
    }
}