asimov-snapshot-cli 25.0.0-dev.1

ASIMOV Snapshot Command-Line Interface (CLI)
Documentation 
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

// This is free and unencumbered software released into the public domain.

use jiff::{Unit, Zoned};

#[tracing::instrument]
pub fn format_ts_diff(a: &Zoned, b: &Zoned) -> Result<String, jiff::Error> {
    let span = a - b;

    tracing::trace!(?span);

    let years = span.total((Unit::Year, a))?.floor() as i64;
    tracing::trace!(?years);
    if years >= 2 {
        return Ok(format!("{years} years ago"));
    }
    if years == 1 {
        return Ok("one year ago".into());
    }

    let months = span.total((Unit::Month, a))?.floor() as i64;
    tracing::trace!(?months);
    if months >= 2 {
        return Ok(format!("{months} months ago"));
    }
    if months == 1 {
        return Ok("one month ago".into());
    }

    let weeks = span.total((Unit::Week, a))?.floor() as i64;
    tracing::trace!(?weeks);
    if weeks >= 2 {
        return Ok(format!("{weeks} weeks ago"));
    }
    if weeks == 1 {
        return Ok("one week ago".into());
    }

    let days = span.total((Unit::Day, a))?.floor() as i64;
    tracing::trace!(?days);
    if days >= 2 {
        return Ok(format!("{days} days ago"));
    }
    if days == 1 {
        return Ok("one day ago".into());
    }

    let hours = span.total((Unit::Hour, a))?.floor() as i64;
    tracing::trace!(?hours);
    if hours >= 2 {
        return Ok(format!("{hours} hours ago"));
    }
    if hours == 1 {
        return Ok("one hour ago".into());
    }

    let minutes = span.total((Unit::Minute, a))?.floor() as i64;
    tracing::trace!(?minutes);
    if minutes >= 2 {
        return Ok(format!("{minutes} minutes ago"));
    }
    if minutes == 1 {
        return Ok("one minute ago".into());
    }

    Ok("just now".into())
}

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

    #[test]
    fn test_format_ts_diff() {
        tracing_subscriber::fmt::init();

        let now = jiff::Zoned::now();

        // There is a decent chance that the days>=1 tests are flaky.
        // Could try adding extra buffer if something starts failing.
        let cases = [
            (3.years(), "3 years ago"),
            (1.year(), "one year ago"),
            (9.months().weeks(2), "9 months ago"),
            (6.weeks(), "one month ago"),
            (3.weeks(), "3 weeks ago"),
            (2.weeks().days(3), "2 weeks ago"),
            (1.week(), "one week ago"),
            (6.days(), "6 days ago"),
            (1.day(), "one day ago"),
            (10.hours(), "10 hours ago"),
            (1.hour(), "one hour ago"),
            (30.minutes(), "30 minutes ago"),
            (1.minute(), "one minute ago"),
            (59.seconds(), "just now"),
            (1.seconds(), "just now"),
        ];

        for case in cases {
            let then = &now - case.0;
            assert_eq!(
                format_ts_diff(&now, &then).unwrap(),
                case.1,
                "input: {}",
                case.0
            );
        }
    }
}