snakedown 0.3.0

This is a snakedown. Hand over your docs, nice and clean, and nobody gets confused.
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

use std::path::{Path, PathBuf};

use color_eyre::Result;
use url::Url;

use crate::render::formats::Renderer;

#[derive(Default)]
pub struct ZolaRenderer {}

impl Renderer for ZolaRenderer {
    fn render_header(&self, content: &str, level: usize) -> String {
        format!("{} {}", &"#".repeat(level), content.trim())
    }

    fn render_front_matter(&self, title: Option<&str>) -> String {
        let mut out = String::new();
        out.push_str("+++\n");
        if let Some(t) = title {
            out.push_str(&format!("title = \"{t}\"\n"));
        };
        out.push_str("+++");
        out
    }

    fn render_reference(
        &self,
        display_text: Option<String>,
        target_prefix: &Path,
        target: String,
    ) -> Result<String> {
        let t = if Url::parse(&target).is_ok() {
            target
        } else {
            format!(
                "{}",
                PathBuf::from("@")
                    .join(target_prefix)
                    .join(target)
                    .with_added_extension("md")
                    .display()
            )
        };
        let rendered = match display_text {
            Some(text) => format!("[{text}]({t})"),
            None => format!("[{t}]({t})"),
        };
        Ok(rendered)
    }
    fn content_path(&self) -> Option<PathBuf> {
        Some(PathBuf::from("content"))
    }

    fn index_file(&self, title: Option<String>) -> Option<(PathBuf, String)> {
        let index_front_matter = self.render_front_matter(title.as_deref());

        Some((PathBuf::from("_index.md"), index_front_matter))
    }
}

#[cfg(test)]
mod test {

    use super::*;
    use color_eyre::Result;
    use pretty_assertions::assert_eq;

    #[test]
    fn test_zola_header() -> Result<()> {
        let renderer = ZolaRenderer {};
        let obj_name = String::from("foo.bar.nasty-names_with_underscores_and_emoji_🙈");
        assert_eq!(
            renderer.render_header(&obj_name, 2),
            "## foo.bar.nasty-names_with_underscores_and_emoji_🙈"
        );
        Ok(())
    }

    #[test]
    fn test_empty_zola_front_matter() -> Result<()> {
        assert_eq!(
            ZolaRenderer {}.render_front_matter(None),
            r"+++
+++"
        );
        Ok(())
    }

    #[test]
    fn zola_internal_link_no_shortcode() -> Result<()> {
        #[cfg(windows)]
        let expected = r#"[Baz](@\foo.bar.baz.index.md)"#;
        #[cfg(not(windows))]
        let expected = r#"[Baz](@/foo.bar.baz.index.md)"#;

        assert_eq!(
            ZolaRenderer {}.render_reference(
                Some("Baz".to_string()),
                &PathBuf::from(""),
                String::from("foo.bar.baz.index")
            )?,
            expected
        );
        Ok(())
    }
    #[test]
    fn zola_external_link_no_shortcode() -> Result<()> {
        assert_eq!(
            ZolaRenderer {}.render_reference(
                Some("Dataset".to_string()),
                &PathBuf::from(""),
                "https://docs.xarray.dev/en/stable/generated/xarray.Dataset.html#xarray.Dataset"
                    .to_string(),
            )?,
            r#"[Dataset](https://docs.xarray.dev/en/stable/generated/xarray.Dataset.html#xarray.Dataset)"#
        );
        Ok(())
    }
    #[test]
    fn test_zola_front_matter_with_title() -> Result<()> {
        assert_eq!(
            ZolaRenderer {}.render_front_matter(Some("foo")),
            r#"+++
title = "foo"
+++"#
        );
        Ok(())
    }
}