orbital-history 0.1.1

Composable audit history timeline components for Orbital
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

//! Unread entry projection from a read watermark.

use chrono::{DateTime, Utc};

use crate::types::{HistoryEntry, HistoryListItem};

/// Returns true when the entry is unread relative to `watermark`.
pub fn is_entry_unread(entry: &HistoryEntry, watermark: DateTime<Utc>) -> bool {
    entry.changed_at > watermark
}

/// Insert an unread divider before the first unread entry in a projected list.
pub fn insert_unread_divider(
    items: Vec<HistoryListItem>,
    watermark: DateTime<Utc>,
    show_divider: bool,
) -> Vec<HistoryListItem> {
    if !show_divider {
        return items;
    }
    let mut out = Vec::with_capacity(items.len() + 1);
    let mut divider_inserted = false;
    for item in items {
        if !divider_inserted {
            if let HistoryListItem::Entry(entry) = &item {
                if is_entry_unread(entry, watermark) {
                    out.push(HistoryListItem::UnreadDivider);
                    divider_inserted = true;
                }
            }
        }
        out.push(item);
    }
    out
}

/// Insert an unread divider before the first unread entry when enabled.
pub fn with_unread_divider(
    entries: &[HistoryEntry],
    watermark: DateTime<Utc>,
    show_divider: bool,
) -> Vec<HistoryListItem> {
    if !show_divider {
        return entries
            .iter()
            .cloned()
            .map(HistoryListItem::Entry)
            .collect();
    }

    let mut out = Vec::with_capacity(entries.len() + 1);
    let mut divider_inserted = false;

    for entry in entries {
        if !divider_inserted && is_entry_unread(entry, watermark) {
            out.push(HistoryListItem::UnreadDivider);
            divider_inserted = true;
        }
        out.push(HistoryListItem::Entry(entry.clone()));
    }

    out
}

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

    use crate::types::{HistoryActor, HistoryChange};

    fn entry(id: &str, at: DateTime<Utc>) -> HistoryEntry {
        HistoryEntry {
            id: id.into(),
            kind: "created".into(),
            changed_at: at,
            actor: HistoryActor::System,
            change: HistoryChange::Created,
        }
    }

    #[test]
    fn unread_divider_before_first_unread() {
        let wm = Utc.with_ymd_and_hms(2026, 7, 1, 12, 0, 0).unwrap();
        let old = entry("a", wm - chrono::Duration::hours(1));
        let new = entry("b", wm + chrono::Duration::hours(1));
        let items = with_unread_divider(&[old, new], wm, true);
        assert_eq!(items.len(), 3);
        assert!(matches!(items[0], HistoryListItem::Entry(_)));
        assert!(matches!(items[1], HistoryListItem::UnreadDivider));
        assert!(matches!(items[2], HistoryListItem::Entry(_)));
    }
}