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

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

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

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

#[derive(Default)]
pub struct MdRenderer {}
impl MdRenderer {
    pub fn new() -> Self {
        Self {}
    }
}
impl Renderer for MdRenderer {
    fn render_header(&self, content: &str, level: usize) -> String {
        format!("{} {}", &"#".repeat(level), content.trim())
    }

    fn render_front_matter(&self, title: Option<&str>) -> String {
        if let Some(t) = title {
            self.render_header(t, 1)
        } else {
            String::new()
        }
    }

    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!("{}.md", target)
        };
        let rendered = match display_text {
            Some(text) => format!("[{text}]({t})"),
            None => format!("[{t}]({t})"),
        };
        Ok(rendered)
    }

    fn content_path(&self) -> Option<PathBuf> {
        None
    }

    fn index_file(&self, _title: Option<String>) -> Option<(PathBuf, String)> {
        None
    }
}

#[cfg(test)]
mod test {
    use std::path::PathBuf;

    use pretty_assertions::assert_eq;

    use color_eyre::Result;

    use crate::render::formats::{Renderer, md::MdRenderer};
    #[test]
    fn test_render_md_header() -> Result<()> {
        let text = String::from("foo");
        let out = MdRenderer::new().render_header(&text, 1);
        assert_eq!(out, String::from("# foo"));
        Ok(())
    }

    #[test]
    fn test_render_external_ref() -> Result<()> {
        let text = String::from("foo");
        let url = String::from("https://example.com/docs/foo/bar/baz.html#Bullshit");
        let out = MdRenderer::new().render_reference(Some(text), &PathBuf::from(""), url)?;
        assert_eq!(
            out,
            String::from("[foo](https://example.com/docs/foo/bar/baz.html#Bullshit)")
        );
        Ok(())
    }
    #[test]
    fn test_render_internal_ref() -> Result<()> {
        let text = String::from("foo");
        let rel_path = String::from("foo/bar/index");

        let out = MdRenderer::new().render_reference(Some(text), &PathBuf::from(""), rel_path)?;
        assert_eq!(out, String::from("[foo](foo/bar/index.md)"));
        Ok(())
    }
}