miko-macros 0.3.10

Macros for miko
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

use quote::quote;
use std::collections::HashMap;
use syn::parse::{Parse, ParseStream};
use syn::{Expr, ExprLit, Lit, LitStr, Meta, Token};

#[derive(Debug, Clone)]
pub struct StrAttrMap {
    pub map: HashMap<String, String>,
    pub default: Option<String>,
}
impl StrAttrMap {
    pub fn new() -> Self {
        Self {
            map: HashMap::new(),
            default: None,
        }
    }
}

impl Parse for StrAttrMap {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        Ok(StrAttrMap::from_parse_stream(input))
    }
}

impl StrAttrMap {
    pub fn from_parse_stream(input: ParseStream) -> Self {
        let mut _default = None;
        let mut map = HashMap::new();
        while !input.is_empty() {
            if input.peek(LitStr) {
                let s: LitStr = input.parse().unwrap();
                _default = Some(s.value());
            } else {
                let meta: Meta = input.parse().unwrap();
                match meta {
                    Meta::NameValue(nvmeta) => {
                        let ident = nvmeta.path.get_ident().unwrap();
                        if let Expr::Lit(ExprLit {
                            lit: Lit::Str(str), ..
                        }) = nvmeta.value
                        {
                            map.insert(ident.to_string(), str.value());
                        }
                    }
                    Meta::Path(path) => {
                        let ident = path.get_ident().unwrap().to_string();
                        map.insert(ident.clone(), ident);
                    }
                    _ => {}
                }
            }
            if input.peek(Token![,]) {
                let _comma: Token![,] = input.parse().unwrap();
            }
        }
        Self {
            map,
            default: _default,
        }
    }

    pub fn get(&self, key: &str) -> Option<&String> {
        self.map.get(key)
    }
    pub fn get_or_default(&self, key: &str) -> Option<String> {
        self.map
            .get(key)
            .map(|s| s.to_string())
            .or(self.default.clone())
    }

    pub fn to_token_stream(&self) -> proc_macro2::TokenStream {
        let mut tokens = proc_macro2::TokenStream::new();
        if let Some(ref default) = self.default {
            tokens.extend(quote! {
                #default
            });
            if !self.map.is_empty() {
                tokens.extend(quote! { , });
            }
        }
        let entries: Vec<_> = self.map.iter().collect();
        for (idx, (key, value)) in entries.iter().enumerate() {
            let key_ident = syn::Ident::new(key, proc_macro2::Span::call_site());
            tokens.extend(quote! {
                #key_ident = #value
            });
            if idx < entries.len() - 1 {
                tokens.extend(quote! { , });
            }
        }

        tokens
    }
}