taurpc-macros 0.8.2

Macros for the taurpc crate
Documentation 
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
136
137
138
139
140
141
142
143
144

use super::extend_errors;
use proc_macro2::Ident;
use syn::{
    Attribute, Expr, Lit, LitStr, MetaNameValue, Token,
    parse::{Parse, ParseStream},
    spanned::Spanned,
};

/// Attributes added on the procedures trait itself, `#[taurpc::procedures( ... )]`.
#[derive(Debug, Default)]
pub struct ProceduresAttrs {
    pub event_trigger_ident: Option<Ident>,
    pub path: String,
}

impl Parse for ProceduresAttrs {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let meta_items = input.parse_terminated(MetaNameValue::parse, Token![,])?;

        let mut errors = Ok(());
        let mut result = Self::default();

        for meta in meta_items {
            if meta.path.segments.len() != 1 {
                extend_errors!(
                    errors,
                    syn::Error::new(
                        meta.span(),
                        "taurpc::procedures does not support this meta item"
                    )
                );
            }

            if meta.path.is_ident("event_trigger") {
                if let Expr::Path(p) = meta.value {
                    if p.path.segments.len() != 1 {
                        extend_errors!(
                            errors,
                            syn::Error::new(
                                p.span(),
                                "taurpc::procedures does not support this meta value"
                            )
                        );
                    }

                    let ident = p.path.get_ident().unwrap();
                    result.event_trigger_ident = Some(ident.clone());
                }
            } else if meta.path.is_ident("path") {
                if let Expr::Lit(p) = meta.value {
                    match p.lit {
                        Lit::Str(str) => {
                            // TODO: validate path
                            result.path = str.value()
                        }
                        _ => {
                            extend_errors!(
                                errors,
                                syn::Error::new(p.span(), "path should be a str")
                            );
                        }
                    }
                } else {
                    extend_errors!(
                        errors,
                        syn::Error::new(meta.path.span(), "path should be a str")
                    );
                }
            } else {
                extend_errors!(
                    errors,
                    syn::Error::new(meta.path.span(), "Unsupported attribute")
                );
            }
        }

        errors?;

        Ok(result)
    }
}

/// Attributes defined on methods inside a procedures trait.
/// Parse the attributes to make sure they are defined in the correct way, like `#[taurpc( ... )]`, accumulate
/// all errors and then display them together with `extend_errors!()`.  
#[derive(Default)]
pub struct MethodAttrs {
    pub(crate) skip: bool,
    pub(crate) alias: Option<String>,
    pub(crate) is_event: bool,
    pub(crate) comments: Vec<String>,
    /// Attributes to forward to the generated code (e.g., #[allow(...)])
    pub(crate) passthrough_attrs: Vec<Attribute>,
}

impl Parse for MethodAttrs {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let mut res = MethodAttrs::default();
        let attrs = input.call(Attribute::parse_outer)?;

        let mut errors = Ok(());

        for attr in attrs {
            if attr.path().is_ident("doc") {
                if let syn::Meta::NameValue(meta) = &attr.meta {
                    if let Expr::Lit(expr_lit) = &meta.value {
                        if let Lit::Str(lit_str) = &expr_lit.lit {
                            res.comments.push(lit_str.value().trim().to_string());
                        }
                    }
                }
            }
            if !attr.path().is_ident("taurpc") {
                // Forward non-taurpc attributes (like #[allow(...)], #[cfg(...)], etc.) to generated code
                res.passthrough_attrs.push(attr);
                continue;
            }

            if let Err(e) = attr.parse_nested_meta(|meta| {
                if meta.path.is_ident("skip") {
                    res.skip = true;
                    Ok(())
                } else if meta.path.is_ident("event") {
                    res.is_event = true;
                    Ok(())
                } else if meta.path.is_ident("alias") {
                    let value = meta.value()?;
                    let alias: LitStr = value.parse()?;

                    res.alias = Some(alias.value());
                    Ok(())
                } else {
                    Err(meta.error("unsupported attribute"))
                }
            }) {
                extend_errors!(errors, e);
            };
        }

        errors?;

        Ok(res)
    }
}