calepin 0.0.20

A Rust CLI for preprocessing Typst documents with executable code chunks
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

use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc;
use std::sync::Arc;
use std::time::Duration;

use anyhow::{Context, Result};
use notify::RecursiveMode;
use notify_debouncer_full::new_debouncer;

pub fn is_write_event(kind: &notify::EventKind) -> bool {
    matches!(
        kind,
        notify::EventKind::Create(_)
            | notify::EventKind::Modify(notify::event::ModifyKind::Data(_))
            | notify::EventKind::Modify(notify::event::ModifyKind::Name(_))
            | notify::EventKind::Modify(notify::event::ModifyKind::Any)
    )
}

pub fn is_rebuild_event(kind: &notify::EventKind) -> bool {
    is_write_event(kind) || matches!(kind, notify::EventKind::Remove(_))
}

pub fn run_debounced_watch(
    watches: &[(PathBuf, RecursiveMode)],
    debounce: Duration,
    poll: Duration,
    stop: Arc<AtomicBool>,
    event_filter: impl FnMut(&notify::EventKind) -> bool,
    path_filter: impl FnMut(PathBuf) -> Option<PathBuf>,
    mut on_change: impl FnMut(&[PathBuf]),
) -> Result<()> {
    run_debounced_watch_until(
        watches,
        debounce,
        poll,
        stop,
        event_filter,
        path_filter,
        |changed| {
            on_change(changed);
            true
        },
    )
}

pub fn run_debounced_watch_until(
    watches: &[(PathBuf, RecursiveMode)],
    debounce: Duration,
    poll: Duration,
    stop: Arc<AtomicBool>,
    mut event_filter: impl FnMut(&notify::EventKind) -> bool,
    mut path_filter: impl FnMut(PathBuf) -> Option<PathBuf>,
    mut on_change: impl FnMut(&[PathBuf]) -> bool,
) -> Result<()> {
    let (tx, rx) = mpsc::channel();
    let mut debouncer =
        new_debouncer(debounce, None, tx).context("failed to create file watcher")?;

    for (path, mode) in watches {
        debouncer
            .watch(path, *mode)
            .with_context(|| format!("failed to watch {}", path.display()))?;
    }

    loop {
        if stop.load(Ordering::Relaxed) {
            break;
        }
        match rx.recv_timeout(poll) {
            Ok(Ok(events)) => {
                let mut changed = Vec::new();
                for event in events {
                    if !event_filter(&event.event.kind) {
                        continue;
                    }
                    for path in event.event.paths {
                        let path = path.canonicalize().unwrap_or(path);
                        if let Some(path) = path_filter(path) {
                            if !changed.contains(&path) {
                                changed.push(path);
                            }
                        }
                    }
                }
                if !changed.is_empty() && !on_change(&changed) {
                    break;
                }
            }
            Ok(Err(errors)) => {
                for error in errors {
                    cwarn!("watch error: {}", error);
                }
            }
            Err(mpsc::RecvTimeoutError::Timeout) => {}
            Err(mpsc::RecvTimeoutError::Disconnected) => break,
        }
    }

    Ok(())
}