chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove server-side functionality

Browse Source 
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.
This commit is contained in:
Jonas Platte 2019-10-29 12:11:38 +01:00
parent 481f4c682c
commit 958a0a01c4
4 changed files with 14 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

155
ruma-api-macros/src/api/mod.rs
View File

@ -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<ruma_api::exports::http::Request<Vec<u8>>> for Request {
type Error = ruma_api::Error;
#[allow(unused_variables)]
fn try_from(request: ruma_api::exports::http::Request<Vec<u8>>) -> Result<Self, Self::Error> {
#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<Request> for ruma_api::exports::http::Request<Vec<u8>> {
type Error = ruma_api::Error;
@ -379,20 +248,6 @@ impl ToTokens for Api {
#[doc = #response_doc]
#response_types
impl std::convert::TryFrom<Response> for ruma_api::exports::http::Response<Vec<u8>> {
type Error = ruma_api::Error;
#[allow(unused_variables)]
fn try_from(response: Response) -> Result<Self, Self::Error> {
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<ruma_api::exports::http::Response<Vec<u8>>> for Response {
type Error = ruma_api::Error;

54
ruma-api-macros/src/api/request.rs
View File

@ -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),*
}

66
ruma-api-macros/src/api/response.rs
View File

@ -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),*
}

45
src/lib.rs
View File

@ -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<http::Request<Vec<u8>>, Error = Error> + TryInto<http::Request<Vec<u8>>, Error = Error>
{
pub trait Endpoint: TryInto<http::Request<Vec<u8>>, Error = Error> {
/// Data returned in a successful response from the endpoint.
type Response: TryFrom<http::Response<Vec<u8>>, Error = Error>
+ TryInto<http::Response<Vec<u8>>, Error = Error>;
type Response: TryFrom<http::Response<Vec<u8>>, 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<http::Request<Vec<u8>>> for Request {
type Error = Error;
fn try_from(request: http::Request<Vec<u8>>) -> Result<Self, Self::Error> {
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<Response> for http::Response<Vec<u8>> {
type Error = Error;
fn try_from(_: Response) -> Result<http::Response<Vec<u8>>, Self::Error> {
let response = http::Response::builder()
.header(CONTENT_TYPE, "application/json")
.body(b"{}".to_vec())
.unwrap();
Ok(response)
}
}
}
}