252 lines
8.3 KiB
Rust
252 lines
8.3 KiB
Rust
pub const DOWNLOAD_STYLE: owo_colors::Style = owo_colors::Style::new().blue().bold();
|
|
pub const EXTRACT_STYLE: owo_colors::Style = owo_colors::Style::new().green().bold();
|
|
use std::{borrow::Cow, fmt::Display, rc::Rc};
|
|
|
|
use indicatif::HumanBytes;
|
|
use owo_colors::Style;
|
|
|
|
use crate::multibar::MultiBar;
|
|
|
|
pub enum StyledStringInner<'a> {
|
|
Cow(Cow<'a, str>),
|
|
Styled(Box<StyledString<'a>>),
|
|
}
|
|
|
|
impl<'a> From<Cow<'a, str>> for StyledStringInner<'a> {
|
|
fn from(value: Cow<'a, str>) -> Self {
|
|
StyledStringInner::Cow(value)
|
|
}
|
|
}
|
|
impl<'a> From<StyledString<'a>> for StyledStringInner<'a> {
|
|
fn from(value: StyledString<'a>) -> Self {
|
|
StyledStringInner::Styled(Box::new(value))
|
|
}
|
|
}
|
|
impl<'a> StyledStringInner<'a> {
|
|
pub fn len(&self) -> usize {
|
|
match self {
|
|
StyledStringInner::Cow(cow) => cow.len(),
|
|
StyledStringInner::Styled(styled) => styled.len(),
|
|
}
|
|
}
|
|
pub fn pad_to_width(self, width: usize) -> StyledStringInner<'a> {
|
|
let len = self.len();
|
|
if len == width {
|
|
self
|
|
} else if len > width {
|
|
match self {
|
|
StyledStringInner::Cow(cow) => StyledStringInner::Cow(Cow::Owned(
|
|
cow.chars()
|
|
.take(width.saturating_sub(2))
|
|
.collect::<String>()
|
|
+ "..",
|
|
)),
|
|
StyledStringInner::Styled(styled) => styled.pad_to_width(width).into(),
|
|
}
|
|
} else {
|
|
match self {
|
|
StyledStringInner::Cow(cow) => StyledStringInner::Cow(Cow::Owned(format!(
|
|
"{}{}",
|
|
cow,
|
|
" ".repeat(width - len)
|
|
))),
|
|
StyledStringInner::Styled(styled) => styled.pad_to_width(width).into(),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct StyledString<'a> {
|
|
inner: StyledStringInner<'a>,
|
|
style: Style,
|
|
}
|
|
|
|
impl<'a> StyledString<'a> {
|
|
pub fn new(inner: impl Into<StyledStringInner<'a>>, style: Style) -> Self {
|
|
Self {
|
|
inner: inner.into(),
|
|
style,
|
|
}
|
|
}
|
|
pub fn len(&self) -> usize {
|
|
self.inner.len()
|
|
}
|
|
pub fn pad_to_width(self, width: usize) -> StyledString<'a> {
|
|
if self.inner.len() == width {
|
|
self
|
|
} else {
|
|
StyledString {
|
|
inner: self.inner.pad_to_width(width),
|
|
style: self.style,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Display for StyledStringInner<'a> {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
StyledStringInner::Cow(cow) => write!(f, "{}", cow),
|
|
StyledStringInner::Styled(styled) => write!(f, "{}", styled),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Display for StyledString<'a> {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
write!(f, "{}", self.style.style(self.inner.to_string()))
|
|
}
|
|
}
|
|
|
|
// {prefix} {name} | {work_per_sec} | {download_done_human} | {extract_done_human} [bar]
|
|
//
|
|
//
|
|
const NAME_WIDTH_CUT: usize = 4;
|
|
const NAME_WIDTH_MIN: usize = 5;
|
|
const INFO_WIDTH: usize = 12;
|
|
|
|
pub fn style_bar<'s, const N: usize>(
|
|
prefix: StyledString,
|
|
name: StyledString,
|
|
work_per_sec: StyledString,
|
|
download_done: usize,
|
|
extract_done: usize,
|
|
bar: MultiBar<'s, N>,
|
|
|
|
width: u16,
|
|
) -> String {
|
|
let name = name.pad_to_width((width as usize / NAME_WIDTH_CUT).max(NAME_WIDTH_MIN));
|
|
let status = format!("{} {}", prefix, name);
|
|
let remaining_width = width.saturating_sub((name.len() + prefix.len()) as u16 + 6);
|
|
if remaining_width == 0 {
|
|
return status;
|
|
}
|
|
let possible_chunks = remaining_width.saturating_div(INFO_WIDTH as u16 + 3);
|
|
let possible_chunks = possible_chunks.min(3);
|
|
let leftover_width = remaining_width.saturating_sub(possible_chunks * (INFO_WIDTH as u16 + 3));
|
|
let download_done_human = StyledString::new(
|
|
Cow::Owned(HumanBytes(download_done as u64).to_string()),
|
|
DOWNLOAD_STYLE,
|
|
)
|
|
.pad_to_width(INFO_WIDTH);
|
|
let extract_done_human = StyledString::new(
|
|
Cow::Owned(HumanBytes(extract_done as u64).to_string()),
|
|
EXTRACT_STYLE,
|
|
)
|
|
.pad_to_width(INFO_WIDTH);
|
|
let work_per_sec = work_per_sec.pad_to_width(INFO_WIDTH);
|
|
let bar = bar.scale(leftover_width as u64).to_string();
|
|
|
|
match possible_chunks {
|
|
0 => format!("{status} | {download_done_human}"),
|
|
1 => format!("{status} | {download_done_human} | [{bar}]"),
|
|
2 => format!("{status} | {work_per_sec} | {download_done_human} | [{bar}]"),
|
|
_ => {
|
|
format!(
|
|
"{status} | {work_per_sec} | {download_done_human} | {extract_done_human} | [{bar}]"
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
// pub fn format(width: u16) {
|
|
// let name = pad_string(&name, (width / 4) as usize);
|
|
// let status = format!("Download {} |", name.purple().bold());
|
|
// let status_len = (width / 4) as usize + 10;
|
|
//
|
|
// if self.download_expected == 0 || self.extract_expected == 0 {
|
|
// self.bar.set_message(format!("{status}"));
|
|
// self.bar.tick();
|
|
// return;
|
|
// }
|
|
//
|
|
// let total_expected = self.download_expected + self.extract_expected;
|
|
// let total_done = self.download_done + self.extract_done;
|
|
//
|
|
// let dl_percent = ((self.download_done as f64 / self.download_expected as f64) * 100.0) as u64;
|
|
// let ex_percent = ((self.extract_done as f64 / self.extract_expected as f64) * 100.0) as u64;
|
|
//
|
|
// let download_per_sec =
|
|
// HumanBytes(self.download_estimator.steps_per_second(Instant::now()) as u64).to_string();
|
|
// let extract_per_sec =
|
|
// HumanBytes(self.extract_estimator.steps_per_second(Instant::now()) as u64).to_string();
|
|
// let download_done_human = HumanBytes(self.download_done).to_string();
|
|
// let download_done_human = pad_string(&download_done_human, INFO_WIDTH)
|
|
// .blue()
|
|
// .bold()
|
|
// .to_string();
|
|
// let extract_done_human = HumanBytes(self.extract_done).to_string();
|
|
// let extract_done_human = pad_string(&extract_done_human, INFO_WIDTH)
|
|
// .green()
|
|
// .bold()
|
|
// .to_string();
|
|
// let download_per_sec = pad_string(&format!("{download_per_sec}/s"), INFO_WIDTH)
|
|
// .blue()
|
|
// .bold()
|
|
// .to_string();
|
|
// let extract_per_sec = pad_string(&format!("{extract_per_sec}/s"), INFO_WIDTH)
|
|
// .green()
|
|
// .bold()
|
|
// .to_string();
|
|
// let work_per_sec = if self.download_done < self.download_expected {
|
|
// download_per_sec
|
|
// } else {
|
|
// extract_per_sec
|
|
// };
|
|
//
|
|
// let display = format!("{work_per_sec} | {download_done_human} | {extract_done_human} ");
|
|
// let display_length = (INFO_WIDTH * 3) + 9;
|
|
//
|
|
// // + 6 to account for final format
|
|
// let total_length = status_len + display_length + 4;
|
|
//
|
|
// let min = dl_percent.min(ex_percent);
|
|
// let dl = dl_percent.saturating_sub(min);
|
|
// let len = total_length as u16;
|
|
// // if width <= len {
|
|
// // self.bar.set_message(format!(
|
|
// // "{}: {}/{}",
|
|
// // name,
|
|
// // total_done,
|
|
// // if total_expected == 0 {
|
|
// // "-".to_string()
|
|
// // } else {
|
|
// // total_expected.to_string()
|
|
// // }
|
|
// // ));
|
|
// // self.bar.tick();
|
|
// // return;
|
|
// // }
|
|
// let msg = match width {
|
|
// 0..60 => {
|
|
// format!(
|
|
// "{}: {}/{}",
|
|
// name,
|
|
// total_done,
|
|
// if total_expected == 0 {
|
|
// "-".to_string()
|
|
// } else {
|
|
// total_expected.to_string()
|
|
// }
|
|
// )
|
|
// }
|
|
// _ => {
|
|
// let bar = MultiBar([
|
|
// BarSegment::Dynamic(&DONE_CHAR, min),
|
|
// BarSegment::Dynamic(&DOWNLOAD_CHAR, dl),
|
|
// BarSegment::Dynamic(" ", 100 - min - dl),
|
|
// ])
|
|
// .scale((width.saturating_sub(total_length as u16)) as u64);
|
|
// let bar = if width > display_length as u16 + status_len as u16 {
|
|
// format!("[{}]", bar)
|
|
// } else {
|
|
// String::new()
|
|
// };
|
|
//
|
|
// format!("{status} {display} {bar}",)
|
|
// }
|
|
// };
|
|
// self.bar.set_message(msg);
|
|
// self.bar.tick();
|
|
// }
|