Repository: typst/typst
File: crates/typst-utils/src/format.rs (Rust)

Code before:

/// Format string starting with number of milliseconds and going bigger from there.
/// `precision` is how many digits of microseconds from left will be preserved.
/// Note that this function will always remove all trailing zeros for microseconds.
fn time_starting_with_ms_with_precision(duration: &Duration, precision: usize) -> String {
    let digits = precision;
    let (d, h, m, s, ms, mcs) = get_duration_parts(duration);
    let mcs_digits = {
        let mut mcs = mcs;
        println!("before {mcs}");
        while mcs % 10 == 0 && mcs != 0 {
            mcs /= 10
        }
        println!("after {mcs}");
        mcs.to_string().len()
    };
    let ms = format!(
        "{1:.0$} ms",
        if mcs != 0 { min(digits, mcs_digits) } else { 0 },
        ms as f32 + mcs as f32 / 1000.0
    );
    match (d, h, m, s) {
        (0, 0, 0, 0) => ms.to_string(),
        (d, h, m, s) => format_dhms(d, h, m, s),
    }
}

fn time_as_ms(duration: &Duration) -> String {
    time_starting_with_ms_with_precision(duration, 2)
}

pub fn elapsed_time(duration: &Duration) -> String {
    time_starting_with_seconds(duration)
}

pub fn eta_time(duration: &Duration) -> String {
    time_starting_with_seconds(duration)
}

pub fn compilation_time(duration: &Duration) -> String {
    time_as_ms(duration)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn duration_milli_micro(milliseconds: u16, microseconds: u16) -> Duration {
        let microseconds = microseconds as u64;
        let milliseconds = 1000 * milliseconds as u64;
        Duration::from_micros(milliseconds + microseconds)

Review comment (bug):
Something like this seems better - see [Playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=afa07ceb3c758d96956cb9e8724c744a):

(note: there's more text below the suggestion)

```suggestion
/// Format string starting with number of milliseconds and going bigger from there.
/// `precision` is how many digits of microseconds from left will be preserved.
/// Note that this function will always remove all trailing zeros for microseconds.
fn time_starting_with_ms_with_precision(duration: &Duration, precision: u16) -> String {
    let (d, h, m, s, ms, mcs) = get_duration_parts(duration);
    match (d, h, m, s) {
        (0, 0, 0, 0) => {
            let ms = ms as f64 + mcs as f64 / 1000.0;
            let ms = (ms * 10.0_f64.powi(precision as i32)).round() / 10.0_f64.powi(precision as i32);
            format!("{ms} ms")
        }
        (d, h, m, s) => format_dhms(d, h, m, s),
    }
}
```

Although it may be a good idea to extract the 10^precision shenanigans into a separate `typst-utils` function, as this is also used for `repr`:

https://github.com/typst/typst/blob/d84a7e423b53e9b5740720270b132da60c8a3fea/crates/typst/src/foundations/repr.rs#L86-L89

Code after:
        || value.abs() >= (1_i64 << f64::MANTISSA_DIGITS) as f64
        || precision as u32 >= f64::DIGITS
    {
        return value;
    }
    let offset = 10_f64.powi(precision.into());
    assert!((value * offset).is_finite(), "{value} * {offset} is not finite!");
    (value * offset).round() / offset
}

/// Returns `(days, hours, minutes, seconds, milliseconds, microseconds)`.
fn get_duration_parts(duration: &Duration) -> (u64, u8, u8, u8, u16, u16) {
    // In practice we probably don't need nanoseconds.
    let micros = duration.as_micros();
    let (millis, micros) = (micros / 1000, (micros % 1000) as u16);
    let (sec, millis) = (millis / 1000, (millis % 1000) as u16);
    let (mins, sec) = (sec / 60, (sec % 60) as u8);
    let (hours, mins) = (mins / 60, (mins % 60) as u8);
    let (days, hours) = ((hours / 24) as u64, (hours % 24) as u8);
    (days, hours, mins, sec, millis, micros)
}

/// Format string using `days`, `hours`, `minutes`, `seconds`.
fn format_dhms(days: u64, hours: u8, minutes: u8, seconds: u8) -> String {
    match (days, hours, minutes, seconds) {
        (0, 0, 0, s) => format!("{s:2} s"),
        (0, 0, m, s) => format!("{m:2} m {s:2} s"),
        (0, h, m, s) => format!("{h:2} h {m:2} m {s:2} s"),
        (d, h, m, s) => format!("{d:3} d {h:2} h {m:2} m {s:2} s"),
    }
}

/// Format string starting with number of seconds and going bigger from there.
///
/// # Examples
///
/// ```
/// # use std::time::Duration;
/// # use typst_utils::format::time_starting_with_seconds;
/// let duration1 = time_starting_with_seconds(&Duration::from_secs(0));
/// assert_eq!(" 0 s", &duration1);
///
/// let duration2 = time_starting_with_seconds(&Duration::from_secs(
///     24 * 60 * 60 * 100 + // days
///     60 * 60 * 10 + // hours
///     60 * 10 + // minutes
///     10 // seconds
/// ));
/// assert_eq!("100 d 10 h 10 m 10 s", &duration2);
/// ```
pub fn time_starting_with_seconds(duration: &Duration) -> String {