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
|
#![deny(clippy::all, clippy::cargo, clippy::nursery, clippy::pedantic)]
#![allow(
clippy::cargo_common_metadata,
clippy::multiple_crate_versions,
clippy::wildcard_dependencies
)]
mod argparse;
mod displace;
mod fs_pipe;
mod fzf;
mod input;
mod output;
mod subprocess;
mod types;
mod udiff;
mod udiff_spec;
use {
ansi_term::Colour,
argparse::{parse_args, parse_opts},
displace::displace,
futures::{
sink::Sink,
stream::{BoxStream, StreamExt, TryStreamExt},
},
input::stream_in,
output::stream_sink,
std::{
convert::Into,
ffi::OsString,
process::{ExitCode, Termination},
sync::Arc,
thread::available_parallelism,
},
tokio::runtime::Builder,
types::{Abort, Fail},
};
async fn run(threads: usize) -> Result<(), Fail> {
let (mode, args) = parse_args();
let input_stream = stream_in(&mode, &args).await;
let opts = parse_opts(mode, args)?;
let options = Arc::new(opts);
let opts = options.clone();
let trans_stream = BoxStream::from(input_stream)
.map_ok(move |input| {
let opts = options.clone();
async move { displace(&opts, input).await }
})
.try_buffer_unordered(threads);
let sink = stream_sink(&opts, trans_stream);
Ok(())
}
fn main() -> impl Termination {
let threads = available_parallelism().map(Into::into).unwrap_or(6);
let rt = Builder::new_multi_thread()
.enable_io()
.max_blocking_threads(threads)
.build()
.expect("runtime failure");
let errors = rt.block_on(async {
let abort = Abort::new();
if let Err(err) = run(threads).await {
let mut errs = abort.fin().await;
errs.push(err);
errs
} else {
abort.fin().await
}
});
match errors[..] {
[] => ExitCode::SUCCESS,
[Fail::Interrupt] => ExitCode::from(130),
_ => {
for err in errors {
eprintln!("{}", Colour::Red.paint(format!("{err}")));
}
ExitCode::FAILURE
}
}
}
|
