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
|
use futures::future::{Future as _, IntoFuture as _};
use futures::sink::Sink 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: crate::state::Error },
#[snafu(display("error during sending: {}", source))]
Sending {
source: futures::sync::mpsc::SendError<crate::state::StateEvent>,
},
#[snafu(display("error during receiving: {}", source))]
Receiving {
source: futures::sync::oneshot::Canceled,
},
}
pub fn tui() {
tokio::run(futures::lazy(|| {
let (w, r) = futures::sync::mpsc::channel(0);
tokio::spawn(crate::state::State::new(r).map_err(|e| {
error(&Error::Print { source: e });
}));
futures::future::loop_fn(0, move |idx| {
let w = w.clone();
read()
.and_then(move |line| {
let (res, req) = futures::sync::oneshot::channel();
w.send(crate::state::StateEvent::Line(idx, line, res))
.map_err(|e| Error::Sending { source: e })
.and_then(|_| {
req.map_err(|e| Error::Receiving { source: e })
})
})
.then(move |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(futures::future::Loop::Continue(idx + 1)),
// eof means we're done
Err(Error::Read {
source: crate::readline::Error::EOF,
}) => Ok(futures::future::Loop::Break(())),
// any other errors should be displayed, then we
// prompt again
Err(e) => {
error(&e);
Ok(futures::future::Loop::Continue(idx + 1))
}
})
})
}));
}
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 error(e: &Error) {
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();
}
|
