shelle 0.1.1

Macros for writing shell scripts in Rust.
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

use std::io;
use std::path::PathBuf;

#[derive(Default)]
pub struct Redirects {
    pub stdin: Option<Stdin>,
    pub stdout: Option<Stdout>,
    pub stderr: Option<Stderr>,
}

pub enum Stdin {
    FromFile { path: PathBuf },
    FromPipe(io::PipeReader),
}
pub enum Stdout {
    ToStderr,
    ToFile { path: PathBuf, append: bool },
    ToPipe(io::PipeWriter),
    ToString,
}
pub enum Stderr {
    ToStdout,
    ToFile { path: PathBuf, append: bool },
    ToPipe(io::PipeWriter),
    ToString,
}

use std::fmt;
impl fmt::Display for Redirects {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.stderr.is_some() || self.stdout.is_some() || self.stdin.is_some() {
            write!(f, " ")?;
        }

        if let Some(stderr) = &self.stderr {
            match stderr {
                Stderr::ToStdout => write!(f, "2>&1")?,
                Stderr::ToFile { path, append: false } => write!(f, "2>{:?}", path.display())?,
                Stderr::ToFile { path, append: true } => write!(f, "2>>{:?}", path.display())?,
                Stderr::ToPipe(_) => {}
                Stderr::ToString => {}
            }
            if self.stdout.is_some() || self.stdin.is_some() {
                write!(f, " ")?;
            }
        }

        if let Some(stdout) = &self.stdout {
            match stdout {
                Stdout::ToStderr => write!(f, ">&2")?,
                Stdout::ToFile { path, append: false } => write!(f, ">{:?}", path.display())?,
                Stdout::ToFile { path, append: true } => write!(f, ">>{:?}", path.display())?,
                Stdout::ToPipe(_) => {}
                Stdout::ToString => {}
            }
            if self.stdin.is_some() {
                write!(f, " ")?;
            }
        }

        if let Some(Stdin::FromFile { path }) = &self.stdin {
            write!(f, "<{:?}", path.display())?;
        }

        Ok(())
    }
}