mdoc 0.3.0

Modern PDF creation through Markdown and LaTeX
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

use anyhow::Result;
use std::path::PathBuf;
use structopt::{clap, StructOpt};

mod cmd;

#[derive(StructOpt)]
#[structopt(name = "MDoc", author = "Knut Magnus Aasrud")]
/// LaTeX for the modern world.
struct App {
    #[structopt(subcommand)]
    command: Command,

    #[structopt(short = "q", long = "quiet")]
    /// Make MDoc quiet. Only errors will get reported.
    quiet: bool,

    #[structopt(short = "d", long = "debug")]
    /// Make MDoc's output verbose. Used for debugging.
    debug: bool,
}

#[derive(Debug, StructOpt)]
enum Command {
    /// Builds a file or document.
    Build {
        #[structopt(parse(from_os_str))]
        /// File to build into PDF (optional).
        path: Option<PathBuf>,

        #[structopt(short = "o", long = "output")]
        /// The type of output you want to build to.
        output: Option<String>,
    },

    /// Clean up files from a project or the data directory.
    Clean {
        #[structopt(long = "data")]
        /// Delete the data directory.
        data: bool,
    },

    /// Initializes a new document.
    Init {
        #[structopt(parse(from_os_str))]
        /// Directory to initialize the document in.
        path: Option<PathBuf>,
    },

    /// Lists the document structure.
    List,
}

fn run() -> Result<()> {
    let app = App::from_args_safe()?;

    match (app.debug, app.quiet) {
        (false, false) => mdoc::log::set_max_level(3),
        (true, _) => mdoc::log::set_max_level(4),
        (false, true) => mdoc::log::set_max_level(1),
    }

    match app.command {
        Command::Build { path, output } => cmd::build(path, output)?,

        Command::Clean { data } => cmd::clean(data)?,

        Command::Init { path } => cmd::init(path)?,

        Command::List => mdoc::info!("Listing"),
    }

    Ok(())
}

fn main() {
    if let Err(e) = run() {
        match e.downcast_ref::<clap::Error>() {
            Some(e) if e.kind == clap::ErrorKind::HelpDisplayed => {
                println!("{}", e)
            }
            Some(e) => {
                mdoc::error!(
                    "{}",
                    e.to_string()
                        .trim_start_matches("\u{1b}[1;31merror:\u{1b}[0m ")
                );
                std::process::exit(1);
            }
            _ => {
                mdoc::error!("{}{}", e, mdoc::log::format_chain(e.chain()));
                std::process::exit(1);
            }
        }
    }
}