Use ruma_api::try_deserialize in manual endpoint implementations

ruma-api/tests/manual_endpoint_impl.rs

@@ -1,14 +1,14 @@
 //! PUT /_matrix/client/r0/directory/room/:room_alias
 
-use std::{convert::TryFrom, ops::Deref};
+use std::convert::TryFrom;
 
 use http::{header::CONTENT_TYPE, method::Method};
 use ruma_api::{
     error::{
-        FromHttpRequestError, FromHttpResponseError, IntoHttpError, RequestDeserializationError,
+        FromHttpRequestError, FromHttpResponseError, IntoHttpError, ResponseDeserializationError,
-        ResponseDeserializationError, ServerError, Void,
+        ServerError, Void,
     },
-    AuthScheme, IncomingRequest, Metadata, OutgoingRequest,
+    try_deserialize, AuthScheme, IncomingRequest, Metadata, OutgoingRequest,
 };
 use ruma_identifiers::{RoomAliasId, RoomId};
 use ruma_serde::Outgoing;
@@ -71,25 +71,19 @@ impl IncomingRequest for Request {
     fn try_from_http_request(
         request: http::Request<Vec<u8>>,
     ) -> Result<Self, FromHttpRequestError> {
-        let request_body: RequestBody = match serde_json::from_slice(request.body().as_slice()) {
+        let request_body: RequestBody =
-            Ok(body) => body,
+            try_deserialize!(request, serde_json::from_slice(request.body().as_slice()));
-            Err(err) => {
-                return Err(RequestDeserializationError::new(err, request).into());
-            }
-        };
         let path_segments: Vec<&str> = request.uri().path()[1..].split('/').collect();
+
         Ok(Request {
             room_id: request_body.room_id,
             room_alias: {
-                let segment = path_segments.get(5).unwrap().as_bytes();
+                let decoded = try_deserialize!(
-                let decoded = match percent_encoding::percent_decode(segment).decode_utf8() {
+                    request,
-                    Ok(x) => x,
+                    percent_encoding::percent_decode(path_segments[5].as_bytes()).decode_utf8(),
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
+                );
-                };
+
-                match serde_json::from_str(decoded.deref()) {
+                try_deserialize!(request, TryFrom::try_from(&*decoded))
-                    Ok(id) => id,
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-                }
             },
         })
     }

ruma-client-api/src/r0/message/send_message_event.rs

@@ -3,8 +3,8 @@
 use std::convert::TryFrom;
 
 use ruma_api::{
-    error::{FromHttpRequestError, IntoHttpError, RequestDeserializationError},
+    error::{FromHttpRequestError, IntoHttpError},
-    ruma_api, Metadata,
+    ruma_api, try_deserialize, Metadata,
 };
 use ruma_events::{AnyMessageEventContent, EventContent as _};
 use ruma_identifiers::{EventId, RoomId};
@@ -115,42 +115,30 @@ impl ruma_api::IncomingRequest for IncomingRequest {
         let path_segments: Vec<&str> = request.uri().path()[1..].split('/').collect();
 
         let room_id = {
-            let decoded =
+            let decoded = try_deserialize!(
-                match percent_encoding::percent_decode(path_segments[4].as_bytes()).decode_utf8() {
+                request,
-                    Ok(val) => val,
+                percent_encoding::percent_decode(path_segments[4].as_bytes()).decode_utf8(),
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
+            );
+
+            try_deserialize!(request, RoomId::try_from(&*decoded))
         };
 
-            match RoomId::try_from(&*decoded) {
+        let txn_id = try_deserialize!(
-                Ok(val) => val,
+            request,
-                Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
+            percent_encoding::percent_decode(path_segments[7].as_bytes()).decode_utf8(),
-            }
+        )
-        };
+        .into_owned();
-
-        let txn_id =
-            match percent_encoding::percent_decode(path_segments[7].as_bytes()).decode_utf8() {
-                Ok(val) => val.into_owned(),
-                Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-            };
 
         let content = {
             let request_body: Box<RawJsonValue> =
-                match serde_json::from_slice(request.body().as_slice()) {
+                try_deserialize!(request, serde_json::from_slice(request.body().as_slice()));
-                    Ok(val) => val,
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-                };
 
-            let event_type = {
+            let event_type = try_deserialize!(
-                match percent_encoding::percent_decode(path_segments[6].as_bytes()).decode_utf8() {
+                request,
-                    Ok(val) => val,
+                percent_encoding::percent_decode(path_segments[6].as_bytes()).decode_utf8()
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
+            );
-                }
-            };
 
-            match AnyMessageEventContent::from_parts(&event_type, request_body) {
+            try_deserialize!(request, AnyMessageEventContent::from_parts(&event_type, request_body))
-                Ok(content) => content,
-                Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-            }
         };
 
         Ok(Self { room_id, txn_id, content })

ruma-client-api/src/r0/state/get_state_events_for_key.rs

@@ -3,8 +3,8 @@
 use std::{borrow::Cow, convert::TryFrom};
 
 use ruma_api::{
-    error::{FromHttpRequestError, IntoHttpError, RequestDeserializationError},
+    error::{FromHttpRequestError, IntoHttpError},
-    ruma_api, Metadata,
+    ruma_api, try_deserialize, Metadata,
 };
 use ruma_events::EventType;
 use ruma_identifiers::RoomId;
@@ -117,44 +117,31 @@ impl ruma_api::IncomingRequest for IncomingRequest {
         let path_segments: Vec<&str> = request.uri().path()[1..].split('/').collect();
 
         let room_id = {
-            let decoded =
+            let decoded = try_deserialize!(
-                match percent_encoding::percent_decode(path_segments[4].as_bytes()).decode_utf8() {
+                request,
-                    Ok(val) => val,
+                percent_encoding::percent_decode(path_segments[4].as_bytes()).decode_utf8()
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
+            );
-                };
 
-            match RoomId::try_from(&*decoded) {
+            try_deserialize!(request, RoomId::try_from(&*decoded))
-                Ok(val) => val,
-                Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-            }
         };
 
         let event_type = {
-            let decoded =
+            let decoded = try_deserialize!(
-                match percent_encoding::percent_decode(path_segments[6].as_bytes()).decode_utf8() {
+                request,
-                    Ok(val) => val,
+                percent_encoding::percent_decode(path_segments[6].as_bytes()).decode_utf8()
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
+            );
-                };
 
-            match EventType::try_from(&*decoded) {
+            try_deserialize!(request, EventType::try_from(&*decoded))
-                Ok(val) => val,
-                Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-            }
         };
 
         let state_key = match path_segments.get(7) {
             Some(segment) => {
-                let decoded = match percent_encoding::percent_decode(segment.as_bytes())
+                let decoded = try_deserialize!(
-                    .decode_utf8()
+                    request,
-                {
+                    percent_encoding::percent_decode(segment.as_bytes()).decode_utf8()
-                    Ok(val) => val,
+                );
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-                };
 
-                match String::try_from(&*decoded) {
+                try_deserialize!(request, String::try_from(&*decoded))
-                    Ok(val) => val,
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-                }
             }
             None => "".into(),
         };

ruma-client-api/src/r0/state/send_state_event.rs

@@ -3,8 +3,8 @@
 use std::{borrow::Cow, convert::TryFrom};
 
 use ruma_api::{
-    error::{FromHttpRequestError, IntoHttpError, RequestDeserializationError},
+    error::{FromHttpRequestError, IntoHttpError},
-    ruma_api, Metadata,
+    ruma_api, try_deserialize, Metadata,
 };
 use ruma_events::{AnyStateEventContent, EventContent as _};
 use ruma_identifiers::{EventId, RoomId};
@@ -117,46 +117,33 @@ impl ruma_api::IncomingRequest for IncomingRequest {
         let path_segments: Vec<&str> = request.uri().path()[1..].split('/').collect();
 
         let room_id = {
-            let decoded =
+            let decoded = try_deserialize!(
-                match percent_encoding::percent_decode(path_segments[4].as_bytes()).decode_utf8() {
+                request,
-                    Ok(val) => val,
+                percent_encoding::percent_decode(path_segments[4].as_bytes()).decode_utf8()
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
+            );
-                };
 
-            match RoomId::try_from(&*decoded) {
+            try_deserialize!(request, RoomId::try_from(&*decoded))
-                Ok(val) => val,
-                Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-            }
         };
 
         let state_key = match path_segments.get(7) {
-            Some(segment) => {
+            Some(segment) => try_deserialize!(
-                match percent_encoding::percent_decode(segment.as_bytes()).decode_utf8() {
+                request,
-                    Ok(val) => val.into_owned(),
+                percent_encoding::percent_decode(segment.as_bytes()).decode_utf8()
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
+            )
-                }
+            .into_owned(),
-            }
             None => "".into(),
         };
 
         let content = {
             let request_body: Box<RawJsonValue> =
-                match serde_json::from_slice(request.body().as_slice()) {
+                try_deserialize!(request, serde_json::from_slice(request.body().as_slice()));
-                    Ok(val) => val,
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-                };
 
-            let event_type = {
+            let event_type = try_deserialize!(
-                match percent_encoding::percent_decode(path_segments[6].as_bytes()).decode_utf8() {
+                request,
-                    Ok(val) => val,
+                percent_encoding::percent_decode(path_segments[6].as_bytes()).decode_utf8()
-                    Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
+            );
-                }
-            };
 
-            match AnyStateEventContent::from_parts(&event_type, request_body) {
+            try_deserialize!(request, AnyStateEventContent::from_parts(&event_type, request_body))
-                Ok(content) => content,
-                Err(err) => return Err(RequestDeserializationError::new(err, request).into()),
-            }
         };
 
         Ok(Self { room_id, state_key, content })