schemadoc-diff 0.1.20

OpenApi diff library and breaking changes detector
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

use crate::schemas::openapi310::schema::*;

pub fn deref_schema<'a>(
    components: &'a Option<Components>,
    reference: &str,
) -> Option<&'a Schema> {
    components.as_ref().and_then(|components| {
        components.schemas.as_ref().and_then(|map| {
            map.get(&reference.replace("#/components/schemas/", ""))
                .map(|may_be_schema| match may_be_schema {
                    MayBeRef310::Value(value) => value,
                    _ => unimplemented!(),
                })
        })
    })
}

pub fn deref_parameter<'a>(
    components: &'a Option<Components>,
    reference: &str,
) -> Option<&'a Parameter> {
    components.as_ref().and_then(|components| {
        components.parameters.as_ref().and_then(|map| {
            map.get(&reference.replace("#/components/parameters/", ""))
                .map(|may_be_parameter| match may_be_parameter {
                    MayBeRef310::Value(value) => value,
                    _ => unimplemented!(),
                })
        })
    })
}

pub fn deref_example<'a>(
    swagger: &'a OpenApi310,
    reference: &str,
) -> Option<&'a Example> {
    swagger.components.as_ref().and_then(|components| {
        components.examples.as_ref().and_then(|map| {
            map.get(&reference.replace("#/components/examples/", ""))
                .map(|may_be_example| match may_be_example {
                    MayBeRef310::Value(value) => value,
                    _ => unimplemented!(),
                })
        })
    })
}

pub fn deref_request_body<'a>(
    swagger: &'a OpenApi310,
    reference: &str,
) -> Option<&'a RequestBody> {
    swagger.components.as_ref().and_then(|components| {
        components.request_bodies.as_ref().and_then(|map| {
            map.get(&reference.replace("#/components/requestBodies/", ""))
                .map(|may_be_request_body| match may_be_request_body {
                    MayBeRef310::Value(value) => value,
                    _ => unimplemented!(),
                })
        })
    })
}

pub fn deref_header<'a>(
    swagger: &'a OpenApi310,
    reference: &str,
) -> Option<&'a Header> {
    swagger.components.as_ref().and_then(|components| {
        components.headers.as_ref().and_then(|map| {
            map.get(&reference.replace("#/components/headers/", ""))
                .map(|may_be_header| match may_be_header {
                    MayBeRef310::Value(value) => value,
                    _ => unimplemented!(),
                })
        })
    })
}

pub fn deref_security_scheme<'a>(
    swagger: &'a OpenApi310,
    reference: &str,
) -> Option<&'a SecurityScheme> {
    swagger.components.as_ref().and_then(|components| {
        components.security_schemes.as_ref().and_then(|map| {
            map.get(&reference.replace("#/components/securitySchemes/", ""))
                .map(|may_be_security_scheme| match may_be_security_scheme {
                    MayBeRef310::Value(value) => value,
                    _ => unimplemented!(),
                })
        })
    })
}

pub fn deref_link<'a>(
    swagger: &'a OpenApi310,
    reference: &str,
) -> Option<&'a Link> {
    swagger.components.as_ref().and_then(|components| {
        components.links.as_ref().and_then(|map| {
            map.get(&reference.replace("#/components/links/", "")).map(
                |may_be_link| match may_be_link {
                    MayBeRef310::Value(value) => value,
                    _ => unimplemented!(),
                },
            )
        })
    })
}

pub fn deref_response<'a>(
    swagger: &'a OpenApi310,
    reference: &str,
) -> Option<&'a Response> {
    swagger.components.as_ref().and_then(|components| {
        components.responses.as_ref().and_then(|map| {
            map.get(&reference.replace("#/components/responses/", ""))
                .map(|may_be_response| match may_be_response {
                    MayBeRef310::Value(value) => value,
                    _ => unimplemented!(),
                })
        })
    })
}