mdmodels-macro 0.1.2

A procedural macro for generating models from a markdown data model
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

#[cfg(test)]
mod tests {
    use mdmodels_macro::parse_mdmodel;

    parse_mdmodel!("tests/data/model.md");

    #[test]
    fn test_model_builder() {
        // Build the 'Object' struct
        ObjectBuilder::default()
            .string_value("Hello, World!")
            .integer_value(42)
            .float_value(3.2)
            .boolean_value(true)
            .multiple_values(vec![1.12, 1.0])
            .nested_object(NestedBuilder::default().value("nested").build().unwrap())
            .multiple_nested_objects(vec![
                NestedBuilder::default().value("nested1").build().unwrap(),
                NestedBuilder::default().value("nested2").build().unwrap(),
            ])
            .enum_value(SomeEnum::Value)
            .build()
            .expect("Failed to build object");
    }

    #[test]
    fn test_model_non_builder() {
        // Build the 'Object' struct
        Object {
            additional_properties: None,
            string_value: Some("Hello, World!".to_string()),
            integer_value: Some(42),
            float_value: Some(3.2),
            boolean_value: Some(true),
            multiple_values: Some(vec![1.12, 1.0]),
            nested_object: Some(Nested {
                additional_properties: None,
                value: Some("nested".to_string()),
            }),
            multiple_nested_objects: vec![
                Nested {
                    additional_properties: None,
                    value: Some("nested1".to_string()),
                },
                Nested {
                    additional_properties: None,
                    value: Some("nested2".to_string()),
                },
            ],
            enum_value: Some(SomeEnum::Value),
        };
    }

    #[test]
    fn test_model_parser() {
        // Parse the 'Object' struct from a JSON string
        let json = r#"
            {
                "string_value": "Hello, World!",
                "integer_value": 42,
                "float_value": 3.2,
                "boolean_value": true,
                "multiple_values": [1.12, 1.0],
                "nested_object": {
                    "value": "nested"
                },
                "multiple_nested_objects": [
                    {
                        "value": "nested1"
                    },
                    {
                        "value": "nested2"
                    }
                ],
                "enum_value": "value"
            }
        "#;

        let object: Object = serde_json::from_str(json).expect("Failed to parse JSON");
        assert_eq!(object.string_value, Some("Hello, World!".to_string()));
        assert_eq!(object.integer_value, Some(42));
        assert_eq!(object.float_value, Some(3.2));
        assert_eq!(object.boolean_value, Some(true));
        assert_eq!(object.multiple_values, Some(vec![1.12, 1.0]));
        assert_eq!(
            object.nested_object.unwrap().value,
            Some("nested".to_string())
        );
        assert_eq!(object.multiple_nested_objects.len(), 2);
        assert_eq!(
            object.multiple_nested_objects[0].value,
            Some("nested1".to_string())
        );
        assert_eq!(
            object.multiple_nested_objects[1].value,
            Some("nested2".to_string())
        );
        assert_eq!(object.enum_value.unwrap(), SomeEnum::Value);
    }
}