geam-cli 0.2.1

Standalone command implementation for Geam
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

use crate::error::CliError;
use std::ffi::OsStr;
use std::process::{Command, Output};

pub(super) fn run_checked(command: &mut Command) -> Result<Output, CliError> {
    let display = display_command(command);
    let output = command.output().map_err(|error| CliError::ProcessIo {
        command: display.clone(),
        error,
    })?;
    if output.status.success() {
        Ok(output)
    } else {
        Err(CliError::ProcessFailure {
            command: display,
            status: output.status.code(),
            stderr: String::from_utf8_lossy(&output.stderr).trim().to_owned(),
        })
    }
}

pub(super) fn run_inherited(command: &mut Command) -> Result<(), CliError> {
    let display = display_command(command);
    let status = command.status().map_err(|error| CliError::ProcessIo {
        command: display.clone(),
        error,
    })?;
    if status.success() {
        Ok(())
    } else {
        Err(CliError::InheritedProcessFailure {
            command: display,
            status: status.code(),
        })
    }
}

fn display_command(command: &Command) -> String {
    std::iter::once(command.get_program())
        .chain(command.get_args())
        .map(OsStr::to_string_lossy)
        .collect::<Vec<_>>()
        .join(" ")
}

#[cfg(test)]
mod tests {
    use super::{run_checked, run_inherited};
    use crate::error::CliError;
    use std::process::{Command, Stdio};

    #[test]
    fn returns_successful_process_output() {
        let output = run_checked(Command::new("rustc").arg("--version"))
            .expect("rustc version should succeed");

        assert!(String::from_utf8_lossy(&output.stdout).starts_with("rustc "));
    }

    #[test]
    fn preserves_failed_process_status_and_stderr() {
        let error = run_checked(Command::new("rustc").arg("--definitely-not-a-rustc-option"))
            .expect_err("invalid rustc option should fail");

        assert!(matches!(
            error,
            CliError::ProcessFailure { command, status: Some(1), stderr }
                if command == "rustc --definitely-not-a-rustc-option"
                    && stderr.contains("Unrecognized option")
        ));
    }

    #[test]
    fn preserves_process_start_failures() {
        let mut command = Command::new("geam-command-that-does-not-exist");
        let error = run_checked(&mut command).expect_err("missing process should fail");

        assert!(matches!(
            error,
            CliError::ProcessIo { command, error }
                if command == "geam-command-that-does-not-exist"
                    && error.kind() == std::io::ErrorKind::NotFound
        ));
    }

    #[test]
    fn runs_with_inherited_streams_and_preserves_status_failures() {
        run_inherited(
            Command::new("rustc")
                .arg("--version")
                .stdout(Stdio::null())
                .stderr(Stdio::null()),
        )
        .expect("inherited process should succeed");

        let error = run_inherited(
            Command::new("rustc")
                .arg("--definitely-not-a-rustc-option")
                .stdout(Stdio::null())
                .stderr(Stdio::null()),
        )
        .expect_err("inherited process status should be preserved");
        assert!(matches!(
            error,
            CliError::InheritedProcessFailure { command, status: Some(1) }
                if command == "rustc --definitely-not-a-rustc-option"
        ));

        let error = run_inherited(&mut Command::new("geam-command-that-does-not-exist"))
            .expect_err("missing inherited process should fail to start");
        assert!(matches!(
            error,
            CliError::ProcessIo { command, error }
                if command == "geam-command-that-does-not-exist"
                    && error.kind() == std::io::ErrorKind::NotFound
        ));
    }
}