megafine 0.2.0

A multithreaded command-line benchmarking tool
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

use std::io::Read;

use anyhow::{Context, Result, bail};

use crate::cli::Cli;

pub struct Command<'a> {
    pub line: &'a str,
    pub name: Option<&'a str>,
}

impl Command<'_> {
    pub fn label(&self) -> &str {
        self.name.unwrap_or(self.line)
    }
}

pub fn from_cli(cli: &Cli) -> Vec<Command<'_>> {
    let names = cli.command_name.as_deref().unwrap_or_default();
    cli.commands
        .iter()
        .enumerate()
        .map(|(idx, line)| Command {
            line,
            name: names.get(idx).map(String::as_str),
        })
        .collect()
}

/// Automatic names for a bare `-n`: strip the prefix and suffix common to all
/// commands, keeping their distinctive middle. A command left empty (e.g. the
/// commands are identical) falls back to its full command line.
pub fn auto_names(commands: &[String]) -> Vec<String> {
    let chars: Vec<Vec<char>> = commands.iter().map(|c| c.chars().collect()).collect();
    let prefix = chars[1..].iter().fold(chars[0].len(), |len, c| {
        chars[0][..len]
            .iter()
            .zip(c)
            .take_while(|(a, b)| a == b)
            .count()
    });
    // The suffix is matched on the prefix-stripped remainders, so the two
    // strips cannot overlap.
    let rests: Vec<&[char]> = chars.iter().map(|c| &c[prefix..]).collect();
    let suffix = rests[1..].iter().fold(rests[0].len(), |len, c| {
        rests[0][rests[0].len() - len..]
            .iter()
            .rev()
            .zip(c.iter().rev())
            .take_while(|(a, b)| a == b)
            .count()
    });
    rests
        .iter()
        .zip(commands)
        .map(|(rest, cmd)| {
            let name: String = rest[..rest.len() - suffix].iter().collect();
            let name = name.trim();
            if name.is_empty() {
                cmd.clone()
            } else {
                name.to_string()
            }
        })
        .collect()
}

/// Read commands from stdin, one (non-blank) per line, for the `-` positional.
pub fn from_stdin() -> Result<Vec<String>> {
    let mut input = String::new();
    std::io::stdin()
        .read_to_string(&mut input)
        .context("failed to read commands from stdin")?;
    let commands: Vec<String> = input
        .lines()
        .map(str::trim)
        .filter(|line| !line.is_empty())
        .map(String::from)
        .collect();
    if commands.is_empty() {
        bail!("no commands read from stdin");
    }
    Ok(commands)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn names(cmds: &[&str]) -> Vec<String> {
        let cmds: Vec<String> = cmds.iter().map(|s| s.to_string()).collect();
        auto_names(&cmds)
    }

    #[test]
    fn auto_names_strip_common_prefix_and_suffix() {
        assert_eq!(
            names(&["sort --merge f", "sort --quick f"]),
            ["merge", "quick"]
        );
        assert_eq!(names(&["echo 1", "echo 2", "echo 3"]), ["1", "2", "3"]);
    }

    #[test]
    fn auto_names_fall_back_to_the_command() {
        // A single command (or identical ones) is entirely common.
        assert_eq!(names(&["echo hi"]), ["echo hi"]);
        assert_eq!(names(&["a", "a"]), ["a", "a"]);
    }

    #[test]
    fn auto_names_prefix_and_suffix_never_overlap() {
        // The prefix "a" consumes all of "a"; the suffix must not re-consume it.
        assert_eq!(names(&["aa", "a"]), ["a", "a"]);
    }
}