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

use cote::prelude::*;
use std::{ffi::OsStr, fmt::Debug};

// The handler must be a generic function.
#[derive(Debug, Cote, PartialEq, Eq)]
#[cote(help, on = display_cli)]
pub struct Cli {
    #[arg(on = empty_handler, then = foo_storer)]
    foo: u64,

    #[sub(force = false)]
    bar: Option<Bar>,

    #[sub(force = false)]
    qux: Option<Qux>,
}

#[derive(Debug, Cote, PartialEq, Eq)]
#[cote(help)]
pub struct Bar {
    #[arg(force = false, fallback = debug_of_bar)]
    debug: bool,

    #[pos()]
    quux: String,
}

#[derive(Debug, Cote, PartialEq, Eq)]
#[cote(help, fallback = process_qux, then = unreachable_storer)]
pub struct Qux {
    #[cmd(name = "c")]
    corge: bool,

    grault: Option<i64>,
}

fn main() -> color_eyre::Result<()> {
    color_eyre::install()?;

    // unwrap the failure of return value
    Cli::parse_env_args()?.ret.unwrap();

    Ok(())
}

fn display_cli<Set>(set: &mut Set, _: &mut Ctx) -> Result<Option<()>, aopt::Error>
where
    Set: SetValueFindExt + cote::prelude::Set,
    SetCfg<Set>: ConfigValue + Default,
{
    println!("Got client: {:?}", Cli::try_extract(set)?);
    Ok(None)
}

fn empty_handler<Set>(_: &mut Set, ctx: &mut Ctx) -> Result<Option<u64>, aopt::Error> {
    Ok(ctx.value::<u64>().ok())
}

fn foo_storer<Set>(
    uid: Uid,
    set: &mut Set,
    raw: Option<&OsStr>,
    val: Option<u64>,
) -> Result<bool, aopt::Error>
where
    Set: SetValueFindExt + cote::prelude::Set,
    SetCfg<Set>: ConfigValue + Default,
{
    let has_value = val.is_some();

    // Set the value if return Some(Value)
    if let Some(val) = val {
        if let Some(opt) = set.get_mut(uid) {
            let (raw_handler, handler) = opt.accessor_mut().handlers();

            if let Some(raw_value) = raw {
                raw_handler.push(raw_value.to_os_string());
            }
            println!("Saving the value of `--foo` to {}", val + 1);
            // modify the value, plus one
            handler.push(val + 1);
        }
    }

    Ok(has_value)
}

fn debug_of_bar<Set>(_: &mut Set, ctx: &mut Ctx) -> Result<Option<()>, aopt::Error> {
    let raw = ctx.arg()?.unwrap();
    let value = ctx.value::<bool>()?;

    println!("Got value of `--debug`: {:?} --> {}", raw, value);
    // if return None, the parser will call default handler of current option
    Ok(None)
}

fn process_qux<Set>(_: &mut Set, _: &mut Ctx) -> Result<Option<()>, aopt::Error>
where
    Set: SetValueFindExt + cote::prelude::Set,
    SetCfg<Set>: ConfigValue + Default,
{
    println!("return Ok(None) call the default handler of Qux");
    Ok(None)
}

fn unreachable_storer<Set>(
    _: Uid,
    _: &mut Set,
    _: Option<&OsStr>,
    _: Option<()>,
) -> Result<bool, aopt::Error>
where
    Set: SetValueFindExt + cote::prelude::Set,
    SetCfg<Set>: ConfigValue + Default,
{
    unreachable!("Never go here")
}