From 958a0a01c47c051eebf493234c314bc101609f63 Mon Sep 17 00:00:00 2001 From: Jonas Platte Date: Tue, 29 Oct 2019 12:11:38 +0100 Subject: [PATCH] Remove server-side functionality This is a temporary change that is done to get one release of ruma-client-api with ruma-events' EventResult API out. After ruma-api 0.11 is released, getting the server-side functionality to work again will be a priority. --- ruma-api-macros/src/api/mod.rs | 155 +--------------------------- ruma-api-macros/src/api/request.rs | 54 +--------- ruma-api-macros/src/api/response.rs | 66 +----------- src/lib.rs | 45 +------- 4 files changed, 14 insertions(+), 306 deletions(-) diff --git a/ruma-api-macros/src/api/mod.rs b/ruma-api-macros/src/api/mod.rs index 08781213..717c0c44 100644 --- a/ruma-api-macros/src/api/mod.rs +++ b/ruma-api-macros/src/api/mod.rs @@ -77,15 +77,7 @@ impl ToTokens for Api { let response = &self.response; let response_types = quote! { #response }; - let extract_request_path = if self.request.has_path_fields() { - quote! { - let path_segments: Vec<&str> = request.uri().path()[1..].split('/').collect(); - } - } else { - TokenStream::new() - }; - - let (set_request_path, parse_request_path) = if self.request.has_path_fields() { + let set_request_path = if self.request.has_path_fields() { let path_str = path.value(); assert!(path_str.starts_with('/'), "path needs to start with '/'"); @@ -111,7 +103,7 @@ impl ToTokens for Api { } }); - let set_tokens = quote! { + quote! { let request_path = RequestPath { #request_path_init_fields }; @@ -121,43 +113,11 @@ impl ToTokens for Api { // the case for our placeholder url. let mut path_segments = url.path_segments_mut().unwrap(); #(#path_segment_push)* - }; - - let path_fields = path_segments - .enumerate() - .filter(|(_, s)| s.starts_with(':')) - .map(|(i, segment)| { - let path_var = &segment[1..]; - let path_var_ident = Ident::new(path_var, Span::call_site()); - let path_field = self - .request - .path_field(path_var) - .expect("expected request to have path field"); - let ty = &path_field.ty; - - quote! { - #path_var_ident: { - let segment = path_segments.get(#i).unwrap().as_bytes(); - let decoded = - ruma_api::exports::percent_encoding::percent_decode(segment) - .decode_utf8_lossy(); - #ty::deserialize(decoded.into_deserializer()) - .map_err(|e: ruma_api::exports::serde_json::error::Error| e)? - } - } - }); - - let parse_tokens = quote! { - #(#path_fields,)* - }; - - (set_tokens, parse_tokens) + } } else { - let set_tokens = quote! { + quote! { url.set_path(metadata.path); - }; - let parse_tokens = TokenStream::new(); - (set_tokens, parse_tokens) + } }; let set_request_query = if self.request.has_query_fields() { @@ -174,21 +134,6 @@ impl ToTokens for Api { TokenStream::new() }; - let extract_request_query = if self.request.has_query_fields() { - quote! { - let request_query: RequestQuery = - ruma_api::exports::serde_urlencoded::from_str(&request.uri().query().unwrap_or(""))?; - } - } else { - TokenStream::new() - }; - - let parse_request_query = if self.request.has_query_fields() { - self.request.request_init_query_fields() - } else { - TokenStream::new() - }; - let add_headers_to_request = if self.request.has_header_fields() { let add_headers = self.request.add_headers_to_request(); quote! { @@ -199,20 +144,6 @@ impl ToTokens for Api { TokenStream::new() }; - let extract_request_headers = if self.request.has_header_fields() { - quote! { - let headers = request.headers(); - } - } else { - TokenStream::new() - }; - - let parse_request_headers = if self.request.has_header_fields() { - self.request.parse_headers_from_request() - } else { - TokenStream::new() - }; - let create_http_request = if let Some(field) = self.request.newtype_body_field() { let field_name = field .ident @@ -240,36 +171,6 @@ impl ToTokens for Api { } }; - let extract_request_body = if let Some(field) = self.request.newtype_body_field() { - let ty = &field.ty; - quote! { - let request_body: #ty = - ruma_api::exports::serde_json::from_slice(request.body().as_slice())?; - } - } else if self.request.has_body_fields() { - quote! { - let request_body: RequestBody = - ruma_api::exports::serde_json::from_slice(request.body().as_slice())?; - } - } else { - TokenStream::new() - }; - - let parse_request_body = if let Some(field) = self.request.newtype_body_field() { - let field_name = field - .ident - .as_ref() - .expect("expected field to have an identifier"); - - quote! { - #field_name: request_body, - } - } else if self.request.has_body_fields() { - self.request.request_init_body_fields() - } else { - TokenStream::new() - }; - let try_deserialize_response_body = if let Some(field) = self.response.newtype_body_field() { let field_type = &field.ty; @@ -301,19 +202,6 @@ impl ToTokens for Api { TokenStream::new() }; - let serialize_response_headers = self.response.apply_header_fields(); - - let try_serialize_response_body = if self.response.has_body() { - let body = self.response.to_body(); - quote! { - ruma_api::exports::serde_json::to_vec(&#body)? - } - } else { - quote! { - "{}".as_bytes().to_vec() - } - }; - let request_doc = format!( "Data for a request to the `{}` API endpoint.\n\n{}", name, @@ -331,25 +219,6 @@ impl ToTokens for Api { #[doc = #request_doc] #request_types - impl std::convert::TryFrom>> for Request { - type Error = ruma_api::Error; - - #[allow(unused_variables)] - fn try_from(request: ruma_api::exports::http::Request>) -> Result { - #extract_request_path - #extract_request_query - #extract_request_headers - #extract_request_body - - Ok(Request { - #parse_request_path - #parse_request_query - #parse_request_headers - #parse_request_body - }) - } - } - impl std::convert::TryFrom for ruma_api::exports::http::Request> { type Error = ruma_api::Error; @@ -379,20 +248,6 @@ impl ToTokens for Api { #[doc = #response_doc] #response_types - impl std::convert::TryFrom for ruma_api::exports::http::Response> { - type Error = ruma_api::Error; - - #[allow(unused_variables)] - fn try_from(response: Response) -> Result { - let response = ruma_api::exports::http::Response::builder() - .header(ruma_api::exports::http::header::CONTENT_TYPE, "application/json") - #serialize_response_headers - .body(#try_serialize_response_body) - .unwrap(); - Ok(response) - } - } - impl std::convert::TryFrom>> for Response { type Error = ruma_api::Error; diff --git a/ruma-api-macros/src/api/request.rs b/ruma-api-macros/src/api/request.rs index e6ac4451..c8e04e40 100644 --- a/ruma-api-macros/src/api/request.rs +++ b/ruma-api-macros/src/api/request.rs @@ -40,30 +40,6 @@ impl Request { } } - /// Produces code to extract fields from the HTTP headers in an `http::Request`. - pub fn parse_headers_from_request(&self) -> TokenStream { - let fields = self.header_fields().map(|request_field| { - let (field, header_name) = match request_field { - RequestField::Header(field, header_name) => (field, header_name), - _ => panic!("expected request field to be header variant"), - }; - - let field_name = &field.ident; - let header_name_string = header_name.to_string(); - - quote! { - #field_name: headers.get(ruma_api::exports::http::header::#header_name) - .and_then(|v| v.to_str().ok()) - .ok_or(ruma_api::exports::serde_json::Error::missing_field(#header_name_string))? - .to_owned() - } - }); - - quote! { - #(#fields,)* - } - } - /// Whether or not this request has any data in the HTTP body. pub fn has_body_fields(&self) -> bool { self.fields.iter().any(|field| field.is_body()) @@ -73,6 +49,7 @@ impl Request { pub fn has_header_fields(&self) -> bool { self.fields.iter().any(|field| field.is_header()) } + /// Whether or not this request has any data in the URL path. pub fn has_path_fields(&self) -> bool { self.fields.iter().any(|field| field.is_path()) @@ -93,20 +70,6 @@ impl Request { self.fields.iter().filter(|field| field.is_path()).count() } - /// Gets the path field with the given name. - pub fn path_field(&self, name: &str) -> Option<&Field> { - self.fields - .iter() - .flat_map(|f| f.field_of_kind(RequestFieldKind::Path)) - .find(|field| { - field - .ident - .as_ref() - .expect("expected field to have an identifier") - == name - }) - } - /// Returns the body field. pub fn newtype_body_field(&self) -> Option<&Field> { for request_field in self.fields.iter() { @@ -136,17 +99,6 @@ impl Request { self.struct_init_fields(RequestFieldKind::Query, quote!(request)) } - /// Produces code for a struct initializer for body fields on a variable named `request_body`. - pub fn request_init_body_fields(&self) -> TokenStream { - self.struct_init_fields(RequestFieldKind::Body, quote!(request_body)) - } - - /// Produces code for a struct initializer for query string fields on a variable named - /// `request_query`. - pub fn request_init_query_fields(&self) -> TokenStream { - self.struct_init_fields(RequestFieldKind::Query, quote!(request_query)) - } - /// Produces code for a struct initializer for the given field kind to be accessed through the /// given variable name. fn struct_init_fields( @@ -261,7 +213,7 @@ impl ToTokens for Request { quote_spanned! {span=> /// Data in the request body. - #[derive(Debug, ruma_api::exports::serde::Deserialize, ruma_api::exports::serde::Serialize)] + #[derive(Debug, ruma_api::exports::serde::Serialize)] struct RequestBody(#ty); } } else if self.has_body_fields() { @@ -278,7 +230,7 @@ impl ToTokens for Request { quote! { /// Data in the request body. - #[derive(Debug, ruma_api::exports::serde::Deserialize, ruma_api::exports::serde::Serialize)] + #[derive(Debug, ruma_api::exports::serde::Serialize)] struct RequestBody { #(#fields),* } diff --git a/ruma-api-macros/src/api/response.rs b/ruma-api-macros/src/api/response.rs index 2bac5765..9f1754d5 100644 --- a/ruma-api-macros/src/api/response.rs +++ b/ruma-api-macros/src/api/response.rs @@ -31,11 +31,6 @@ impl Response { self.fields.iter().any(|field| field.is_header()) } - /// Whether or not this response has any data in the HTTP body. - pub fn has_body(&self) -> bool { - self.fields.iter().any(|field| !field.is_header()) - } - /// Produces code for a request struct initializer. pub fn init_fields(&self) -> TokenStream { let fields = self @@ -86,63 +81,6 @@ impl Response { } } - /// Produces code to add necessary HTTP headers to an `http::Response`. - pub fn apply_header_fields(&self) -> TokenStream { - let header_calls = self.fields.iter().filter_map(|response_field| { - if let ResponseField::Header(ref field, ref header_name) = *response_field { - let field_name = field - .ident - .as_ref() - .expect("expected field to have an identifier"); - let span = field.span(); - - Some(quote_spanned! {span=> - .header(ruma_api::exports::http::header::#header_name, response.#field_name) - }) - } else { - None - } - }); - - quote! { - #(#header_calls)* - } - } - - /// Produces code to initialize the struct that will be used to create the response body. - pub fn to_body(&self) -> TokenStream { - if let Some(field) = self.newtype_body_field() { - let field_name = field - .ident - .as_ref() - .expect("expected field to have an identifier"); - let span = field.span(); - quote_spanned!(span=> response.#field_name) - } else { - let fields = self.fields.iter().filter_map(|response_field| { - if let ResponseField::Body(ref field) = *response_field { - let field_name = field - .ident - .as_ref() - .expect("expected field to have an identifier"); - let span = field.span(); - - Some(quote_spanned! {span=> - #field_name: response.#field_name - }) - } else { - None - } - }); - - quote! { - ResponseBody { - #(#fields),* - } - } - } - } - /// Gets the newtype body field, if this request has one. pub fn newtype_body_field(&self) -> Option<&Field> { for response_field in self.fields.iter() { @@ -247,7 +185,7 @@ impl ToTokens for Response { quote_spanned! {span=> /// Data in the response body. - #[derive(Debug, ruma_api::exports::serde::Deserialize, ruma_api::exports::serde::Serialize)] + #[derive(Debug, ruma_api::exports::serde::Deserialize)] struct ResponseBody(#ty); } } else if self.has_body_fields() { @@ -264,7 +202,7 @@ impl ToTokens for Response { quote! { /// Data in the response body. - #[derive(Debug, ruma_api::exports::serde::Deserialize, ruma_api::exports::serde::Serialize)] + #[derive(Debug, ruma_api::exports::serde::Deserialize)] struct ResponseBody { #(#fields),* } diff --git a/src/lib.rs b/src/lib.rs index 4e83f749..b85256b2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -58,7 +58,6 @@ pub use ruma_api_macros::ruma_api; /// It is not considered part of ruma-api's public API. pub mod exports { pub use http; - pub use percent_encoding; pub use serde; pub use serde_json; pub use serde_urlencoded; @@ -68,12 +67,9 @@ pub mod exports { /// A Matrix API endpoint. /// /// The type implementing this trait contains any data needed to make a request to the endpoint. -pub trait Endpoint: - TryFrom>, Error = Error> + TryInto>, Error = Error> -{ +pub trait Endpoint: TryInto>, Error = Error> { /// Data returned in a successful response from the endpoint. - type Response: TryFrom>, Error = Error> - + TryInto>, Error = Error>; + type Response: TryFrom>, Error = Error>; /// Metadata about the endpoint. const METADATA: Metadata; @@ -202,10 +198,9 @@ mod tests { pub mod create { use std::convert::TryFrom; - use http::{self, header::CONTENT_TYPE, method::Method}; - use percent_encoding; + use http::{self, method::Method}; use ruma_identifiers::{RoomAliasId, RoomId}; - use serde::{de::IntoDeserializer, Deserialize, Serialize}; + use serde::{Deserialize, Serialize}; use serde_json; use crate::{Endpoint, Error, Metadata}; @@ -254,25 +249,6 @@ mod tests { } } - impl TryFrom>> for Request { - type Error = Error; - - fn try_from(request: http::Request>) -> Result { - let request_body: RequestBody = - ::serde_json::from_slice(request.body().as_slice())?; - 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 = percent_encoding::percent_decode(segment).decode_utf8_lossy(); - RoomAliasId::deserialize(decoded.into_deserializer()) - .map_err(|e: serde_json::error::Error| e)? - }, - }) - } - } - #[derive(Debug, Serialize, Deserialize)] struct RequestBody { room_id: RoomId, @@ -293,18 +269,5 @@ mod tests { } } } - - impl TryFrom for http::Response> { - type Error = Error; - - fn try_from(_: Response) -> Result>, Self::Error> { - let response = http::Response::builder() - .header(CONTENT_TYPE, "application/json") - .body(b"{}".to_vec()) - .unwrap(); - - Ok(response) - } - } } }