kaeo 1.0.1

Keep an Eye on files and folder, run a command when one changes
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

use crate::{
    command::{Case, Command},
    helpers::find_ancestor,
};
use notify_debouncer_full::{
    DebounceEventResult, DebouncedEvent, new_debouncer,
    notify::{EventKind, RecursiveMode, event::ModifyKind},
};
use std::{path::PathBuf, sync::mpsc::Sender, time::Duration};

pub fn watch(command: Command, paths: Vec<PathBuf>, recursive: bool) {
    // Open debouncer
    let (tx, rx) = std::sync::mpsc::channel::<Vec<DebouncedEvent>>();
    let debouncer = new_debouncer(Duration::from_millis(500), None, on_event(tx));
    let mut debouncer = match debouncer {
        Ok(d) => d,
        Err(err) => {
            eprintln!("Failed to create Debouncer");
            eprintln!("Error : {err:?}");
            return;
        }
    };

    // Watch for change on all paths
    for path in paths.iter() {
        if let Err(err) = debouncer.watch(path, RecursiveMode::Recursive) {
            eprintln!("Failed to keep an eye on {path:?} for changes");
            eprintln!("Error : {err:?}");
            return;
        }
    }

    // Handle fs events
    for events in rx {
        for event in events {
            let modified = match event.kind {
                EventKind::Modify(modify_kind) => modify_kind,
                // FUTURE : Also kaeo Create
                _ => continue,
            };
            let _data = match modified {
                ModifyKind::Data(data_change) => data_change,
                // FUTURE : Also kaeo Metadata changes
                _ => continue,
            };

            assert_eq!(event.paths.len(), 1);
            if !recursive && command.case() == Case::OnePath {
                let ancestor = find_ancestor(&event.paths[0], &paths);
                command.run(&paths, Some(&ancestor), true);
            } else {
                command.run(&paths, Some(&event.paths[0]), true);
            }
        }
    }
}

fn on_event(tx: Sender<Vec<DebouncedEvent>>) -> impl Fn(DebounceEventResult) {
    move |event: DebounceEventResult| {
        let result = match event {
            Ok(event) => tx.send(event),
            Err(err) => {
                eprintln!("Failed to receive fs event");
                eprintln!("Error : {err:?}");
                return;
            }
        };
        if let Err(err) = result {
            eprintln!("Failed to transmit fs event");
            eprintln!("Error : {err:?}");
        }
    }
}