yofi 0.2.1

minimalistic menu for wayland
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

use once_cell::sync::OnceCell;
use regex::Regex;

#[derive(Debug)]
#[cfg_attr(test, derive(PartialEq, Eq))]
pub struct InputValue<'a> {
    pub source: &'a str,
    pub search_string: &'a str,
    pub args: Option<&'a str>,
    pub env_vars: Option<&'a str>,
    pub working_dir: Option<&'a str>,
}

impl InputValue<'static> {
    pub fn empty() -> Self {
        InputValue {
            source: "",
            search_string: "",
            args: None,
            env_vars: None,
            working_dir: None,
        }
    }
}

enum NextValueKind {
    Args,
    EnvVars,
    WorkingDir,
}

static SEPARATOR_REGEX: OnceCell<Regex> = OnceCell::new();

fn parse_command_part(input: &str) -> (&str, (&str, Option<NextValueKind>)) {
    let re = SEPARATOR_REGEX
        .get_or_init(|| Regex::new(r"(!!|#|~)").unwrap())
        .clone();
    let Some(cap) = re.captures(input) else {
        return ("", (input, None));
    };
    let m = cap.get(0).unwrap();
    let bang = cap.get(1).unwrap().as_str();
    let kind = match bang {
        "!!" => Some(NextValueKind::Args),
        "#" => Some(NextValueKind::EnvVars),
        "~" => Some(NextValueKind::WorkingDir),
        s => panic!("regex bug: unexpected bang match {}", s),
    };

    (&input[m.end()..], (&input[..m.start()], kind))
}

pub fn parse(source: &str) -> InputValue<'_> {
    let (mut input, (search_string, mut next_kind)) = parse_command_part(source);
    let mut command = InputValue {
        source,
        search_string,
        args: None,
        env_vars: None,
        working_dir: None,
    };

    while let Some(kind) = next_kind.take() {
        let (left, (cmd, new_kind)) = parse_command_part(input);

        match kind {
            NextValueKind::Args => command.args = Some(cmd),
            NextValueKind::EnvVars => command.env_vars = Some(cmd),
            NextValueKind::WorkingDir => command.working_dir = Some(cmd),
        }

        input = left;
        next_kind = new_kind;
    }

    debug_assert!(input.is_empty(), "trailing input: {}", input);

    command
}

#[cfg(test)]
mod tests {
    use super::{parse, InputValue};

    use quickcheck_macros::quickcheck;
    use test_case::test_case;

    #[test_case("", InputValue::empty(); "empty string")]
    #[test_case("qwdqwd asd asd", InputValue {
        search_string: "qwdqwd asd asd",
        ..InputValue::empty()
    }; "search string")]
    #[test_case("qwdqwd asd asd", InputValue {
        search_string: "qwdqwd asd asd",
        ..InputValue::empty()
    }; "search string with exact prefix")]
    #[test_case("qwdqwd!!asd#dsa", InputValue {
        search_string: "qwdqwd",
        args: Some("asd"),
        env_vars: Some("dsa"),
        ..InputValue::empty()
    }; "search string with args then env")]
    #[test_case("qwdqwd#dsa!!asd", InputValue {
        search_string: "qwdqwd",
        args: Some("asd"),
        env_vars: Some("dsa"),
        ..InputValue::empty()
    }; "search string with env then args")]
    #[test_case("qwdqwd~zx,c#qwe !!asd", InputValue {
        search_string: "qwdqwd",
        args: Some("asd"),
        env_vars: Some("qwe "),
        working_dir: Some("zx,c"),
        ..InputValue::empty()
    }; "search string with working dir then env then args")]
    #[test_case("#qwe~zx,c!!asd", InputValue {
        search_string: "",
        args: Some("asd"),
        env_vars: Some("qwe"),
        working_dir: Some("zx,c"),
        ..InputValue::empty()
    }; "all but search string")]
    #[test_case("ffx!!--new-instance#MOZ_ENABLE_WAYLAND=1~/run/user/1000", InputValue {
        search_string: "ffx",
        args: Some("--new-instance"),
        env_vars: Some("MOZ_ENABLE_WAYLAND=1"),
        working_dir: Some("/run/user/1000"),
        ..InputValue::empty()
    }; "with all params")]
    fn test_parse(input: &str, input_value: InputValue) {
        assert_eq!(
            parse(input),
            InputValue {
                source: input,
                ..input_value
            }
        );
    }

    #[quickcheck]
    fn test_parse_all(input: String) {
        parse(&input);
    }
}