mmz 0.13.0

memoized command runner
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

//! Maps an invoked command to the rule that memoizes it.

use crate::manifest::{Command, MatchMode};

/// Returns the first command rule that matches `argv` under its match mode.
///
/// Rules are tried in manifest order, so the author orders specific rules
/// before general ones. A `prefix` rule named `cargo test` matches `cargo test`,
/// `cargo test --workspace`, and so on, but not `cargo build`; an `exact` rule
/// matches only the bare `cargo test`.
#[must_use]
pub fn first_match<'a>(commands: &'a [Command], argv: &[String]) -> Option<&'a Command> {
    commands.iter().find(|command| matches(command, argv))
}

/// True when `command` matches `argv` under its [`MatchMode`]. An empty matcher
/// (a name with no tokens) never matches.
pub(crate) fn matches(command: &Command, argv: &[String]) -> bool {
    let tokens: Vec<&str> = command.name.split_whitespace().collect();
    if tokens.is_empty() {
        return false;
    }
    match command.match_mode {
        MatchMode::Prefix => leads(&tokens, argv),
        MatchMode::Exact => argv.len() == tokens.len() && leads(&tokens, argv),
    }
}

/// True when `tokens` equal the leading `tokens.len()` entries of `argv`.
fn leads(tokens: &[&str], argv: &[String]) -> bool {
    match argv.get(..tokens.len()) {
        Some(prefix) => prefix.iter().map(String::as_str).eq(tokens.iter().copied()),
        None => false,
    }
}

#[cfg(test)]
mod tests {
    use super::first_match;
    use crate::manifest::{Command, MatchMode};

    fn rule(name: &str) -> Command {
        Command {
            name: name.to_owned(),
            inputs: Vec::new(),
            exclude: Vec::new(),
            match_mode: MatchMode::Prefix,
            outputs: Vec::new(),
            tags: Vec::new(),
            on_hit: None,
            ttl: None,
        }
    }

    fn exact_rule(name: &str) -> Command {
        Command {
            name: name.to_owned(),
            inputs: Vec::new(),
            exclude: Vec::new(),
            match_mode: MatchMode::Exact,
            outputs: Vec::new(),
            tags: Vec::new(),
            on_hit: None,
            ttl: None,
        }
    }

    fn argv(parts: &[&str]) -> Vec<String> {
        parts.iter().map(|part| (*part).to_owned()).collect()
    }

    #[test]
    fn matches_token_prefix() {
        let rules = [rule("cargo test")];
        assert!(first_match(&rules, &argv(&["cargo", "test", "--workspace"])).is_some());
        assert!(first_match(&rules, &argv(&["cargo", "build"])).is_none());
        assert!(
            first_match(&rules, &argv(&["cargo"])).is_none(),
            "shorter than matcher"
        );
    }

    #[test]
    fn first_rule_in_order_wins() {
        let rules = [rule("cargo"), rule("cargo test")];
        let hit = first_match(&rules, &argv(&["cargo", "test"])).expect("match");
        assert_eq!(hit.name, "cargo", "earlier rule wins on a tie");
    }

    #[test]
    fn token_boundary_is_respected() {
        let rules = [rule("car")];
        assert!(
            first_match(&rules, &argv(&["cargo"])).is_none(),
            "no partial-token match"
        );
    }

    #[test]
    fn exact_rejects_trailing_args() {
        let rules = [exact_rule("cargo test")];
        assert!(
            first_match(&rules, &argv(&["cargo", "test"])).is_some(),
            "exact matches the bare command"
        );
        assert!(
            first_match(&rules, &argv(&["cargo", "test", "--workspace"])).is_none(),
            "exact rejects extra args a prefix rule would accept"
        );
    }
}