ziyy 2.0.3

Terminal Styling using HTML-like syntax.
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

#![allow(dead_code)]
use std::{env::Args, fmt::Display};

#[derive(Debug)]
pub enum Arg {
    ShortFlag(String, String),
    LongFlag(String, String),
    ShortSwitch(String),
    LongSwitch(String),
    Param(String),
}

impl Arg {
    pub fn is_long_switch_and(&self, f: fn(&String) -> bool) -> bool {
        match self {
            Arg::LongSwitch(s) => f(s),
            _ => false,
        }
    }

    pub fn is_short_switch_and(&self, f: fn(&String) -> bool) -> bool {
        match self {
            Arg::ShortSwitch(s) => f(s),
            _ => false,
        }
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn is_params_and(self, mut f: impl FnMut(String)) {
        if let Arg::Param(s) = self {
            f(s)
        }
    }
}

#[derive(Debug)]
pub enum Error {
    Long(String),
    Short(String),
}

impl Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::Long(v) => f.write_fmt(format_args!("--{v}")),
            Error::Short(v) => f.write_fmt(format_args!("-{v}")),
        }
    }
}

pub struct Cli<'a> {
    pub short_flags: &'a [&'a str],
    pub long_flags: &'a [&'a str],
    pub short_switches: &'a [&'a str],
    pub long_switches: &'a [&'a str],
}

fn split_args(args0: Args) -> Vec<String> {
    let mut args: Vec<String> = vec![];

    for arg in args0 {
        if let Some(ch) = arg.strip_prefix('-') {
            if ch.starts_with('-') {
                args.push(arg.clone());
                continue;
            }

            let _: Vec<_> = ch.chars().map(|v| args.push(format!("-{v}"))).collect();
            continue;
        }

        args.push(arg.clone());
    }

    args
}

pub fn parse_args(args0: Args, cli: Cli) -> Result<Vec<Arg>, Error> {
    let _args0 = split_args(args0);
    let mut parts = _args0.split(|x| x == "--");
    let args0 = parts.next().unwrap();
    let mut args = vec![];

    let mut i = 0;
    let length = args0.len();
    while i < length {
        let arg = args0[i].clone();
        if let Some(arg) = arg.strip_prefix("--") {
            if arg.contains('=') {
                let mut split = arg.split('=');
                let key = split.next().unwrap();
                let value = split.collect::<Vec<_>>().join("=");
                if cli.long_flags.contains(&key) {
                    args.push(Arg::LongFlag(key.to_owned(), value));
                } else {
                    return Err(Error::Long(key.to_owned()));
                }
            } else {
                let key = arg;
                if cli.long_flags.contains(&key) {
                    args.push(Arg::LongFlag(key.to_owned(), args0[i + 1].clone()));
                    i += 1;
                } else if cli.long_switches.contains(&key) {
                    args.push(Arg::LongSwitch(key.to_owned()));
                } else {
                    return Err(Error::Long(key.to_owned()));
                }
            }
        } else if let Some(arg) = arg.strip_prefix("-") {
            if arg.contains('=') {
                let mut split = arg.split('=');
                let key = split.next().unwrap();
                let value = split.collect::<Vec<_>>().join("=");
                if cli.short_flags.contains(&key) {
                    args.push(Arg::ShortFlag(key.to_owned(), value));
                } else {
                    return Err(Error::Short(key.to_owned()));
                }
            } else {
                let key = arg;
                if cli.short_flags.contains(&key) {
                    args.push(Arg::ShortFlag(key.to_owned(), args0[i + 1].clone()));
                    i += 1;
                } else if cli.short_switches.contains(&key) {
                    args.push(Arg::ShortSwitch(key.to_owned()));
                } else {
                    return Err(Error::Short(key.to_owned()));
                }
            }
        } else {
            args.push(Arg::Param(arg));
        }
        i += 1;
    }

    args.extend(
        parts
            .collect::<Vec<_>>()
            .join(&String::from("--"))
            .iter()
            .map(|x| Arg::Param(x.clone())),
    );

    Ok(args)
}