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
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
133
134
135
136
137
138
139
140
141
142

use clap::{CommandFactory, Parser};
use colored::Colorize;
use std::path::PathBuf;

mod cli;
mod document;
mod included;
mod ioutil;
mod log;
mod paths;
mod server;
mod service;
mod themes;
mod watcher;

async fn run() -> Result<(), Box<dyn std::error::Error>> {
    let cli = cli::Cli::parse();

    if let Some(generator) = cli.generator {
        let mut cmd = cli::Cli::command();
        cli::print_completions(generator, &mut cmd);
        return Ok(());
    }

    if cli.themes {
        for theme in themes::available_themes()?.themes.into_iter() {
            println!("{}", theme.name);
        }

        return Ok(());
    }

    if cli.where_config {
        println!("{}", paths::dirs::config().display());

        return Ok(());
    }

    if let Some(path) = &cli.path {
        if path.is_dir() {
            die!("Path is a directory")
        }

        if !path.exists() {
            die!("No such file")
        }
    }

    let options = document::RenderOptions {
        theme: cli.get_theme()?,
        math: cli.all || cli.math,
        highlight: cli.all || cli.highlight,
        diagrams: cli.all || cli.diagrams,
        live: cli.live,
        include_images: cli.include_images,
        optimize_images: cli.optimize_images,
    };

    info!("Using theme {}", options.theme.name.cyan());
    if options.highlight {
        info!("Highlight.js syntax highlighting is enabled");
    }

    if options.math {
        info!("KaTeX math rendering is enabled");
    }

    if options.diagrams {
        info!("Mermaid diagrams rendering is enabled");
    }

    let out = {
        let auto_extension = "html";

        if let Some(out) = &cli.out {
            out.clone()
        } else if let Some(path) = &cli.path {
            path.with_extension(auto_extension)
        } else {
            PathBuf::new()
                .with_file_name("out")
                .with_extension(auto_extension)
        }
    };

    if cli.watch || cli.live {
        if cli.path.is_none() {
            die!("watcher needs a file to watch");
        }

        let path = &cli.path.unwrap();

        if cli.live {
            watcher::watch_live(path, &options, cli.port).await?;
        } else {
            watcher::watch_file(path, &out, &options).await?;
        }

        return Ok(());
    }

    let doc = document::Document {
        text: cli.get_markdown()?,
        options,
    };
    let buffer = doc.render()?;

    if cli.stdout {
        let string = String::from_utf8(buffer).unwrap();
        println!("{}", string);
    } else {
        std::fs::write(&out, &buffer)?;
        info!(
            "wrote {} to {}",
            humansize::format_size(buffer.len(), humansize::DECIMAL),
            &out.display().to_string().cyan(),
        );

        if cli.open {
            open::that(&out)?;
        }
    }

    Ok(())
}

#[tokio::main]
async fn main() {
    let execution_start = std::time::Instant::now();

    match run().await {
        Ok(_) => {
            let execution_duration = execution_start.elapsed();

            success!(
                "took {}",
                format!("{}ms", execution_duration.as_millis()).yellow(),
            )
        }
        Err(e) => die!("{}", e.to_string()),
    }
}