debate-derive 1.0.0

derive macro for the `debate` CLI arguments parser
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

use itertools::Itertools;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::{
    Data, DeriveInput, Ident, Token, Type, Variant, punctuated::Punctuated, spanned::Spanned as _,
};

use crate::{
    common::value::AnalyzedEnum,
    generics::{AngleBracedLifetime, compute_generics},
};

fn derive_newtype_usage(
    ident: &Ident,
    field_type: &Type,
    type_lifetime: Option<&AngleBracedLifetime>,
) -> syn::Result<TokenStream2> {
    Ok(quote! {
        impl #type_lifetime ::debate::help::ParameterUsage for #ident $type_lifetime {
            const VALUE: ::debate::help::ParameterValueKind =
                <#field_type as ::debate::help::ParameterUsage>::VALUE;

            const REQUIREMENT: ::debate::help::Requirement =
                <#field_type as ::debate::help::ParameterUsage>::REQUIREMENT;

            const REPETITION: ::debate::help::Repetition =
                <#field_type as ::debate::help::ParameterUsage>::REPETITION;
        }
    })
}

fn derive_value_enum_usage(
    ident: &Ident,
    variants: &Punctuated<Variant, Token![,]>,
    type_lifetime: Option<&AngleBracedLifetime>,
) -> syn::Result<TokenStream2> {
    let analyzed = AnalyzedEnum::from_variants(variants)?;
    let variant_names = analyzed.variants.iter().map(|(value, _)| value.as_str());

    let kind = match analyzed.fallback {
        None => quote! { OneOf(&[#(#variant_names,)*]) },
        Some(_) => quote! { Value },
    };

    Ok(quote! {
        impl #type_lifetime ::debate::help::ParameterUsage for #ident #type_lifetime {
            const VALUE: ::debate::help::ParameterValueKind =
                ::debate::help::ParameterValueKind:: #kind;

            const REQUIREMENT: ::debate::help::Requirement =
                ::debate::help::Requirement::Mandatory;

            const REPETITION: ::debate::help::Repetition =
                ::debate::help::Repetition::Single;
        }
    })
}

pub fn derive_parameter_usage_result(tokens: TokenStream2) -> syn::Result<TokenStream2> {
    let input: DeriveInput = syn::parse2(tokens)?;
    let (_, type_lifetime) = compute_generics(&input.generics)?;

    match input.data {
        Data::Struct(ref data) => {
            let field = data.fields.iter().exactly_one().map_err(|_| {
                syn::Error::new(
                    input.span(),
                    "can only derive `ParameterUsage` on structs with exactly one field",
                )
            })?;

            derive_newtype_usage(&input.ident, &field.ty, type_lifetime.as_ref())
        }
        Data::Enum(ref data) => {
            derive_value_enum_usage(&input.ident, &data.variants, type_lifetime.as_ref())
        }
        Data::Union(_) => Err(syn::Error::new(
            input.span(),
            "can't derive `ParameterUsage` on a union",
        )),
    }
}