cote 0.17.1

Quickly build your command line utils
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

#![allow(unused)]
use std::ffi::OsString;

use aopt::shell::get_complete_cli;
use aopt::shell::value::once_values;
use cote::prelude::*;
use cote::shell::shell::Complete;
use cote::shell::value::Values;
use cote::shell::CompletionManager;

pub const OS: [&str; 4] = ["HarmonyOS", "Windows", "Android", "MacOS"];

#[derive(Debug, Cote)]
#[cote(shellcomp)]
struct OperateSystem {
    /// Enable user flag
    preserve_user: bool,

    /// Migrate from on OS to another OS
    #[sub(scvalues)]
    migrate: Option<Migrate>,

    /// Install OS from server
    #[sub(scvalues)]
    install: Option<Install>,

    /// Update OS
    #[sub()]
    update: Option<Update>,
}

#[derive(Debug, Cote)]
pub struct Migrate {
    /// Set the OS server
    #[arg(scvalues = read_server_from_cfg())]
    server: Option<String>,

    /// Set the name of OS
    #[pos()]
    from: Option<String>,

    /// Set the name of OS
    #[pos()]
    to: Option<String>,
}

#[derive(Debug, Cote)]
pub struct Install {
    /// Set the OS server
    #[arg(scvalues = read_server_from_cfg())]
    server: Option<String>,

    /// Set the name of OS
    #[pos(scvalues = OS)]
    name: Option<String>,
}

#[derive(Debug, Cote)]
pub struct Update {
    /// Enable yes flag
    yes: bool,

    /// Enable only flag
    only: bool,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // pass the executable binary name
    if try_complete("sub_shell_completion").is_ok() {
        return Ok(());
    }

    // do normal command line things
    let _ = OperateSystem::parse_env()?;

    Ok(())
}

pub fn try_complete(name: &str) -> Result<(), Box<dyn std::error::Error>> {
    let cli = get_complete_cli()?;

    if cli.write_stdout(name, name).is_ok() {
        return Ok(());
    }
    cli.complete(|shell| {
        let mut ctx = cli.get_context()?;
        let mut parser = OperateSystem::into_parser()?;
        let mut policy = OperateSystem::into_policy().with_prepolicy(true);

        // process arguments
        let _ = parser.parse_policy(Args::from(&cli.args), &mut policy);

        // get Migrate of from parser
        let migr = parser.take_val::<Migrate>("migrate").ok();
        let from = migr.and_then(|v| v.from);

        let mut manager = CompletionManager::new(parser);
        let migr = manager.find_manager_mut("migrate")?;

        // set values of from and to
        migr.set_values(migr.parser().find_uid("from")?, OS);
        migr.set_values(migr.parser().find_uid("to")?, list_os_except(from));

        // inject other values
        OperateSystem::inject_completion_values(&mut manager)?;

        // set buff of shell
        shell.set_buff(std::io::stdout());

        // do complete
        manager.complete(shell, &mut ctx)?;
        Ok(())
    })?;
    Ok(())
}

pub fn read_server_from_cfg<O>() -> impl Values<O> {
    once_values(|_| {
        Ok(["a.com", "b.org", "c.io"]
            .iter()
            .map(OsString::from)
            .collect())
    })
}

pub fn list_os_except<O>(from: Option<String>) -> impl Values<O> {
    once_values(move |_| {
        let mut vals = OS.to_vec();

        if let Some(idx) = from.as_ref().and_then(|r| vals.iter().position(|v| v == r)) {
            vals.swap_remove(idx);
        }
        Ok(vals.iter().map(OsString::from).collect())
    })
}