cruct_shared 1.0.0

Shared library for Cruct, providing parsers and error handling
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::collections::HashMap;
use std::fs::read_to_string;

use jzon::{JsonValue, parse};

use super::{ConfigValue, Parser, ParserError};

#[derive(Clone)]
pub struct JsonParser;

impl Parser for JsonParser {
    fn extensions(&self) -> &'static [&'static str] {
        &["json"]
    }

    fn load(&self, path: &str) -> Result<ConfigValue, ParserError> {
        let content = read_to_string(path)?;
        let json = parse(&content)?;

        parse_json_value(json)
    }
}

/// Parses a JSON value into a configuration value.
///
/// * `value`: The `JsonValue` to be parsed.
fn parse_json_value(value: JsonValue) -> Result<ConfigValue, ParserError> {
    match value {
        JsonValue::Object(obj) => {
            let mut map = HashMap::new();
            for (k, v) in obj {
                map.insert(k, parse_json_value(v)?);
            }
            Ok(ConfigValue::Section(map))
        },
        JsonValue::Array(arr) => {
            let items = arr
                .into_iter()
                .map(parse_json_value)
                .collect::<Result<Vec<_>, _>>()?;
            Ok(ConfigValue::Array(items))
        },
        _ => Ok(ConfigValue::Value(value.to_string())),
    }
}

#[cfg(test)]
mod test {
    use std::collections::HashMap;

    use jzon::object::Object;

    use super::*;

    #[test]
    fn test_parse_json_value_string() {
        let value = JsonValue::String("test_string".into());
        let result = parse_json_value(value).unwrap();

        assert_eq!(result, ConfigValue::Value("test_string".into()));
    }

    #[test]
    fn test_parse_json_value_integer() {
        let value = JsonValue::Number(123.into());
        let result = parse_json_value(value).unwrap();

        assert_eq!(result, ConfigValue::Value("123".into()));
    }

    #[test]
    fn test_parse_json_value_float() {
        let value = JsonValue::Number(123.45.into());
        let result = parse_json_value(value).unwrap();

        assert_eq!(result, ConfigValue::Value("123.45".into()));
    }

    #[test]
    fn test_parse_json_value_boolean() {
        let value = JsonValue::Boolean(true);
        let result = parse_json_value(value).unwrap();

        assert_eq!(result, ConfigValue::Value("true".into()));
    }

    #[test]
    fn test_parse_json_value_object() {
        let mut obj = Object::new();
        obj.insert("key", JsonValue::String("value".into()));

        let value = JsonValue::Object(obj);
        let result = parse_json_value(value).unwrap();

        let mut expected_map = HashMap::new();
        expected_map.insert("key".into(), ConfigValue::Value("value".into()));

        assert_eq!(result, ConfigValue::Section(expected_map));
    }

    #[test]
    fn test_parse_json_value_array() {
        let value = JsonValue::Array(vec![
            JsonValue::String("item1".into()),
            JsonValue::String("item2".into()),
        ]);

        let result = parse_json_value(value).unwrap();

        assert_eq!(
            result,
            ConfigValue::Array(vec![
                ConfigValue::Value("item1".into()),
                ConfigValue::Value("item2".into())
            ])
        );
    }
}