marky 0.9.0

Markdown Magician 🧙
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

use anyhow::Result;
use colored::Colorize;
use notify::Watcher;

use crate::{document, error, info, ioutil};
use std::{
    io, net,
    path::{Path, PathBuf},
};

fn recompile(path: &PathBuf, options: &document::RenderOptions) -> io::Result<document::Document> {
    match ioutil::read_path(path) {
        Ok(contents) => Ok(document::Document {
            text: contents,
            options: options.clone(),
        }),
        Err(e) => Err(e),
    }
}

macro_rules! watch {
    ($path: ident, $options:ident, $on_update:ident$(.$field:ident)*$( $arg:ident)*) => {{
        info!("waiting for changes on {}", $path.display().to_string().cyan());

        let (tx, rx) = std::sync::mpsc::channel();
        let mut watcher = notify::RecommendedWatcher::new(tx, notify::Config::default())?;

        watcher.watch($path.as_path(), notify::RecursiveMode::NonRecursive)?;

        if let Ok(compiled) = recompile($path, $options) {
            $on_update$(.$field)*($($arg,)* &compiled).await;
        }

        for res in rx {
            match res {
                Ok(event) => {
                    if event.kind.is_modify() {
                        match recompile($path, $options) {
                            Ok(compiled) => {
                                $on_update$(.$field)*($($arg,)* &compiled).await;
                                info!("updated")
                            },
                            Err(e) => error!("compilation failed: {}", e)
                        }
                    }
                }
                Err(e) => error!("{}", e.to_string()),
            }
        }

        Ok(())
    }};
}

pub async fn watch_live(
    path: &PathBuf,
    options: &document::RenderOptions,
    port: u16,
) -> Result<(), Box<dyn std::error::Error>> {
    let addr = net::SocketAddr::V4(net::SocketAddrV4::new(
        net::Ipv4Addr::new(127, 0, 0, 1),
        port,
    ));

    let config = crate::server::Config {
        root_dir: path
            .clone()
            .parent()
            .unwrap_or(Path::new("."))
            .to_path_buf(),
        render_options: options.clone(),
    };

    let server = crate::server::Server::bind(&addr, config);

    watch!(path, options, server.send)
}

pub async fn watch_file(
    path: &PathBuf,
    output: &PathBuf,
    options: &document::RenderOptions,
) -> Result<(), Box<dyn std::error::Error>> {
    watch!(path, options, write_to_file output)
}

async fn write_to_file(path: &PathBuf, document: &document::Document) {
    match document.render() {
        Ok(rendered) => {
            if let Err(e) = std::fs::write(path, rendered) {
                error!("{}", e);
            }
        }
        Err(e) => error!("{}", e),
    }
}