1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
use proc_macro::TokenStream;
use proc_macro2::Span;
use quote::quote;
use syn::{parse_macro_input, spanned::Spanned, DeriveInput};
pub fn derive_paginated(input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as DeriveInput);
let name = &input.ident;
// Disallow Generic structs
if !input.generics.params.is_empty() {
return syn::Error::new(
Span::call_site(),
"Paginated Response structs cannot be generic",
)
.into_compile_error()
.into();
}
let field = match handle_field_attrs(&input) {
Ok(a) => a,
Err(e) => return e.to_compile_error().into(),
};
let tp = match extract_item(&field.ty) {
Ok(tp) => tp,
Err(e) => return e.to_compile_error().into(),
};
let Some(i_field) = &field.ident else {
return syn::Error::new(Span::call_site(), "missing field name")
.into_compile_error()
.into();
};
let expanded = quote! {
#[automatically_derived]
impl crate::PaginatedResponse for #name {
type Item = #tp;
fn items(&self) -> &[Self::Item] {
&self.#i_field.items
}
fn next_page(&self) -> Option<usize> {
self.#i_field.next_page()
}
}
};
TokenStream::from(expanded)
}
fn handle_field_attrs(input: &DeriveInput) -> syn::Result<&syn::Field> {
let syn::Data::Struct(data) = &input.data else {
return Err(syn::Error::new(
Span::call_site(),
"Paginated Response must be a struct",
));
};
let mut ret = None;
for field in &data.fields {
for attr in &field.attrs {
if attr.path().is_ident("trakt") {
attr.parse_nested_meta(|meta| {
if meta.path.is_ident("pagination") {
ret = Some(field);
Ok(())
} else {
Err(meta.error("unknown attribute"))
}
})?;
break;
}
}
}
if let Some(ret) = ret {
Ok(ret)
} else {
Err(syn::Error::new(
Span::call_site(),
"missing #[trakt(pagination)] attribute",
))
}
}
/// Extracts the inner type of `PaginationResponse<T>` type.
fn extract_item(tp: &syn::Type) -> syn::Result<&syn::Type> {
let syn::Type::Path(type_path) = tp else {
return Err(syn::Error::new(tp.span(), "expected a type path"));
};
let syn::Path { segments, .. } = &type_path.path;
let mut tp = None;
for segment in segments {
if segment.ident != "PaginationResponse" {
continue;
}
let syn::PathArguments::AngleBracketed(args) = &segment.arguments else {
return Err(syn::Error::new(
segment.ident.span(),
"expected angle-bracketed arguments",
));
};
let args = &args.args;
if args.len() != 1 {
return Err(syn::Error::new(
args.span(),
"expected exactly one argument",
));
}
if let syn::GenericArgument::Type(t) = &args[0] {
tp = Some(t);
break;
} else {
return Err(syn::Error::new(args.span(), "expected a type argument"));
}
}
if let Some(tp) = tp {
Ok(tp)
} else {
Err(syn::Error::new(
tp.span(),
"expected a PaginationResponse type",
))
}
}
|
