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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
// will uncomment this once it is closer to release
// #![warn(clippy::cargo)]
#![warn(clippy::pedantic)]
#![warn(clippy::nursery)]
#![warn(clippy::as_conversions)]
#![warn(clippy::get_unwrap)]
#![allow(clippy::cognitive_complexity)]
#![allow(clippy::missing_const_for_fn)]
#![allow(clippy::similar_names)]
#![allow(clippy::struct_excessive_bools)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::too_many_lines)]
#![allow(clippy::type_complexity)]
mod builtins;
mod command;
mod env;
mod event;
mod format;
mod parse;
mod state;
use async_std::stream::StreamExt as _;
use textmode::Textmode 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 async_main() -> anyhow::Result<i32> {
if std::env::args().nth(1).as_deref() == Some("--internal-cmd-runner") {
return command::run().await;
}
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 signals = signal_hook_async_std::Signals::new(&[
signal_hook::consts::signal::SIGWINCH,
])?;
let event_w = event_w.clone();
async_std::task::spawn(async move {
let mut signals = async_std::stream::once(
signal_hook::consts::signal::SIGWINCH,
)
.chain(signals);
while signals.next().await.is_some() {
event_w
.send(crate::event::Event::Resize(
terminal_size::terminal_size().map_or(
(24, 80),
|(
terminal_size::Width(w),
terminal_size::Height(h),
)| { (h, w) },
),
))
.await
.unwrap();
}
});
}
{
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 mut state = state::State::new(get_offset());
let event_reader = event::Reader::new(event_r);
while let Some(event) = event_reader.recv().await {
match state.handle_event(event, &event_w).await {
Some(state::Action::Refresh) => {
state.render(&mut output).await?;
output.refresh().await?;
}
Some(state::Action::HardRefresh) => {
state.render(&mut output).await?;
output.hard_refresh().await?;
}
Some(state::Action::Resize(rows, cols)) => {
output.set_size(rows, cols);
state.render(&mut output).await?;
output.hard_refresh().await?;
}
Some(state::Action::Quit) => break,
None => {}
}
}
Ok(0)
}
fn main() {
match async_std::task::block_on(async_main()) {
Ok(code) => {
std::process::exit(code);
}
Err(e) => {
eprintln!("nbsh: {}", e);
std::process::exit(1);
}
};
}
|
