shelly-shell 0.3.1

A Rust based Unix style shell with a typed and structured language syntax.
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


use std::{ fs::File,
           io::{ self, Error, ErrorKind, PipeWriter, Read, copy, pipe },
           process::{ Command, Stdio },
           rc::Rc,
           thread::{ Builder, JoinHandle } };

use crate::language::text::location::Location;


pub(super) enum Output
{
    File(File),
    Pipe(PipeWriter)
}


impl Output
{
    fn stdio(&self) -> io::Result<Stdio>
    {
        match self
        {
            Self::File(file) => Ok(file.try_clone()?.into()),
            Self::Pipe(writer) => Ok(writer.try_clone()?.into()),
        }
    }

    pub fn copy_from(&self, input: &mut impl Read) -> io::Result<u64>
    {
        match self
        {
            Self::File(file) => copy(input, &mut &*file),
            Self::Pipe(writer) => copy(input, &mut &*writer),
        }
    }
}


pub(super) struct Redirection
{
    pub location: Location,
    pub output: Option<Rc<Output>>,
    pub error: Option<Rc<Output>>,
    capture: Option<(String, JoinHandle<io::Result<Vec<u8>>>)>,
}


impl Redirection
{
    pub fn new(location: Location) -> Self
    {
        Self { location, output: None, error: None, capture: None }
    }

    pub fn capture(&mut self, name: String) -> io::Result<Rc<Output>>
    {
        let (mut reader, writer) = pipe()?;
        let worker = Builder::new().name("shelly-output".to_string()).spawn(move ||
            {
                let mut bytes = Vec::new();
                reader.read_to_end(&mut bytes)?;
                Ok(bytes)
            })?;
        self.capture = Some((name, worker));
        Ok(Rc::new(Output::Pipe(writer)))
    }

    pub fn finish(self) -> io::Result<Option<(String, String)>>
    {
        let Self { output, error, capture, .. } = self;
        // Close all shell-owned write ends before joining the capture worker.
        drop((output, error));
        capture.map(|(name, worker)|
            {
                let bytes = worker.join()
                    .map_err(|_| Error::other("Capture worker panicked"))??;
                let text = String::from_utf8(bytes)
                    .map_err(|error| Error::new(ErrorKind::InvalidData, error))?;
                Ok((name, text))
            }).transpose()
    }
}


pub(super) fn configure(command: &mut Command, redirects: &[Redirection]) -> io::Result<bool>
{
    let output = redirects.iter().rev().find_map(|redirect| redirect.output.as_ref());
    if let Some(output) = output { command.stdout(output.stdio()?); }
    if let Some(error) = redirects.iter().rev().find_map(|redirect| redirect.error.as_ref())
    { command.stderr(error.stdio()?); }
    Ok(output.is_some())
}