hd-watch 0.2.0

File system watcher with debouncing and DAG invalidation for hyperdocker
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::collections::HashMap;
use std::path::PathBuf;

#[derive(Debug, Clone, PartialEq)]
pub enum ChangeKind {
    Created,
    Modified,
    Deleted,
    Renamed,
}

#[derive(Debug, Clone)]
pub struct RawChange {
    pub path: PathBuf,
    pub kind: ChangeKind,
}

/// Collects raw filesystem events and coalesces them by path.
/// When drained, emits one event per unique path (last event wins).
pub struct Debouncer {
    pending: HashMap<PathBuf, ChangeKind>,
}

impl Debouncer {
    pub fn new() -> Self {
        Debouncer {
            pending: HashMap::new(),
        }
    }

    /// Push a raw change event. If the same path was already pending,
    /// the new kind overwrites the old one.
    pub fn push(&mut self, change: RawChange) {
        self.pending.insert(change.path, change.kind);
    }

    /// Drain all pending changes, returning a batch of coalesced events.
    pub fn drain(&mut self) -> Vec<RawChange> {
        let batch: Vec<RawChange> = self.pending
            .drain()
            .map(|(path, kind)| RawChange { path, kind })
            .collect();
        batch
    }

    /// Check if there are pending changes.
    pub fn has_pending(&self) -> bool {
        !self.pending.is_empty()
    }
}

impl Default for Debouncer {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn single_event_emitted_after_drain() {
        let mut debouncer = Debouncer::new();
        debouncer.push(RawChange {
            path: PathBuf::from("src/main.rs"),
            kind: ChangeKind::Modified,
        });
        let batch = debouncer.drain();
        assert_eq!(batch.len(), 1);
        assert_eq!(batch[0].path, PathBuf::from("src/main.rs"));
    }

    #[test]
    fn duplicate_paths_coalesced() {
        let mut debouncer = Debouncer::new();
        debouncer.push(RawChange {
            path: PathBuf::from("src/main.rs"),
            kind: ChangeKind::Modified,
        });
        debouncer.push(RawChange {
            path: PathBuf::from("src/main.rs"),
            kind: ChangeKind::Modified,
        });
        let batch = debouncer.drain();
        assert_eq!(batch.len(), 1);
    }

    #[test]
    fn different_paths_preserved() {
        let mut debouncer = Debouncer::new();
        debouncer.push(RawChange {
            path: PathBuf::from("a.rs"),
            kind: ChangeKind::Modified,
        });
        debouncer.push(RawChange {
            path: PathBuf::from("b.rs"),
            kind: ChangeKind::Created,
        });
        let batch = debouncer.drain();
        assert_eq!(batch.len(), 2);
    }

    #[test]
    fn drain_clears_buffer() {
        let mut debouncer = Debouncer::new();
        debouncer.push(RawChange {
            path: PathBuf::from("file.rs"),
            kind: ChangeKind::Modified,
        });
        let _ = debouncer.drain();
        let batch = debouncer.drain();
        assert!(batch.is_empty());
    }

    #[test]
    fn last_kind_wins_for_same_path() {
        let mut debouncer = Debouncer::new();
        debouncer.push(RawChange {
            path: PathBuf::from("file.rs"),
            kind: ChangeKind::Created,
        });
        debouncer.push(RawChange {
            path: PathBuf::from("file.rs"),
            kind: ChangeKind::Deleted,
        });
        let batch = debouncer.drain();
        assert_eq!(batch.len(), 1);
        assert_eq!(batch[0].kind, ChangeKind::Deleted);
    }
}