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
|
use futures::future::{Future as _, IntoFuture as _};
use futures::stream::Stream as _;
use snafu::ResultExt as _;
use std::io::Write as _;
#[derive(Debug, snafu::Snafu)]
pub enum Error {
#[snafu(display("error during read: {}", source))]
Read { source: crate::readline::Error },
#[snafu(display("error during eval: {}", source))]
Eval { source: crate::eval::Error },
#[snafu(display("error during print: {}", source))]
Print { source: std::io::Error },
}
pub type Result<T> = std::result::Result<T, Error>;
pub fn repl() {
let loop_stream = futures::stream::unfold(false, |done| {
if done {
return None;
}
let repl = read()
.and_then(|line| {
eval(&line).for_each(|event| {
futures::future::FutureResult::from(print(&event))
})
})
.then(|res| match res {
// successful run or empty input means prompt again
Ok(_)
| Err(Error::Eval {
source:
crate::eval::Error::Parser {
source: crate::parser::Error::CommandRequired,
..
},
}) => Ok((false, false)),
// eof means we're done
Err(Error::Read {
source: crate::readline::Error::EOF,
}) => Ok((false, true)),
// any other errors should be displayed, then we prompt again
Err(e) => {
let stderr = std::io::stderr();
let mut stderr = stderr.lock();
// panics seem fine for errors during error handling
write!(stderr, "{}\r\n", e).unwrap();
stderr.flush().unwrap();
Ok((false, false))
}
});
Some(repl)
});
let loop_future = loop_stream.collect().map(|_| ());
tokio::run(loop_future);
}
fn read() -> impl futures::future::Future<Item = String, Error = Error> {
crate::readline::readline("$ ", true)
.into_future()
.flatten()
.map_err(|e| Error::Read { source: e })
}
fn eval(
line: &str,
) -> impl futures::stream::Stream<Item = crate::eval::CommandEvent, Error = Error>
{
crate::eval::eval(line)
.into_future()
.flatten_stream()
.map_err(|e| Error::Eval { source: e })
}
fn print(event: &crate::eval::CommandEvent) -> Result<()> {
match event {
crate::eval::CommandEvent::CommandStart(cmd, args) => {
eprint!("running '{} {:?}'\r\n", cmd, args);
}
crate::eval::CommandEvent::Output(out) => {
let stdout = std::io::stdout();
let mut stdout = stdout.lock();
stdout.write(out).context(Print)?;
stdout.flush().context(Print)?;
}
crate::eval::CommandEvent::CommandExit(status) => {
eprint!("command exited: {}\r\n", status);
}
}
Ok(())
}
|
