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
134
135
136
137
138
139
//! Implements encoding object for content.
use serde::{Deserialize, Serialize};
use super::parameter::ParameterStyle;
use super::{Header, PropMap};
/// A single encoding definition applied to a single schema [`Object
/// property`](crate::openapi::schema::Object::properties).
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct Encoding {
/// The Content-Type for encoding a specific property. Default value depends on the property
/// type: for string with format being binary – `application/octet-stream`; for other primitive
/// types – `text/plain`; for object - `application/json`; for array – the default is defined
/// based on the inner type. The value can be a specific media type (e.g. `application/json`),
/// a wildcard media type (e.g. `image/*`), or a comma-separated list of the two types.
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
/// A map allowing additional information to be provided as headers, for example
/// Content-Disposition. Content-Type is described separately and SHALL be ignored in this
/// section. This property SHALL be ignored if the request body media type is not a multipart.
#[serde(skip_serializing_if = "PropMap::is_empty")]
pub headers: PropMap<String, Header>,
/// Describes how a specific property value will be serialized depending on its type. See
/// Parameter Object for details on the style property. The behavior follows the same values as
/// query parameters, including default values. This property SHALL be ignored if the request
/// body media type is not `application/x-www-form-urlencoded`.
#[serde(skip_serializing_if = "Option::is_none")]
pub style: Option<ParameterStyle>,
/// When this is true, property values of type array or object generate separate parameters for
/// each value of the array, or key-value-pair of the map. For other types of properties this
/// property has no effect. When style is form, the default value is true. For all other
/// styles, the default value is false. This property SHALL be ignored if the request body
/// media type is not `application/x-www-form-urlencoded`.
#[serde(skip_serializing_if = "Option::is_none")]
pub explode: Option<bool>,
/// Determines whether the parameter value SHOULD allow reserved characters, as defined by
/// RFC3986 `:/?#[]@!$&'()*+,;=` to be included without percent-encoding. The default value is
/// false. This property SHALL be ignored if the request body media type is not
/// `application/x-www-form-urlencoded`.
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_reserved: Option<bool>,
/// Optional extensions "x-something"
#[serde(skip_serializing_if = "PropMap::is_empty", flatten)]
pub extensions: PropMap<String, serde_json::Value>,
}
impl Encoding {
/// Set the content type. See [`Encoding::content_type`].
#[must_use]
pub fn content_type<S: Into<String>>(mut self, content_type: S) -> Self {
self.content_type = Some(content_type.into());
self
}
/// Add a [`Header`]. See [`Encoding::headers`].
#[must_use]
pub fn header<S: Into<String>, H: Into<Header>>(mut self, header_name: S, header: H) -> Self {
self.headers.insert(header_name.into(), header.into());
self
}
/// Set the style [`ParameterStyle`]. See [`Encoding::style`].
#[must_use]
pub fn style(mut self, style: ParameterStyle) -> Self {
self.style = Some(style);
self
}
/// Set the explode. See [`Encoding::explode`].
#[must_use]
pub fn explode(mut self, explode: bool) -> Self {
self.explode = Some(explode);
self
}
/// Set the allow reserved. See [`Encoding::allow_reserved`].
#[must_use]
pub fn allow_reserved(mut self, allow_reserved: bool) -> Self {
self.allow_reserved = Some(allow_reserved);
self
}
/// Add openapi extensions (`x-something`) for [`Encoding`].
#[must_use]
pub fn extensions(mut self, extensions: PropMap<String, serde_json::Value>) -> Self {
self.extensions = extensions;
self
}
}
#[cfg(test)]
mod tests {
use assert_json_diff::assert_json_eq;
use serde_json::json;
use super::*;
#[test]
fn test_encoding_default() {
let encoding = Encoding::default();
assert_json_eq!(encoding, json!({}));
}
#[test]
fn test_build_encoding() {
let encoding = Encoding::default()
.content_type("application/json")
.header("header1", Header::default())
.style(ParameterStyle::Simple)
.explode(true)
.allow_reserved(false);
assert_json_eq!(
encoding,
json!({
"contentType": "application/json",
"headers": {
"header1": {
"schema": {
"type": "string"
}
}
},
"style": "simple",
"explode": true,
"allowReserved": false
})
);
}
}