schematools 0.23.0

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
127
128
129
130
131
132
133

#![allow(dead_code)]

#[cfg(feature = "semver")]
pub mod bump_openapi;
pub mod dereference;
pub mod merge_allof;
pub mod merge_openapi;
pub mod name;
pub mod patch;

use serde_json::Value;
use url::Url;

pub fn rel_to_absolute_refs(url: &Url, mut data: Value) -> Value {
    if url.scheme() == "file" {
        let mut prefix = url.clone();
        prefix.path_segments_mut().unwrap().pop();

        process_node(&prefix, &mut data);
    }

    data
}

fn process_node(url: &Url, data: &mut Value) {
    match data {
        Value::Object(ref mut map) => {
            if let Some(Value::String(reference)) = map.get_mut("$ref") {
                if Url::parse(reference) == Err(url::ParseError::RelativeUrlWithoutBase) {
                    let mut prefix = url.clone();

                    if let [path, fragment] = reference.split('#').collect::<Vec<_>>()[..] {
                        url_extend(&mut prefix, path.split('/'));

                        let mut new_url = prefix.to_string();
                        new_url.push('#');
                        new_url.push_str(fragment);

                        reference.clone_from(&new_url);
                    } else {
                        url_extend(&mut prefix, reference.split('/'));

                        reference.clone_from(&prefix.to_string());
                    }
                }
            } else {
                for (_, value) in map.into_iter() {
                    process_node(url, value);
                }
            }
        }
        Value::Array(a) => {
            for x in a.iter_mut() {
                process_node(url, x);
            }
        }
        _ => {}
    }
}

fn url_extend<I>(url: &mut Url, parts: I)
where
    I: IntoIterator,
    I::Item: AsRef<str>,
{
    let mut segments = url.path_segments_mut().unwrap();

    for p in parts {
        let part = p.as_ref();

        if part == "." {
            continue;
        } else if part == ".." {
            segments.pop();
        } else {
            segments.push(part);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn test_no_replace() {
        let mut data = json!({"asd": "test", "ref": "xxx"});

        process_node(&Url::parse("http://google.pl/").unwrap(), &mut data);

        assert_eq!(data, json!({"asd": "test", "ref": "xxx"}))
    }

    #[test]
    fn test_replace_ref() {
        let mut data = json!({"asd": "test", "$ref": "#xxx"});

        process_node(&Url::parse("http://google.pl/").unwrap(), &mut data);

        assert_eq!(
            data,
            json!({"asd": "test", "$ref": "http://google.pl/#xxx"})
        )
    }

    #[test]
    #[ignore]
    fn test_replace_discriminator_ref() {
        let mut data = json!({
            "oneOf": [{"$ref": "#/KindDiscriminatorSimple"}],
            "discriminator": {
                "mapping": {
                    "test": "#/components/schemas/KindDiscriminatorSimple"
                }
            }
        });

        process_node(&Url::parse("http://google.pl/").unwrap(), &mut data);

        assert_eq!(
            data,
            json!({
                "oneOf": [{"$ref": "http://google.pl/#/KindDiscriminatorSimple"}],
                "discriminator": {
                    "mapping": {
                        "test": "http://google.pl/#/components/schemas/KindDiscriminatorSimple"
                    }
                }
            })
        )
    }
}