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
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
143
144
145
146
147
148
149
150
151
152
153
154

use crate::utils::{kebab, read_file};

use anyhow::Result;
use chrono::{Local, NaiveDate, NaiveDateTime};
use serde::{Deserialize, Serialize};
use std::path::Path;

#[derive(Debug, Deserialize, Serialize)]
#[serde(default, rename_all = "kebab-case")]
pub struct Config {
    pub(crate) src: Option<toml::Value>,

    // Metadata
    pub title: String,
    pub authors: Vec<String>,
    pub date: Option<String>,

    // Subtables
    pub bib: BibConfig,
    pub build: BuildConfig,
    pub latex: LatexConfig,
    pub style: StyleConfig,
}

impl Config {
    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
        let config_content = read_file(path)?;
        Ok(toml::from_str(&config_content)?)
    }

    pub(crate) fn latex_header(&self) -> Option<String> {
        if self.latex.head.is_empty() && self.latex.packages.is_empty() {
            None
        } else {
            let mut header = String::new();
            header.push_str(&self.latex.head);
            let packages: String = self
                .latex
                .packages
                .iter()
                .map(|package| format!("\\usepackage{{{}}}\n", package))
                .collect();
            header.push_str(&packages);
            Some(header)
        }
    }

    pub(crate) fn date(&self) -> String {
        match self.date.as_deref() {
            Some("now") => {
                let now = Local::now();
                now.format(&self.style.date_format).to_string()
            }
            Some(date) => {
                // NOTE: When formatting with invalid format strings (e.g. time formatters when
                // time is not available), chrono panics with a really vague message. I am unable
                // to fix this myself and will just have to hope this does not happen.
                //
                // Related issue: https://github.com/chronotope/chrono/issues/575
                // Related PR: https://github.com/chronotope/chrono/pull/614
                if let Ok(dt) = date.parse::<NaiveDateTime>() {
                    return dt.format(&self.style.date_format).to_string();
                }
                if let Ok(dt) = date.parse::<NaiveDate>() {
                    return dt.format(&self.style.date_format).to_string();
                }
                date.to_owned()
            }
            None => String::default(),
        }
    }

    pub fn filename(&self) -> String {
        self.build
            .filename
            .to_owned()
            .unwrap_or_else(|| kebab(&self.title))
    }
}

impl Default for Config {
    fn default() -> Self {
        Self {
            src: None,
            title: "Document title".to_owned(),
            authors: vec![],
            date: None,
            bib: BibConfig::default(),
            build: BuildConfig::default(),
            latex: LatexConfig::default(),
            style: StyleConfig::default(),
        }
    }
}

#[derive(Debug, Deserialize, Serialize)]
#[serde(default, rename_all = "kebab-case")]
pub struct BibConfig {
    pub csl: String,
    pub src: Option<String>,
}

impl Default for BibConfig {
    fn default() -> Self {
        Self {
            csl: "apa".to_owned(),
            src: None,
        }
    }
}

#[derive(Debug, Deserialize, Serialize)]
#[serde(default, rename_all = "kebab-case")]
pub struct BuildConfig {
    pub filename: Option<String>,
    pub tidy_logs: bool,
    pub output: String,
}

impl Default for BuildConfig {
    fn default() -> Self {
        Self {
            filename: None,
            tidy_logs: true,
            output: "pdf".to_owned(),
        }
    }
}

#[derive(Debug, Deserialize, Serialize)]
#[serde(default, rename_all = "kebab-case")]
pub struct StyleConfig {
    pub number_sections: bool,
    pub date_format: String,
    pub document_class: Option<String>,
}

impl Default for StyleConfig {
    fn default() -> Self {
        Self {
            number_sections: false,
            date_format: "%e %B %Y".to_owned(),
            document_class: None,
        }
    }
}

#[derive(Debug, Default, Deserialize, Serialize)]
#[serde(default, rename_all = "kebab-case")]
pub struct LatexConfig {
    pub head: String,
    pub packages: Vec<String>,
    pub title_script: Option<String>,
}