loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

Fix #18572 rust server: Silence clippy lints by refactoring (#18575)

Browse Source 
* refactor: move closure definition to own statement

A clippy lint recommends not using a closure inside of a statement.
The code generation used to produce code that triggered this warning,
which caused the rust-server integration test to fail because clippy is
configured to return lint violations as errors.
For details for the lint see:
https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_conditions

* refactor: Remove unnecessary qualification

A GitHub action test used to fail because of a clippy warning that was
emitted due to not using an imported symbol but qualifying its use.
A failed test can be seen here:
https://github.com/OpenAPITools/openapi-generator/actions/runs/8958257509/job/24603984954?pr=18563
With the relevant error being:

error: unnecessary qualification
  --> output/openapi-v3/src/client/callbacks.rs:88:9
   |
88 |         futures::future::ok(Service::new(

This commit simply removes the qualification.

* test: Update examples and run integration test.

Updated examples by running
`./bin/generate-samples.sh ./bin/configs/rust-server-*`
The integration test with the following command passes:
`mvn integration-test -f samples/server/petstore/rust-server/pom.xml`
This commit is contained in:
myz-dev 2024-05-06 06:24:33 +02:00 committed by GitHub
parent f145b8962d
commit b1fac19a75
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 150 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modules/openapi-generator/src/main/resources/rust-server/server-make-service.mustache vendored
View File

@ -31,7 +31,7 @@ impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C> where
}
fn call(&mut self, target: Target) -> Self::Future {
futures::future::ok(Service::new(
future::ok(Service::new(
self.api_impl.clone(),
))
}

14
modules/openapi-generator/src/main/resources/rust-server/server-operation.mustache vendored
View File

@ -224,10 +224,11 @@
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
{{/x-consumes-json}}
{{^x-consumes-plain-text}}
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_{{{paramName}}}) => param_{{{paramName}}},
{{#required}}
Err(e) => return Ok(Response::builder()
@ -421,10 +422,11 @@
Some("{{{contentType}}}") if param_{{{paramName}}}.is_none() => {
// Extract JSON part.
let deserializer = &mut serde_json::Deserializer::from_slice(part.body.as_slice());
let json_data: {{dataType}} = match serde_ignored::deserialize(deserializer, |path| {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in JSON part: {}", path);
unused_elements.push(path.to_string());
}) {
};
let json_data: {{dataType}} = match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(json_data) => json_data,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)

7
samples/server/petstore/rust-server/output/multipart-v3/src/server/mod.rs
View File

@ -81,7 +81,7 @@ impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C> where
}
fn call(&mut self, target: Target) -> Self::Future {
futures::future::ok(Service::new(
future::ok(Service::new(
self.api_impl.clone(),
))
}
@ -206,10 +206,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
Some("application/json") if param_object_field.is_none() => {
// Extract JSON part.
let deserializer = &mut serde_json::Deserializer::from_slice(part.body.as_slice());
let json_data: models::MultipartRequestObjectField = match serde_ignored::deserialize(deserializer, |path| {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in JSON part: {}", path);
unused_elements.push(path.to_string());
}) {
};
let json_data: models::MultipartRequestObjectField = match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(json_data) => json_data,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)

11
samples/server/petstore/rust-server/output/no-example-v3/src/server/mod.rs
View File

@ -70,7 +70,7 @@ impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C> where
}
fn call(&mut self, target: Target) -> Self::Future {
futures::future::ok(Service::new(
future::ok(Service::new(
self.api_impl.clone(),
))
}
@ -150,10 +150,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_op_get_request: Option<models::OpGetRequest> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_op_get_request) => param_op_get_request,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)

2
samples/server/petstore/rust-server/output/openapi-v3/src/client/callbacks.rs
View File

@ -85,7 +85,7 @@ impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C> where
}
fn call(&mut self, target: Target) -> Self::Future {
futures::future::ok(Service::new(
future::ok(Service::new(
self.api_impl.clone(),
))
}

65
samples/server/petstore/rust-server/output/openapi-v3/src/server/mod.rs
View File

@ -155,7 +155,7 @@ impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C> where
}
fn call(&mut self, target: Target) -> Self::Future {
futures::future::ok(Service::new(
future::ok(Service::new(
self.api_impl.clone(),
))
}
@ -1269,10 +1269,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_object_untyped_props: Option<models::ObjectUntypedProps> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_object_untyped_props) => param_object_untyped_props,
Err(_) => None,
}
@ -1368,10 +1369,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_duplicate_xml_object: Option<models::DuplicateXmlObject> = if !body.is_empty() {
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_duplicate_xml_object) => param_duplicate_xml_object,
Err(_) => None,
}
@ -1435,10 +1437,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_another_xml_object: Option<models::AnotherXmlObject> = if !body.is_empty() {
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_another_xml_object) => param_another_xml_object,
Err(_) => None,
}
@ -1513,10 +1516,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_another_xml_array: Option<models::AnotherXmlArray> = if !body.is_empty() {
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_another_xml_array) => param_another_xml_array,
Err(_) => None,
}
@ -1580,10 +1584,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_xml_array: Option<models::XmlArray> = if !body.is_empty() {
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_xml_array) => param_xml_array,
Err(_) => None,
}
@ -1647,10 +1652,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_xml_object: Option<models::XmlObject> = if !body.is_empty() {
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_xml_object) => param_xml_object,
Err(_) => None,
}
@ -1714,10 +1720,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_object_param: Option<models::ObjectParam> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_object_param) => param_object_param,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)

