type-cli-derive 0.0.1

Derive macro for a convenient, type-safe CLI 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

use std::iter::IntoIterator as IntoIter;

use super::to_snake;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::{self, Attribute, Ident, Variant};

pub(super) fn parse(
    cmd_ident: &Ident,
    attrs: Vec<Attribute>,
    variants: impl IntoIter<Item = Variant>,
    iter_ident: &Ident,
) -> TokenStream2 {
    let parse_ty = crate_path!(Parse);
    let help_ty = crate_path!(HelpInfo);
    let err_ty = crate_path!(Error);

    let mut subc: Vec<String> = Vec::new();

    let mut _match = quote! {};

    for Variant {
        ident,
        attrs,
        fields,
        ..
    } in variants
    {
        let name = to_snake(&ident);

        let mut helpmsg = name.clone();
        if let Some(help) = try_help!(attrs.iter()) {
            helpmsg.push('\t');
            helpmsg.push_str(&help);
        }
        subc.push(helpmsg);

        let ctor = super::struct_cmd::parse(ident, attrs, fields, iter_ident);
        _match = quote! {
            #_match
            Some(#name) => {
                #ctor
            } ,
        };
    }

    let mut helpmsg = format!("Help - {}\n", to_snake(cmd_ident));
    if let Some(help) = attrs.iter().find(|a| a.path.is_ident("help")) {
        match super::parse_help(help) {
            Ok(help) => {
                helpmsg.push_str(&help);
                helpmsg.push_str("\n\n");
            }
            Err(e) => return e.to_compile_error().into(),
        }
    }

    helpmsg.push_str("SUBCOMMANDS:\n");
    for subc in subc {
        helpmsg.push_str("    ");
        helpmsg.push_str(&subc);
        helpmsg.push('\n');
    }

    quote! {
        use #cmd_ident::*;

        const HELP: &str = #helpmsg;

        match #iter_ident.next().as_deref() {
            #_match
            Some("--help") | Some("-h") | None => return Ok(#parse_ty::Help(#help_ty(HELP))),
            Some(sub) => return Err(#err_ty::UnknownSub(sub.to_string())),
        }
    }
}