rsmooth 0.3.1

Opinionated wrapper for pandoc using YAML headers for configuration
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
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

#[macro_use]
extern crate log;

/// Format argument for a PDF output.
const PDF_FORMAT: &str = "pdf";
/// Format argument for a ODT (OpenDocument Text) output.
const ODT_FORMAT: &str = "odt";
/// Format argument for a DOCX (Office Open XML Document) output.
const DOCX_FORMAT: &str = "docx";
/// Format argument for a ODT (OpenDocument Text) and PDF output.
const ODTPDF_FORMAT: &str = "odtpdf";
/// Format argument for a Reveal.js output.
const REVEAL_FORMAT: &str = "reveal";

use clap::{App, AppSettings, Arg, ArgMatches, ValueHint};

/// Default CLI interface for rsmooth-lib.
pub fn main() {
    let matches = App::new("rsmooth")
        .version("0.3.0")
        .author("72nd <msg@frg72.com>")
        .about("simple tool chain/wrapper for pandoc.")
        .setting(AppSettings::ArgRequiredElseHelp)
        .setting(AppSettings::SubcommandsNegateReqs)
        .arg(
            Arg::new("debug")
                .about("enable debug mode")
                .long("debug")
                .short('d')
                .global(true),
        )
        .arg(
            Arg::new("format")
                .about("set the output format")
                .long("format")
                .short('f')
                .takes_value(true)
                .possible_value(PDF_FORMAT)
                .possible_value(ODT_FORMAT)
                .possible_value(DOCX_FORMAT)
                .possible_value(ODTPDF_FORMAT)
                .possible_value(REVEAL_FORMAT)
                .default_value(PDF_FORMAT)
        )
        .arg(
            Arg::new("INPUT")
                .about("path to input markdown file")
                .value_name("INPUT")
                .required(true)
                .index(1)
                .value_hint(ValueHint::AnyPath),
        )
        .arg(
            Arg::new("raw")
                .about("outputs the finalized pandoc input on the stdout for debugging")
                .long("raw")
                .short('r')
                .global(true),
        )
        .arg(
            Arg::new("output")
                .about("optional output file path")
                .long("output")
                .short('o')
                .takes_value(true),
        )
        .subcommand(
            App::new("example-file")
                .about("outputs a example markdown file with all available header fields")
                .arg(
                    Arg::new("output")
                        .about("optional output file path")
                        .long("output")
                        .short('o')
                        .takes_value(true),
                ),
        )
        .get_matches();

    env_logger::Builder::new()
        .filter(
            None,
            match matches.is_present("debug") {
                true => log::LevelFilter::Debug,
                false => log::LevelFilter::Info,
            },
        )
        .init();

    match matches.subcommand() {
        Some(("example-file", x)) => example_cmd(x),
        Some((&_, _)) => {}
        None => default_cmd(&matches),
    }
}

/// Handles example subcommand.
fn example_cmd(matches: &ArgMatches) {
    match lib::example(matches.value_of("output")) {
        Ok(x) => match x {
            Some(x) => println!("{}", x),
            None => {}
        },
        Err(e) => error!("{}", e),
    }
}

/// Handles default command.
fn default_cmd(matches: &ArgMatches) {
    match lib::convert(
        matches.value_of("INPUT").unwrap(),
        matches.value_of("output"),
        matches.is_present("raw"),
        match matches.value_of("format").unwrap() {
            PDF_FORMAT => lib::OutputFormat::Pdf,
            ODT_FORMAT => lib::OutputFormat::Odt,
            DOCX_FORMAT => lib::OutputFormat::Docx,
            ODTPDF_FORMAT => lib::OutputFormat::OdtPdf,
            REVEAL_FORMAT => lib::OutputFormat::Reveal,
            _ => lib::OutputFormat::Pdf,
        },
    ) {
        Ok(_) => {}
        Err(e) => error!("{}", e),
    };
}