2
samples/server/petstore/rust-server/output/ops-v3/src/server/mod.rs
View File

@ -178,7 +178,7 @@ impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C> where
}
fn call(&mut self, target: Target) -> Self::Future {
futures::future::ok(Service::new(
future::ok(Service::new(
self.api_impl.clone(),
))
}

146
samples/server/petstore/rust-server/output/petstore-with-fake-endpoints-models-for-testing/src/server/mod.rs
View File

@ -188,7 +188,7 @@ impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C> where
}
fn call(&mut self, target: Target) -> Self::Future {
futures::future::ok(Service::new(
future::ok(Service::new(
self.api_impl.clone(),
))
}
@ -268,10 +268,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::Client> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -377,10 +378,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::OuterBoolean> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(_) => None,
}
@ -447,10 +449,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::OuterComposite> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(_) => None,
}
@ -517,10 +520,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::OuterNumber> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(_) => None,
}
@ -587,10 +591,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::OuterString> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(_) => None,
}
@ -766,10 +771,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::User> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -840,10 +846,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::Client> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -1136,10 +1143,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_param: Option<std::collections::HashMap<String, String>> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_param) => param_param,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -1254,10 +1262,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::Client> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -1364,10 +1373,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::Pet> = if !body.is_empty() {
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -1803,10 +1813,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::Pet> = if !body.is_empty() {
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -2318,10 +2329,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::Order> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -2402,10 +2414,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::User> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -2475,10 +2488,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<Vec<models::User>> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -2548,10 +2562,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<Vec<models::User>> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -2927,10 +2942,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_body: Option<models::User> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_body) => param_body,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)

2
samples/server/petstore/rust-server/output/ping-bearer-auth/src/server/mod.rs
View File

@ -70,7 +70,7 @@ impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C> where
}
fn call(&mut self, target: Target) -> Self::Future {
futures::future::ok(Service::new(
future::ok(Service::new(
self.api_impl.clone(),
))
}

20
samples/server/petstore/rust-server/output/rust-server-test/src/server/mod.rs
View File

@ -92,7 +92,7 @@ impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C> where
}
fn call(&mut self, target: Target) -> Self::Future {
futures::future::ok(Service::new(
future::ok(Service::new(
self.api_impl.clone(),
))
}
@ -237,10 +237,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_nested_response: Option<models::DummyPutRequest> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_nested_response) => param_nested_response,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)
@ -547,10 +548,11 @@ impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C> where
let mut unused_elements = Vec::new();
let param_value: Option<serde_json::Value> = if !body.is_empty() {
let deserializer = &mut serde_json::Deserializer::from_slice(&body);
match serde_ignored::deserialize(deserializer, |path| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
}) {
let handle_unknown_field = |path: serde_ignored::Path<'_>| {
warn!("Ignoring unknown field in body: {}", path);
unused_elements.push(path.to_string());
};
match serde_ignored::deserialize(deserializer, handle_unknown_field) {
Ok(param_value) => param_value,
Err(e) => return Ok(Response::builder()
.status(StatusCode::BAD_REQUEST)