knave 0.14.21

A Lisp programming language for humans and agents that infers types and ownership and compiles to readable Rust
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

use std::ffi::OsString;

use clap::ValueEnum;

#[derive(Clone, Copy, Default, ValueEnum)]
pub enum ColorWhen {
    #[default]
    Auto,
    Always,
    Never,
}

impl ColorWhen {
    const FLAG: &str = "--color";
    const FLAG_WITH_VALUE: &str = "--color=";
    const END_OF_OPTIONS: &str = "--";

    pub fn written_in(arguments: &[OsString]) -> Self {
        let options: Vec<&str> = arguments
            .iter()
            .map(|argument| argument.to_str().unwrap_or_default())
            .take_while(|argument| *argument != Self::END_OF_OPTIONS)
            .collect();
        options
            .windows(2)
            .filter_map(Self::written_value)
            .next_back()
            .and_then(|value| Self::from_str(value, false).ok())
            .unwrap_or_default()
    }

    fn written_value<'a>(pair: &[&'a str]) -> Option<&'a str> {
        match pair {
            [Self::FLAG, value] => Some(value),
            [_, option] => option.strip_prefix(Self::FLAG_WITH_VALUE),
            _ => None,
        }
    }
}

impl From<ColorWhen> for clap::ColorChoice {
    fn from(when: ColorWhen) -> Self {
        match when {
            ColorWhen::Auto => Self::Auto,
            ColorWhen::Always => Self::Always,
            ColorWhen::Never => Self::Never,
        }
    }
}

impl From<ColorWhen> for anstream::ColorChoice {
    fn from(when: ColorWhen) -> Self {
        match when {
            ColorWhen::Auto => Self::Auto,
            ColorWhen::Always => Self::Always,
            ColorWhen::Never => Self::Never,
        }
    }
}