cdoc 0.8.1

A markdown-based document parser and processor
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

use anyhow::{anyhow, Context};
use serde::{Deserialize, Serialize};
use std::io::Write;
use tera::Context as TCtx;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PrecompiledFormat {
    Html,
    Markdown,
    LaTeX,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PrecompiledTemplate {
    Paragraph,
    Emphasis,
    Strong,
    HardBreak,
    SoftBreak,
}

impl PrecompiledTemplate {
    pub fn render(
        &self,
        format: &PrecompiledFormat,
        ctx: &TCtx,
        mut buf: impl Write,
    ) -> anyhow::Result<()> {
        match self {
            PrecompiledTemplate::Paragraph => match format {
                PrecompiledFormat::Html => write!(
                    &mut buf,
                    "<p>{}</p>",
                    ctx.get("value")
                        .ok_or(anyhow!("missing value"))?
                        .as_str()
                        .unwrap()
                )
                .context("rendering"),
                PrecompiledFormat::Markdown => writeln!(
                    &mut buf,
                    "{}",
                    ctx.get("value")
                        .ok_or(anyhow!("missing value"))?
                        .as_str()
                        .unwrap()
                )
                .context("rendering"),
                _ => Err(anyhow!(format!("unsupported format {:?}", format))),
            },
            PrecompiledTemplate::Emphasis => match format {
                PrecompiledFormat::Html => write!(
                    &mut buf,
                    "<em>{}</em>",
                    ctx.get("value")
                        .ok_or(anyhow!("missing value"))?
                        .as_str()
                        .unwrap()
                )
                .context("rendering"),
                PrecompiledFormat::Markdown => write!(
                    &mut buf,
                    "_{}_",
                    ctx.get("value")
                        .ok_or(anyhow!("missing value"))?
                        .as_str()
                        .unwrap()
                )
                .context("rendering"),
                _ => Err(anyhow!(format!("unsupported format {:?}", format))),
            },
            PrecompiledTemplate::Strong => match format {
                PrecompiledFormat::Html => write!(
                    &mut buf,
                    "<strong>{}</strong>",
                    ctx.get("value")
                        .ok_or(anyhow!("missing value"))?
                        .as_str()
                        .unwrap()
                )
                .context("rendering"),
                PrecompiledFormat::Markdown => write!(
                    &mut buf,
                    "**{}**",
                    ctx.get("value")
                        .ok_or(anyhow!("missing value"))?
                        .as_str()
                        .unwrap()
                )
                .context("rendering"),
                _ => Err(anyhow!(format!("unsupported format {:?}", format))),
            },
            PrecompiledTemplate::HardBreak => match format {
                PrecompiledFormat::Html => write!(&mut buf, "<br>",).context("rendering"),
                PrecompiledFormat::Markdown => write!(&mut buf, "\n\n",).context("rendering"),
                _ => Err(anyhow!(format!("unsupported format {:?}", format))),
            },
            PrecompiledTemplate::SoftBreak => match format {
                PrecompiledFormat::Html => write!(&mut buf, "",).context("rendering"),
                PrecompiledFormat::Markdown => writeln!(&mut buf).context("rendering"),
                _ => Err(anyhow!(format!("unsupported format {:?}", format))),
            },
        }?;
        Ok(())
    }
}