From c9277ddc94ebd55e54cc9a72e135525638c68bbd Mon Sep 17 00:00:00 2001 From: Jonas Platte Date: Sat, 10 Nov 2018 14:04:46 +0100 Subject: [PATCH] Upgrade dependencies --- Cargo.toml | 20 +++++------ src/api/metadata.rs | 2 +- src/api/mod.rs | 76 +++++++++++++++++++++++++--------------- src/api/request.rs | 43 ++++++++++++----------- src/api/response.rs | 38 ++++++++++++-------- src/lib.rs | 8 ++--- tests/ruma_api_macros.rs | 2 +- 7 files changed, 110 insertions(+), 79 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index de2b539d..784ffc84 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,25 +11,25 @@ repository = "https://github.com/ruma/ruma-api-macros" version = "0.2.2" [dependencies] -quote = "0.5.2" +quote = "0.6.10" ruma-api = "0.5.0" [dependencies.syn] -version = "0.13.10" +version = "0.15.18" features = ["full"] [dependencies.proc-macro2] -version = "0.4.2" +version = "0.4.21" features = ["nightly"] [dev-dependencies] -futures = "0.1.21" -http = "0.1.5" -serde = "1.0.57" -serde_derive = "1.0.57" -serde_json = "1.0.17" -serde_urlencoded = "0.5.2" -url = "1.7.0" +futures = "0.1.25" +http = "0.1.13" +serde = "1.0.80" +serde_derive = "1.0.80" +serde_json = "1.0.33" +serde_urlencoded = "0.5.3" +url = "1.7.2" [lib] proc-macro = true diff --git a/src/api/metadata.rs b/src/api/metadata.rs index c167829d..300eb44b 100644 --- a/src/api/metadata.rs +++ b/src/api/metadata.rs @@ -25,7 +25,7 @@ impl From> for Metadata { _ => panic!("expected Member::Named"), }; - match identifier.as_ref() { + match &identifier.to_string()[..] { "description" => { let expr_lit = match field_value.expr { Expr::Lit(expr_lit) => expr_lit, diff --git a/src/api/mod.rs b/src/api/mod.rs index c199c680..4a4d5510 100644 --- a/src/api/mod.rs +++ b/src/api/mod.rs @@ -1,7 +1,7 @@ -use quote::{ToTokens, Tokens}; -use syn::punctuated::Punctuated; -use syn::synom::Synom; -use syn::{Field, FieldValue, Ident, Meta}; +use proc_macro2::{Span, TokenStream}; +use quote::{ToTokens, TokenStreamExt}; +use syn::{braced, Field, FieldValue, Ident, Meta, Token}; +use syn::parse::{Parse, ParseStream, Result}; mod metadata; mod request; @@ -23,7 +23,7 @@ pub fn strip_serde_attrs(field: &Field) -> Field { _ => return true, }; - if meta_list.ident.as_ref() == "serde" { + if &meta_list.ident.to_string() == "serde" { return false; } @@ -50,9 +50,9 @@ impl From for Api { } impl ToTokens for Api { - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { let description = &self.metadata.description; - let method = Ident::from(self.metadata.method.as_ref()); + let method = Ident::new(self.metadata.method.as_ref(), Span::call_site()); let name = &self.metadata.name; let path = &self.metadata.path; let rate_limited = &self.metadata.rate_limited; @@ -92,7 +92,7 @@ impl ToTokens for Api { if segment.starts_with(':') { let path_var = &segment[1..]; - let path_var_ident = Ident::from(path_var); + let path_var_ident = Ident::new(path_var, Span::call_site()); tokens.append_all(quote! { (&request_path.#path_var_ident.to_string()); @@ -122,7 +122,7 @@ impl ToTokens for Api { url.set_query(Some(&::serde_urlencoded::to_string(request_query)?)); } } else { - Tokens::new() + TokenStream::new() }; let add_headers_to_request = if self.request.has_header_fields() { @@ -134,11 +134,11 @@ impl ToTokens for Api { header_tokens } else { - Tokens::new() + TokenStream::new() }; let create_http_request = if let Some(field) = self.request.newtype_body_field() { - let field_name = field.ident.expect("expected field to have an identifier"); + let field_name = field.ident.clone().expect("expected field to have an identifier"); quote! { let request_body = RequestBody(request.#field_name); @@ -188,13 +188,13 @@ impl ToTokens for Api { let mut headers = http_response.headers().clone(); } } else { - Tokens::new() + TokenStream::new() }; let response_init_fields = if self.response.has_fields() { self.response.init_fields() } else { - Tokens::new() + TokenStream::new() }; tokens.append_all(quote! { @@ -279,8 +279,13 @@ impl ToTokens for Api { } } -type ParseMetadata = Punctuated; -type ParseFields = Punctuated; +mod kw { + use syn::custom_keyword; + + custom_keyword!(metadata); + custom_keyword!(request); + custom_keyword!(response); +} pub struct RawApi { pub metadata: Vec, @@ -288,18 +293,33 @@ pub struct RawApi { pub response: Vec, } -impl Synom for RawApi { - named!(parse -> Self, do_parse!( - custom_keyword!(metadata) >> - metadata: braces!(ParseMetadata::parse_terminated) >> - custom_keyword!(request) >> - request: braces!(call!(ParseFields::parse_terminated_with, Field::parse_named)) >> - custom_keyword!(response) >> - response: braces!(call!(ParseFields::parse_terminated_with, Field::parse_named)) >> - (RawApi { - metadata: metadata.1.into_iter().collect(), - request: request.1.into_iter().collect(), - response: response.1.into_iter().collect(), +impl Parse for RawApi { + fn parse(input: ParseStream) -> Result { + input.parse::()?; + let metadata; + braced!(metadata in input); + + input.parse::()?; + let request; + braced!(request in input); + + input.parse::()?; + let response; + braced!(response in input); + + Ok(RawApi { + metadata: metadata + .parse_terminated::(FieldValue::parse)? + .into_iter() + .collect(), + request: request + .parse_terminated::(Field::parse_named)? + .into_iter() + .collect(), + response: response + .parse_terminated::(Field::parse_named)? + .into_iter() + .collect(), }) - )); + } } diff --git a/src/api/request.rs b/src/api/request.rs index be33d5be..1d3bff4d 100644 --- a/src/api/request.rs +++ b/src/api/request.rs @@ -1,4 +1,5 @@ -use quote::{ToTokens, Tokens}; +use proc_macro2::{Span, TokenStream}; +use quote::{ToTokens, TokenStreamExt}; use syn::spanned::Spanned; use syn::{Field, Ident, Lit, Meta, NestedMeta}; @@ -9,15 +10,15 @@ pub struct Request { } impl Request { - pub fn add_headers_to_request(&self) -> Tokens { - self.header_fields().fold(Tokens::new(), |mut header_tokens, request_field| { + pub fn add_headers_to_request(&self) -> TokenStream { + self.header_fields().fold(TokenStream::new(), |mut header_tokens, request_field| { let (field, header_name_string) = match request_field { RequestField::Header(field, header_name_string) => (field, header_name_string), _ => panic!("expected request field to be header variant"), }; let field_name = &field.ident; - let header_name = Ident::from(header_name_string.as_ref()); + let header_name = Ident::new(header_name_string.as_ref(), Span::call_site()); header_tokens.append_all(quote! { headers.append( @@ -67,23 +68,23 @@ impl Request { None } - pub fn request_body_init_fields(&self) -> Tokens { + pub fn request_body_init_fields(&self) -> TokenStream { self.struct_init_fields(RequestFieldKind::Body) } - pub fn request_path_init_fields(&self) -> Tokens { + pub fn request_path_init_fields(&self) -> TokenStream { self.struct_init_fields(RequestFieldKind::Path) } - pub fn request_query_init_fields(&self) -> Tokens { + pub fn request_query_init_fields(&self) -> TokenStream { self.struct_init_fields(RequestFieldKind::Query) } - fn struct_init_fields(&self, request_field_kind: RequestFieldKind) -> Tokens { - let mut tokens = Tokens::new(); + fn struct_init_fields(&self, request_field_kind: RequestFieldKind) -> TokenStream { + let mut tokens = TokenStream::new(); for field in self.fields.iter().flat_map(|f| f.field_(request_field_kind)) { - let field_name = field.ident.expect("expected field to have an identifier"); + let field_name = field.ident.clone().expect("expected field to have an identifier"); let span = field.span(); tokens.append_all(quote_spanned! {span=> @@ -112,7 +113,7 @@ impl From> for Request { _ => return true, }; - if meta_list.ident.as_ref() != "ruma_api" { + if &meta_list.ident.to_string() != "ruma_api" { return true; } @@ -121,7 +122,7 @@ impl From> for Request { NestedMeta::Meta(meta_item) => { match meta_item { Meta::Word(ident) => { - match ident.as_ref() { + match &ident.to_string()[..] { "body" => { has_newtype_body = true; field_kind = RequestFieldKind::NewtypeBody; @@ -132,7 +133,7 @@ impl From> for Request { } } Meta::NameValue(name_value) => { - match name_value.ident.as_ref() { + match &name_value.ident.to_string()[..] { "header" => { match name_value.lit { Lit::Str(lit_str) => header = Some(lit_str.value()), @@ -173,7 +174,7 @@ impl From> for Request { } impl ToTokens for Request { - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { let request_struct_header = quote! { /// Data for a request to this API endpoint. #[derive(Debug)] @@ -183,7 +184,7 @@ impl ToTokens for Request { let request_struct_body = if self.fields.len() == 0 { quote!(;) } else { - let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, request_field| { + let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, request_field| { let field = request_field.field(); let span = field.span(); @@ -214,7 +215,7 @@ impl ToTokens for Request { struct RequestBody(#ty); }; } else if self.has_body_fields() { - let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, request_field| { + let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, request_field| { match *request_field { RequestField::Body(ref field) => { let span = field.span(); @@ -235,13 +236,13 @@ impl ToTokens for Request { } }; } else { - request_body_struct = Tokens::new(); + request_body_struct = TokenStream::new(); } let request_path_struct; if self.has_path_fields() { - let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, request_field| { + let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, request_field| { match *request_field { RequestField::Path(ref field) => { let span = field.span(); @@ -262,13 +263,13 @@ impl ToTokens for Request { } }; } else { - request_path_struct = Tokens::new(); + request_path_struct = TokenStream::new(); } let request_query_struct; if self.has_query_fields() { - let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, request_field| { + let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, request_field| { match *request_field { RequestField::Query(ref field) => { let span = field.span(); @@ -289,7 +290,7 @@ impl ToTokens for Request { } }; } else { - request_query_struct = Tokens::new(); + request_query_struct = TokenStream::new(); } tokens.append_all(quote! { diff --git a/src/api/response.rs b/src/api/response.rs index 39658f1f..7b4e6499 100644 --- a/src/api/response.rs +++ b/src/api/response.rs @@ -1,4 +1,5 @@ -use quote::{ToTokens, Tokens}; +use proc_macro2::{Span, TokenStream}; +use quote::{ToTokens, TokenStreamExt}; use syn::spanned::Spanned; use syn::{Field, Ident, Lit, Meta, NestedMeta}; @@ -21,13 +22,16 @@ impl Response { self.fields.iter().any(|field| field.is_header()) } - pub fn init_fields(&self) -> Tokens { - let mut tokens = Tokens::new(); + pub fn init_fields(&self) -> TokenStream { + let mut tokens = TokenStream::new(); for response_field in self.fields.iter() { match *response_field { ResponseField::Body(ref field) => { - let field_name = field.ident.expect("expected field to have an identifier"); + let field_name = field + .ident + .clone() + .expect("expected field to have an identifier"); let span = field.span(); tokens.append_all(quote_spanned! {span=> @@ -35,8 +39,11 @@ impl Response { }); } ResponseField::Header(ref field, ref header) => { - let field_name = field.ident.expect("expected field to have an identifier"); - let header_name = Ident::from(header.as_ref()); + let field_name = field + .ident + .clone() + .expect("expected field to have an identifier"); + let header_name = Ident::new(header.as_ref(), Span::call_site()); let span = field.span(); tokens.append_all(quote_spanned! {span=> @@ -48,7 +55,10 @@ impl Response { }); } ResponseField::NewtypeBody(ref field) => { - let field_name = field.ident.expect("expected field to have an identifier"); + let field_name = field + .ident + .clone() + .expect("expected field to have an identifier"); let span = field.span(); tokens.append_all(quote_spanned! {span=> @@ -94,7 +104,7 @@ impl From> for Response { _ => return true, }; - if meta_list.ident.as_ref() != "ruma_api" { + if &meta_list.ident.to_string() != "ruma_api" { return true; } @@ -103,7 +113,7 @@ impl From> for Response { NestedMeta::Meta(meta_item) => { match meta_item { Meta::Word(ident) => { - match ident.as_ref() { + match &ident.to_string()[..] { "body" => { has_newtype_body = true; field_kind = ResponseFieldKind::NewtypeBody; @@ -112,7 +122,7 @@ impl From> for Response { } } Meta::NameValue(name_value) => { - match name_value.ident.as_ref() { + match &name_value.ident.to_string()[..] { "header" => { match name_value.lit { Lit::Str(lit_str) => header = Some(lit_str.value()), @@ -156,7 +166,7 @@ impl From> for Response { } impl ToTokens for Response { - fn to_tokens(&self, tokens: &mut Tokens) { + fn to_tokens(&self, tokens: &mut TokenStream) { let response_struct_header = quote! { /// Data in the response from this API endpoint. #[derive(Debug)] @@ -166,7 +176,7 @@ impl ToTokens for Response { let response_struct_body = if self.fields.len() == 0 { quote!(;) } else { - let fields = self.fields.iter().fold(Tokens::new(), |mut fields_tokens, response_field| { + let fields = self.fields.iter().fold(TokenStream::new(), |mut fields_tokens, response_field| { let field = response_field.field(); let span = field.span(); @@ -197,7 +207,7 @@ impl ToTokens for Response { struct ResponseBody(#ty); }; } else if self.has_body_fields() { - let fields = self.fields.iter().fold(Tokens::new(), |mut field_tokens, response_field| { + let fields = self.fields.iter().fold(TokenStream::new(), |mut field_tokens, response_field| { match *response_field { ResponseField::Body(ref field) => { let span = field.span(); @@ -218,7 +228,7 @@ impl ToTokens for Response { } }; } else { - response_body_struct = Tokens::new(); + response_body_struct = TokenStream::new(); } tokens.append_all(quote! { diff --git a/src/lib.rs b/src/lib.rs index 6306380d..c2134f43 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -4,13 +4,13 @@ //! See the documentation for the `ruma_api!` macro for usage details. #![deny(missing_debug_implementations)] -#![feature(proc_macro)] #![recursion_limit="256"] extern crate proc_macro; +extern crate proc_macro2; #[macro_use] extern crate quote; extern crate ruma_api; -#[macro_use] extern crate syn; +extern crate syn; use proc_macro::TokenStream; @@ -202,9 +202,9 @@ mod api; /// ``` #[proc_macro] pub fn ruma_api(input: TokenStream) -> TokenStream { - let raw_api: RawApi = syn::parse(input).expect("ruma_api! failed to parse input"); + let raw_api = syn::parse_macro_input!(input as RawApi); let api = Api::from(raw_api); - api.into_tokens().into() + api.into_token_stream().into() } diff --git a/tests/ruma_api_macros.rs b/tests/ruma_api_macros.rs index 43cd5472..b37f20f6 100644 --- a/tests/ruma_api_macros.rs +++ b/tests/ruma_api_macros.rs @@ -1,4 +1,4 @@ -#![feature(proc_macro, try_from)] +#![feature(try_from)] extern crate futures; extern crate http;