use std::borrow::Cow;
use std::error::Error;
use std::fmt;
use std::time::Duration;
use serde::{Deserialize, Deserializer, Serializer};
const SECS_PER_MINUTE: u64 = 60;
const SECS_PER_HOUR: u64 = 60 * SECS_PER_MINUTE;
const SECS_PER_DAY: u64 = 24 * SECS_PER_HOUR;
pub fn format_duration(duration: Duration) -> FormattedDuration {
FormattedDuration(duration)
}
pub fn parse_duration(input: &str) -> Result<Duration, ParseDurationError> {
humantime::parse_duration(input).map_err(ParseDurationError)
}
pub fn serialize<S: Serializer>(duration: &Duration, serializer: S) -> Result<S::Ok, S::Error> {
serializer.collect_str(&format_duration(*duration))
}
pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Duration, D::Error> {
#[derive(Deserialize)]
#[serde(transparent)]
struct BorrowedStr<'a>(#[serde(borrow)] Cow<'a, str>);
let BorrowedStr(value) = BorrowedStr::deserialize(deserializer)?;
parse_duration(&value).map_err(serde::de::Error::custom)
}
#[derive(Debug)]
pub struct ParseDurationError(humantime::DurationError);
impl fmt::Display for ParseDurationError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
impl Error for ParseDurationError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FormattedDuration(Duration);
impl fmt::Display for FormattedDuration {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let secs = self.0.as_secs();
if secs == 0 {
return f.write_str("0s");
}
let components = [
(secs / SECS_PER_DAY, "d"),
(secs % SECS_PER_DAY / SECS_PER_HOUR, "h"),
(secs % SECS_PER_HOUR / SECS_PER_MINUTE, "m"),
(secs % SECS_PER_MINUTE, "s"),
];
let mut separator = "";
for (value, unit) in components {
if value > 0 {
write!(f, "{separator}{value}{unit}")?;
separator = " ";
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn format(duration: Duration) -> String {
format_duration(duration).to_string()
}
#[test]
fn formats_units() {
assert_eq!(format(Duration::ZERO), "0s");
assert_eq!(format(Duration::from_secs(30)), "30s");
assert_eq!(format(Duration::from_secs(60)), "1m");
assert_eq!(format(Duration::from_secs(3600)), "1h");
assert_eq!(format(Duration::from_secs(86400)), "1d");
}
#[test]
fn formats_combined_units_and_skips_zeroes() {
let duration = Duration::from_secs(2 * 86400 + 3 * 3600 + 4);
assert_eq!(format(duration), "2d 3h 4s");
}
#[test]
fn keeps_long_durations_in_days() {
assert_eq!(format(Duration::from_secs(7 * 86400)), "7d");
assert_eq!(format(Duration::from_secs(400 * 86400)), "400d");
}
#[test]
fn truncates_sub_second_remainder() {
assert_eq!(format(Duration::from_millis(1500)), "1s");
assert_eq!(format(Duration::from_millis(500)), "0s");
}
#[test]
fn round_trips_through_parse() {
for secs in [0, 1, 59, 60, 3661, 86400, 396 * 86400 + 62208] {
let duration = Duration::from_secs(secs);
let formatted = format(duration);
assert_eq!(parse_duration(&formatted).unwrap(), duration, "{formatted}");
}
}
#[test]
fn parses_units_that_are_never_emitted() {
assert_eq!(
parse_duration("2weeks").unwrap(),
Duration::from_secs(1_209_600)
);
assert_eq!(
parse_duration("1year").unwrap(),
Duration::from_secs(31_557_600)
);
}
}