inquiry 0.1.4

A utility macro for the inquire 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

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn::{Data, DataEnum, DeriveInput, Variant, parse_macro_input};

#[proc_macro_derive(Choice, attributes(desc))]
pub fn derive_choice(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let enum_name = &input.ident;
    let variants = match &input.data {
        syn::Data::Enum(DataEnum { variants, .. }) => variants,
        _ => panic!("Choice can only be derived for enums"),
    };

    let variant_matches = variants.iter().map(|variant| {
        let variant_name = &variant.ident;
        let desc = get_doc_comment(variant)
            .unwrap_or_else(|| panic!("Missing description for variant {}", variant_name));

        quote! {
            #enum_name::#variant_name => #desc,
        }
    });

    let variants = if let Data::Enum(data_enum) = &input.data {
        data_enum
            .variants
            .iter()
            .map(|v| &v.ident)
            .collect::<Vec<_>>()
    } else {
        panic!("Choice only supports enums")
    };

    let module_name = format_ident!("__enum_choice_for_{}", enum_name.to_string().to_lowercase());

    let expanded = quote! {
        mod #module_name {
            use super::*;

            #[doc(hidden)]
            pub trait Variants<T: 'static> {
                const VARIANTS: &'static [T];
            }

            impl Variants<#enum_name> for #enum_name {
                const VARIANTS: &'static [#enum_name] = &[#(#enum_name::#variants),*];
            }

            pub use Variants as VariantsTrait;
        }

        impl #enum_name {
            fn description(&self) -> &'static str {
                match self {
                    #(#variant_matches)*
                }
            }

            pub fn choice(msg: &str) -> ::inquire::error::InquireResult<Self>
            where
                Self: ::std::fmt::Display + ::std::fmt::Debug + Copy + Clone + 'static
            {
                let answer: Self = ::inquire::Select::new(msg, <Self as #module_name::VariantsTrait<Self>>::VARIANTS.to_vec())
                    .prompt()?;

                Ok(answer)
            }
        }

        impl std::fmt::Display for #enum_name {
            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                write!(f, "{}", self.description())
            }
        }
    };

    TokenStream::from(expanded)
}

fn get_doc_comment(variant: &Variant) -> Option<String> {
    let mut lines: Vec<_> = variant
        .attrs
        .iter()
        .filter(|attr| attr.path().is_ident("doc"))
        .filter_map(|attr| match &attr.meta {
            syn::Meta::NameValue(syn::MetaNameValue {
                value:
                    syn::Expr::Lit(syn::ExprLit {
                        lit: syn::Lit::Str(s),
                        ..
                    }),
                ..
            }) => Some(s.value()),
            _ => None,
        })
        .skip_while(|s| s.trim().is_empty())
        .flat_map(|s| {
            s.split('\n')
                .map(|s| {
                    let s = s.strip_prefix(' ').unwrap_or(s);
                    s.to_owned()
                })
                .collect::<Vec<_>>()
        })
        .collect();

    while let Some(true) = lines.last().map(|s| s.trim().is_empty()) {
        lines.pop();
    }

    Some(lines.concat())
}