Project Anni 之旅 01 - 从 clap-builder 到 derive

1
    let matches = App::new("My Super Program")
2
        .version("1.0")
3
        .author("Kevin K. <[email protected]>")
4
        .about("Does awesome things")
5
        .arg(Arg::new("config")
6
            .short('c')
7
            .long("config")
8
            .value_name("FILE")
9
            .about("Sets a custom config file")
10
            .takes_value(true))
11
        .arg(Arg::new("INPUT")
12
            .about("Sets the input file to use")
13
            .required(true)
14
            .index(1))
15
        .arg(Arg::new("v")
16
            .short('v')
17
            .multiple_occurrences(true)
18
            .takes_value(true)
19
            .about("Sets the level of verbosity"))
20
        .subcommand(App::new("test")
21
            .about("controls testing features")
22
            .version("1.3")
23
            .author("Someone E. <[email protected]>")
24
            .arg(Arg::new("debug")
25
                .short('d')
26
                .about("print debug information verbosely")))
27
        .get_matches();
28

29
    // You can check the value provided by positional arguments, or option arguments
30
    if let Some(i) = matches.value_of("INPUT") {
31
        println!("Value for input: {}", i);
32
    }
33

34
    if let Some(c) = matches.value_of("config") {
35
        println!("Value for config: {}", c);
36
    }
37

38
    // You can see how many times a particular flag or argument occurred
39
    // Note, only flags can have multiple occurrences
40
    match matches.occurrences_of("v") {
41
        0 => println!("Verbose mode is off"),
42
        1 => println!("Verbose mode is kind of on"),
43
        2 => println!("Verbose mode is on"),
44
        _ => println!("Don't be crazy"),
45
    }
46

47
    // You can check for the existence of subcommands, and if found use their
48
    // matches just as you would the top level app
49
    if let Some(ref matches) = matches.subcommand_matches("test") {
50
        // "$ myapp test" was run
51
        if matches.is_present("debug") {
52
            // "$ myapp test -d" was run
53
            println!("Printing debug info...");
54
        } else {
55
            println!("Printing normally...");
56
        }
57
    }

1
// 顶层命令
2
// 包含了 root 属性和不同的 subcommand
3
#[derive(Clap, Debug)]
4
pub struct RepoSubcommand {
5
    #[clap(long, env = "ANNI_REPO")]
6
    root: PathBuf,
7

8
    #[clap(subcommand)]
9
    action: RepoAction,
10
}
11

12
// 第二层的 Subcommand
13
// 包含各个子命令的声明方式
14
#[derive(Clap, Debug)]
15
pub enum RepoAction {
16
    Add(RepoAddAction),
17
    Edit(RepoEditAction),
18
    Apply(RepoApplyAction),
19
    Validate(RepoValidateAction),
20
    Print(RepoPrintAction),
21
}
22

23
// 第三层的命令
24
// 实际执行的操作
25
#[derive(Clap, Debug)]
26
pub struct RepoAddAction {
27
    #[clap(short = 'e', long)]
28
    open_editor: bool,
29

30
    #[clap(required = true)]
31
    directories: Vec<PathBuf>,
32
}

1
#[derive(Clap)]
2
struct SimpleCommand {
3
    #[clap(subcommand)]
4
    subcommand: SimpleSubcommand;
5
}
6

7
#[clap(Clap)]
8
enum SimpleSubcommand {
9
    A(SubcommandA),
10
    B(SubcommandB),
11
}
12

13
#[clap(Clap)]
14
struct SubcommandA {
15
    #[clap(short, long)]
16
    arg1: String,
17
}
18

19
#[clap(Clap)]
20
struct SubcommandB {
21
    #[clap(short, long)]
22
    arg2: String,
23
}

1
pub trait Handle {
2
    fn handle(&self) -> anyhow::Result<()>;
3
}
4

5
#[proc_macro_derive(ClapHandler)]
6
pub fn derive_clap_handler(item: TokenStream) -> TokenStream {
7
    let input = parse_macro_input!(item as DeriveInput);
8
    let name = &input.ident;
9

10
    let expanded = match input.data {
11
        Data::Struct(DataStruct { ref fields, .. }) => {
12
            match fields {
13
                Fields::Named(ref fields_name) => {
14
                    // find struct field which has #[clap(subcommand)]
15
                    let subcommand_field: Option<syn::Ident> = fields_name
16
                        .named
17
                        .iter()
18
                        .find_map(|field| {
19
                            for attr in field.attrs.iter() {
20
                                if attr.path.is_ident("clap") {
21
                                    let ident: syn::Ident = attr.parse_args().ok()?;
22
                                    if ident == "subcommand" {
23
                                        return Some(field.ident.clone().unwrap());
24
                                    }
25
                                }
26
                            }
27
                            None
28
                        })
29
                        .expect("Failed to find #[clap(subcommand)] in struct!");
30

31
                    quote! {
32
                        impl Handle for #name {
33
                            fn handle(&self) -> anyhow::Result<()> {
34
                                self.#subcommand_field.handle()
35
                            }
36
                        }
37
                    }
38
                }
39
                _ => panic!("ClapHandler is not implemented for unnamed or None struct"),
40
            }
41
        }
42
        Data::Enum(DataEnum { variants, .. }) => {
43
            // list enum variants
44
            let subcommands: Vec<_> = variants
45
                .iter()
46
                .map(|v| {
47
                    let ident = &v.ident;
48
                    quote! { #name::#ident }
49
                })
50
                .collect();
51

52
            quote! {
53
                impl Handler for #name {
54
                    #[inline(always)]
55
                    fn handle(&self) -> anyhow::Result<()> {
56
                        match self {
57
                            #(#subcommands(s) => s.handle(),)*
58
                        }
59
                    }
60
                }
61
            }
62
        }
63
        _ => panic!("ClapHandler is not implemented for union type"),
64
    };
65
    expanded.into()
66
}