birta 0.5.0

Preview markdown files in the browser with GitHub-style rendering
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

use std::collections::HashSet;
use std::path::PathBuf;
use std::sync::Arc;

use notify_debouncer_mini::{DebouncedEventKind, new_debouncer};
use tokio::sync::broadcast;

use crate::render;
use crate::server::{AppState, ContentUpdate};

/// Watch a directory recursively and broadcast rendered HTML for changed `.md` files.
pub(crate) fn watch_dir(
    base_dir: PathBuf,
    tx: broadcast::Sender<ContentUpdate>,
    state: Arc<AppState>,
) -> anyhow::Result<notify_debouncer_mini::Debouncer<notify::RecommendedWatcher>> {
    let canonical_base = base_dir.canonicalize()?;
    let rt = tokio::runtime::Handle::current();

    let mut debouncer = new_debouncer(
        std::time::Duration::from_millis(200),
        move |events: Result<Vec<notify_debouncer_mini::DebouncedEvent>, notify::Error>| {
            let events = match events {
                Ok(events) => events,
                Err(e) => {
                    eprintln!("birta: watcher error: {e}");
                    return;
                }
            };

            // Collect unique .md files that changed
            let mut changed: HashSet<PathBuf> = HashSet::new();
            for event in &events {
                if event.kind != DebouncedEventKind::Any {
                    continue;
                }
                let Ok(path) = event.path.canonicalize() else {
                    continue;
                };
                if !path.starts_with(&canonical_base) {
                    continue;
                }
                match path.extension().and_then(|e| e.to_str()) {
                    Some("md" | "markdown") => {
                        changed.insert(path);
                    }
                    _ => continue,
                }
            }

            if changed.is_empty() {
                return;
            }

            let syntax_theme = rt.block_on(async {
                let reg = state.registry.read().await;
                reg.active().active_data().syntax.clone()
            });

            for path in changed {
                let relpath = path
                    .strip_prefix(&canonical_base)
                    .unwrap_or(&path)
                    .to_string_lossy()
                    .into_owned();

                let markdown = match std::fs::read_to_string(&path) {
                    Ok(s) => s,
                    Err(e) => {
                        eprintln!("birta: could not read {relpath}: {e}");
                        continue;
                    }
                };

                let html = render::render_dir(
                    &markdown,
                    syntax_theme.as_ref(),
                    std::path::Path::new(&relpath),
                );
                let source = render::render_source(&markdown, syntax_theme.as_ref());
                let _ = tx.send(ContentUpdate {
                    relpath,
                    rendered_html: html,
                    source_html: source,
                });
            }
        },
    )?;

    if let Err(e) = debouncer
        .watcher()
        .watch(&base_dir, notify::RecursiveMode::Recursive)
    {
        eprintln!("birta: warning: directory watch failed: {e}");
        eprintln!("birta: hint: on Linux, try increasing fs.inotify.max_user_watches");
    }

    Ok(debouncer)
}