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

Upgrade dependencies

Browse Source
This commit is contained in:
Jonas Platte 2018-11-10 14:04:46 +01:00
parent adf785ffc9
commit c9277ddc94
7 changed files with 110 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Cargo.toml
View File

@ -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

2
src/api/metadata.rs
View File

@ -25,7 +25,7 @@ impl From<Vec<FieldValue>> 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,

76
src/api/mod.rs
View File

@ -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<RawApi> 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<FieldValue, Token![,]>;
type ParseFields = Punctuated<Field, Token![,]>;
mod kw {
use syn::custom_keyword;
custom_keyword!(metadata);
custom_keyword!(request);
custom_keyword!(response);
}
pub struct RawApi {
pub metadata: Vec<FieldValue>,
@ -288,18 +293,33 @@ pub struct RawApi {
pub response: Vec<Field>,
}
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<Self> {
input.parse::<kw::metadata>()?;
let metadata;
braced!(metadata in input);
input.parse::<kw::request>()?;
let request;
braced!(request in input);
input.parse::<kw::response>()?;
let response;
braced!(response in input);
Ok(RawApi {
metadata: metadata
.parse_terminated::<FieldValue, Token![,]>(FieldValue::parse)?
.into_iter()
.collect(),
request: request
.parse_terminated::<Field, Token![,]>(Field::parse_named)?
.into_iter()
.collect(),
response: response
.parse_terminated::<Field, Token![,]>(Field::parse_named)?
.into_iter()
.collect(),
})
));
}
}

43
src/api/request.rs
View File

@ -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<Vec<Field>> 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<Vec<Field>> 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<Vec<Field>> 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<Vec<Field>> 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! {

38
src/api/response.rs
View File

@ -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<Vec<Field>> 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<Vec<Field>> 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<Vec<Field>> 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<Vec<Field>> 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! {

8
src/lib.rs
View File

@ -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()
}

2
tests/ruma_api_macros.rs
View File

@ -1,4 +1,4 @@
#![feature(proc_macro, try_from)]
#![feature(try_from)]
extern crate futures;
extern crate http;