flag-rs 0.10.0

A Cobra-inspired CLI framework with dynamic completions
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

use flag_rs::{Command, CommandBuilder, CompletionResult, Context, Flag, FlagType};

#[test]
fn test_complex_cli_app() {
    // Simulate a git-like CLI
    let app = build_git_cli();

    // Test: git clone https://example.com/repo.git
    let result = app.execute(vec![
        "clone".to_string(),
        "https://example.com/repo.git".to_string(),
    ]);
    assert!(result.is_ok());

    // Test: git -C /path/to/repo status
    let result = app.execute(vec![
        "-C".to_string(),
        "/path/to/repo".to_string(),
        "status".to_string(),
    ]);
    assert!(result.is_ok());

    // Test: git commit -m "Initial commit"
    let result = app.execute(vec![
        "commit".to_string(),
        "-m".to_string(),
        "Initial commit".to_string(),
    ]);
    if let Err(e) = &result {
        eprintln!("Commit test failed with: {e}");
    }
    assert!(result.is_ok());
}

fn build_git_cli() -> Command {
    CommandBuilder::new("git")
        .short("The stupid content tracker")
        .flag(
            Flag::new("work-tree")
                .short('C')
                .usage("Change to directory before doing anything")
                .value_type(FlagType::String),
        )
        .subcommand(build_clone_command())
        .subcommand(build_commit_command())
        .subcommand(build_status_command())
        .build()
}

fn build_clone_command() -> Command {
    CommandBuilder::new("clone")
        .short("Clone a repository into a new directory")
        .run(|ctx| {
            if let Some(url) = ctx.args().first() {
                println!("Cloning from: {url}");
            }
            Ok(())
        })
        .build()
}

fn build_commit_command() -> Command {
    CommandBuilder::new("commit")
        .short("Record changes to the repository")
        .flag(
            Flag::new("message")
                .short('m')
                .usage("Use the given message as the commit message")
                .value_type(FlagType::String),
        )
        .run(|ctx| {
            if let Some(message) = ctx.flag("message") {
                println!("Committing with message: {message}");
            }
            Ok(())
        })
        .build()
}

fn build_status_command() -> Command {
    CommandBuilder::new("status")
        .short("Show the working tree status")
        .run(|ctx| {
            if let Some(work_tree) = ctx.flag("work-tree") {
                println!("Checking status in: {work_tree}");
            } else {
                println!("Checking status in current directory");
            }
            Ok(())
        })
        .build()
}

#[test]
fn test_dynamic_completion() {
    let mut cmd = CommandBuilder::new("kubectl")
        .subcommand(
            CommandBuilder::new("get")
                .subcommand(
                    CommandBuilder::new("pods")
                        .arg_completion(|_ctx, prefix| {
                            // Simulate dynamic pod lookup
                            let pods = vec![
                                "nginx-7fb96c846b-8xvnl",
                                "nginx-7fb96c846b-kxptv",
                                "redis-master-0",
                                "redis-slave-0",
                            ];

                            Ok(CompletionResult::new().extend(
                                pods.into_iter()
                                    .filter(|p| p.starts_with(prefix))
                                    .map(String::from),
                            ))
                        })
                        .build(),
                )
                .build(),
        )
        .build();

    // Navigate to the pods subcommand for testing
    let pods_cmd = cmd
        .find_subcommand_mut("get")
        .and_then(|get| get.find_subcommand_mut("pods"))
        .unwrap();

    let ctx = Context::new(vec![]);

    // Test completion
    let result = pods_cmd.get_completions(&ctx, "nginx", None).unwrap();
    assert_eq!(result.values.len(), 2);
    assert!(
        result
            .values
            .contains(&"nginx-7fb96c846b-8xvnl".to_string())
    );
    assert!(
        result
            .values
            .contains(&"nginx-7fb96c846b-kxptv".to_string())
    );

    let result = pods_cmd.get_completions(&ctx, "redis", None).unwrap();
    assert_eq!(result.values.len(), 2);
    assert!(result.values.contains(&"redis-master-0".to_string()));
    assert!(result.values.contains(&"redis-slave-0".to_string()));
}

#[test]
fn test_nested_subcommands() {
    let app = CommandBuilder::new("app")
        .subcommand(
            CommandBuilder::new("level1")
                .subcommand(
                    CommandBuilder::new("level2")
                        .subcommand(
                            CommandBuilder::new("level3")
                                .run(|_ctx| {
                                    println!("Reached level 3!");
                                    Ok(())
                                })
                                .build(),
                        )
                        .build(),
                )
                .build(),
        )
        .build();

    let result = app.execute(vec![
        "level1".to_string(),
        "level2".to_string(),
        "level3".to_string(),
    ]);

    assert!(result.is_ok());
}