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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
#![warn(clippy::pedantic)]
#![warn(clippy::nursery)]
#![allow(clippy::missing_const_for_fn)]
#![allow(clippy::struct_excessive_bools)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::too_many_lines)]
#![allow(clippy::unused_self)]
mod builtins;
mod env;
mod event;
mod format;
mod history;
mod parse;
mod readline;
mod state;
mod util;
use async_std::stream::StreamExt as _;
// the time crate is currently unable to get the local offset on unix due to
// soundness concerns, so we have to do it manually/:
//
// https://github.com/time-rs/time/issues/380
fn get_offset() -> time::UtcOffset {
let offset_str =
std::process::Command::new("date").args(&["+%:z"]).output();
if let Ok(offset_str) = offset_str {
let offset_str = String::from_utf8(offset_str.stdout).unwrap();
time::UtcOffset::parse(
offset_str.trim(),
&time::format_description::parse("[offset_hour]:[offset_minute]")
.unwrap(),
)
.unwrap_or(time::UtcOffset::UTC)
} else {
time::UtcOffset::UTC
}
}
async fn resize(event_w: &async_std::channel::Sender<crate::event::Event>) {
let size = terminal_size::terminal_size().map_or(
(24, 80),
|(terminal_size::Width(w), terminal_size::Height(h))| (h, w),
);
event_w
.send(crate::event::Event::Resize(size))
.await
.unwrap();
}
async fn async_main() -> anyhow::Result<()> {
let mut input = textmode::Input::new().await?;
let mut output = textmode::Output::new().await?;
// avoid the guards getting stuck in a task that doesn't run to
// completion
let _input_guard = input.take_raw_guard();
let _output_guard = output.take_screen_guard();
let (event_w, event_r) = async_std::channel::unbounded();
let mut state = state::State::new(get_offset());
state.render(&mut output, true).await.unwrap();
{
let mut signals = signal_hook_async_std::Signals::new(&[
signal_hook::consts::signal::SIGWINCH,
])?;
let event_w = event_w.clone();
async_std::task::spawn(async move {
while signals.next().await.is_some() {
resize(&event_w).await;
}
});
}
resize(&event_w).await;
{
let event_w = event_w.clone();
async_std::task::spawn(async move {
while let Some(key) = input.read_key().await.unwrap() {
event_w.send(event::Event::Key(key)).await.unwrap();
}
});
}
// redraw the clock every second
{
let event_w = event_w.clone();
async_std::task::spawn(async move {
let first_sleep = 1_000_000_000_u64.saturating_sub(
time::OffsetDateTime::now_utc().nanosecond().into(),
);
async_std::task::sleep(std::time::Duration::from_nanos(
first_sleep,
))
.await;
let mut interval = async_std::stream::interval(
std::time::Duration::from_secs(1),
);
event_w.send(crate::event::Event::ClockTimer).await.unwrap();
while interval.next().await.is_some() {
event_w.send(crate::event::Event::ClockTimer).await.unwrap();
}
});
}
let event_reader = event::Reader::new(event_r);
while let Some(event) = event_reader.recv().await {
state.handle_event(event, &mut output, &event_w).await;
}
Ok(())
}
fn main() {
match async_std::task::block_on(async_main()) {
Ok(_) => (),
Err(e) => {
eprintln!("nbsh: {}", e);
std::process::exit(1);
}
};
}
|
