mingling_macros 0.1.9

Macros of the mingling library
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

use proc_macro::TokenStream;
use quote::quote;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::{Expr, LitStr, Token, parse_macro_input};

struct SuggestInput {
    items: Punctuated<SuggestItem, Token![,]>,
}

enum SuggestItem {
    WithDesc(Box<(LitStr, Expr)>), // "-i" = "Insert something"
    Simple(LitStr),                // "-I"
}

impl Parse for SuggestInput {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let items = Punctuated::parse_terminated(input)?;
        Ok(SuggestInput { items })
    }
}

impl Parse for SuggestItem {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let key: LitStr = input.parse()?;

        if input.peek(Token![:]) {
            let _colon: Token![:] = input.parse()?;
            let value: Expr = input.parse()?;
            Ok(SuggestItem::WithDesc(Box::new((key, value))))
        } else {
            Ok(SuggestItem::Simple(key))
        }
    }
}

#[cfg(feature = "comp")]
pub fn suggest(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as SuggestInput);

    let mut items = Vec::new();

    for item in input.items {
        match item {
            SuggestItem::WithDesc(boxed) => {
                let (key, value) = *boxed;
                items.push(quote! {
                    ::mingling::SuggestItem::new_with_desc(#key.to_string(), #value.to_string())
                });
            }
            SuggestItem::Simple(key) => {
                items.push(quote! {
                    ::mingling::SuggestItem::new(#key.to_string())
                });
            }
        }
    }

    let expanded = if items.is_empty() {
        quote! {
            ::mingling::Suggest::new()
        }
    } else {
        quote! {{
            let mut suggest = ::mingling::Suggest::new();
            #(suggest.insert(#items);)*
            suggest
        }}
    };

    expanded.into()
}

pub fn suggest_enum(input: TokenStream) -> TokenStream {
    let enum_type = parse_macro_input!(input as syn::Type);

    let expanded = quote! {{
        let mut enum_suggest = ::mingling::Suggest::new();
        for (name, desc) in <#enum_type>::enums() {
            if desc.is_empty() {
                enum_suggest.insert(::mingling::SuggestItem::new(name.to_string()));
            } else {
                enum_suggest.insert(::mingling::SuggestItem::new_with_desc(
                    name.to_string(),
                    desc.to_string(),
                ));
            }
        }
        enum_suggest
    }};

    expanded.into()
}