cargo-delta 0.4.0

Detects which crates in a Cargo workspace are affected by changes in a Git feature branch.
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

#![doc(hidden)]

//! A cargo tool to detect impacted packages from git changes.

use cargo_delta_lib::Host;
use std::ffi::{OsStr, OsString};
use std::fs;
use std::io::{self, Write, stderr, stdout};
use std::path::{Path, PathBuf};
use std::process::{Command, Output};

/// Default host that runs real OS commands.
#[derive(Debug, Clone, Default)]
pub struct RealHost;

impl Host for RealHost {
    fn error(&mut self) -> impl Write {
        stderr()
    }

    fn write_output(&mut self, path: Option<&Path>, contents: &[u8]) -> io::Result<()> {
        let Some(path) = path else {
            return stdout().write_all(contents);
        };
        let path = if path.is_absolute() {
            path.to_path_buf()
        } else {
            self.current_dir()?.join(path)
        };
        if let Some(parent) = path.parent() {
            fs::create_dir_all(parent)?;
        }
        fs::write(path, contents)
    }

    fn exit(&mut self, code: i32) {
        std::process::exit(code);
    }

    fn current_dir(&self) -> io::Result<PathBuf> {
        std::env::current_dir()
    }

    fn env_var_os(&self, key: &str) -> Option<OsString> {
        std::env::var_os(key)
    }

    fn run_command(&mut self, command: impl AsRef<OsStr>, args: &[&str], working_dir: Option<&Path>) -> io::Result<Output> {
        let mut cmd = Command::new(command);
        let _ = cmd.args(args);
        if let Some(dir) = working_dir {
            let _ = cmd.current_dir(dir);
        }
        cmd.output()
    }
}

fn main() {
    cargo_delta_lib::run(&mut RealHost, std::env::args());
}

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

    #[test]
    fn real_host_reports_process_context() {
        let host = RealHost;
        assert_eq!(host.current_dir().unwrap(), std::env::current_dir().unwrap());
        assert_eq!(host.env_var_os("PATH"), std::env::var_os("PATH"));
    }

    #[test]
    fn real_host_writes_output_file() {
        let root = std::env::temp_dir().join(format!("cargo-delta-real-host-output-{}", std::process::id()));
        let path = root.join("nested/output.txt");
        let mut host = RealHost;

        host.write_output(Some(&path), b"output").unwrap();

        assert_eq!(fs::read_to_string(path).unwrap(), "output");
        fs::remove_dir_all(root).unwrap();
    }
}