schematools 0.22.4

Tools for codegen, preprocessing and validation of json-schema and openapi spec
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
119
120
121
122
123
124
125
126

use serde_json::{Map, Value};

use super::{
    types::{EnumType, Model, ModelType},
    JsonSchemaExtractOptions,
};
use crate::scope::SchemaScope;

pub fn convert_to_enum(
    model: Model,
    schema: &Map<String, Value>,
    scope: &mut SchemaScope,
    _options: &JsonSchemaExtractOptions,
) -> Model {
    match schema.get("enum") {
        Some(value) => match value {
            Value::Array(values) => {
                // enum model generated only for primitive types
                if let ModelType::PrimitiveType(primitive) = model.inner() {
                    log::trace!("{}: processing enum", scope);

                    let name = scope.namer().simple();
                    if name.is_err() {
                        log::error!("Cannot resolve name of enum");

                        return Model::new(ModelType::PrimitiveType(primitive.clone()));
                    }

                    let mut partitioned: (Vec<String>, Vec<f64>) = (vec![], vec![]);
                    for value in values {
                        match value {
                            Value::String(m) => partitioned.0.push(m.clone()),
                            Value::Number(m) => partitioned.1.push(m.as_f64().unwrap()),
                            _ => log::error!(
                                "{}: processing enum, field type not accepted: {}",
                                scope,
                                primitive.type_
                            ),
                        }
                    }

                    if !partitioned.0.is_empty() {
                        Model::new(ModelType::EnumType(EnumType {
                            name: name.unwrap(),
                            type_: "string".to_string(),
                            variants: partitioned.0.to_vec(),
                        }))
                    } else if !partitioned.1.is_empty() {
                        Model::new(ModelType::EnumType(EnumType {
                            name: name.unwrap(),
                            type_: "number".to_string(),
                            variants: partitioned
                                .1
                                .iter()
                                .map(|f| f.to_string())
                                .collect::<Vec<String>>(),
                        }))
                    } else {
                        log::error!("{}: enum discarded", scope);
                        Model::new(ModelType::PrimitiveType(primitive.clone()))
                    }
                } else {
                    log::warn!("{}: enum ignored because of complex type", scope);
                    model
                }
            }
            _ => {
                log::warn!("{}: incorrect enum type, skipping", scope);
                model
            }
        },
        None => model,
    }
}

#[cfg(test)]
mod tests {
    use crate::codegen::jsonschema::types::PrimitiveType;

    use super::*;
    use serde_json::json;

    #[test]
    fn test_should_convert_to_enum() {
        let schema = json!({"enum": ["a", "b"]});
        let mut scope = SchemaScope::default();
        let options = JsonSchemaExtractOptions::default();
        let model = Model::new(ModelType::PrimitiveType(PrimitiveType {
            name: None,
            type_: "string".to_string(),
        }));

        scope.entity("TestName");
        let result = convert_to_enum(model, schema.as_object().unwrap(), &mut scope, &options);

        assert_eq!(
            result,
            Model::new(ModelType::EnumType(EnumType {
                variants: vec!["a".to_string(), "b".to_string()],
                name: "TestName".to_string(),
                type_: "string".to_string(),
            }))
        );
    }

    #[test]
    fn test_should_do_nothing_when_complex_types() {
        let schema = json!({"enum": [{"a":"b"}, true]});
        let mut scope = SchemaScope::default();
        let options = JsonSchemaExtractOptions::default();
        let model = Model::new(ModelType::PrimitiveType(PrimitiveType {
            name: None,
            type_: "string".to_string(),
        }));

        scope.entity("TestName");
        let result = convert_to_enum(
            model.clone(),
            schema.as_object().unwrap(),
            &mut scope,
            &options,
        );

        assert_eq!(result, model);
    }
}