inquiry 0.1.1

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

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

fn enum_choice_impl(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as syn::DeriveInput);
    let enum_name = &input.ident;

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

    TokenStream::from(expanded)
}

#[proc_macro_derive(Choice)]
pub fn derive_enum_choice(input: TokenStream) -> TokenStream {
    enum_choice_impl(input)
}