diva 0.1.0

Opinionated convenience wrappers for `std::process::Command` and friends.
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

use crate::{ChildStderr, ChildStdin, ChildStdout, Error, ExitStatus, Output};
use std::{io, process};

#[derive(Debug)]
struct Inner {
    command: String,
    inner: process::Child,
}

/// A handle to a child process. You **must** call either [`Handle::wait`] or
/// [`Handle::wait_for_output`] to consume the handle. If you don't, it'll get
/// mad at you.
#[derive(Debug)]
#[must_use = "handles must be `wait`ed on, or they won't stop"]
pub struct Handle {
    inner: Option<Inner>,
}

impl Drop for Handle {
    fn drop(&mut self) {
        if let Some(inner) = self.inner.as_ref() {
            log::error!(
                "handle for command {:?} dropped without being waited on",
                inner.command
            );
        }
    }
}

impl Handle {
    pub(crate) fn new(command: String, inner: process::Child) -> Self {
        Self {
            inner: Some(Inner { command, inner }),
        }
    }

    fn expect<T>(opt: Option<T>) -> T {
        opt.expect("developer error: `Handle` vacant")
    }

    fn as_mut(&mut self) -> &mut Inner {
        Self::expect(self.inner.as_mut())
    }

    fn take(mut self) -> Inner {
        Self::expect(self.inner.take())
    }

    pub fn stdin(&mut self) -> Option<&mut ChildStdin> {
        self.as_mut().inner.stdin.as_mut()
    }

    pub fn stdout(&mut self) -> Option<&mut ChildStdout> {
        self.as_mut().inner.stdout.as_mut()
    }

    pub fn stderr(&mut self) -> Option<&mut ChildStderr> {
        self.as_mut().inner.stderr.as_mut()
    }

    pub fn kill(&mut self) -> io::Result<()> {
        self.as_mut().inner.kill()
    }

    pub fn wait(self) -> crate::Result<ExitStatus> {
        let Inner { command, mut inner } = self.take();
        Error::from_status_result(command, inner.wait())
    }

    pub fn wait_for_output(self) -> crate::Result<Output> {
        let Inner { command, inner } = self.take();
        Error::from_output_result(command, inner.wait_with_output())
    }

    pub fn leak(self) {
        self.take();
    }
}