texted 1.2.1

A markdown blog platform that lets you in control of your data
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

use std::io;
use std::io::ErrorKind;

use ramhorns::Template;

use crate::content::Content;
use crate::text_utils::format_date_time;

#[derive(ramhorns::Content)]
struct ViewTag<'a> {
    tag: &'a str,
}

#[derive(ramhorns::Content)]
struct ViewItem<'a> {
    errors: Vec<String>,
    id: &'a str,
    author: &'a str,
    tags: &'a Vec<ViewTag<'a>>,
    date: &'a str,
    time: &'a str,
    post_title: &'a str,
    post_content: &'a str,
}

pub struct PostRenderer<'a> {
    pub template: Template<'a>,
}

impl PostRenderer<'_> {
    pub fn new(view_tpl_src: &str) -> io::Result<PostRenderer> {
        let template = match Template::new(view_tpl_src) {
            Ok(x) => x,
            Err(e) => {
                return Err(io::Error::new(ErrorKind::InvalidInput, format!("Error parsing post view template: {}", e)));
            }
        };

        Ok(PostRenderer {
            template,
        })
    }

    pub fn render(&self, content: &Content) -> String {
        let tags: &Vec<ViewTag> = &content.header.tags.iter().map(|t| ViewTag { tag: t.as_str() }).collect();
        let (date, time) = format_date_time(&content.header.date);
        let rendered_page = self.template.render(&ViewItem {
            errors: vec![],
            id: content.header.id.0.as_str(),
            author: content.header.author.as_str(),
            tags,
            date: date.as_str(),
            time: time.as_str(),
            post_title: content.title.as_str(),
            post_content: content.rendered.as_str(),
        });

        rendered_page
    }
}

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

    use chrono::{NaiveDate, NaiveDateTime, NaiveTime};

    use crate::content::{Content, ContentHeader, PostId};
    use crate::view::post_renderer::PostRenderer;

    #[test]
    fn render_view() {
        let template_src = r##"
TITLE=[{{{post_title}}}]
AUTHOR=[{{author}}]
DATE=[{{date}}]
TIME=[{{time}}]
TAGS=[{{#tags}}({{tag}}){{/tags}}]
POST_CONTENT=[{{{post_content}}}]
"##;
        let post_renderer = PostRenderer::new(template_src).unwrap();
        let content = Content {
            header: ContentHeader {
                file_name: PathBuf::from("file_name.md"),
                id: PostId("post-id".to_string()),
                date: NaiveDateTime::new(
                    NaiveDate::from_ymd_opt(2024, 01, 02).unwrap(),
                    NaiveTime::from_hms_opt(3, 4, 5).unwrap(),
                ),
                author: "<Thiago>".to_string(),
                tags: vec!["<rust>".to_string(), "programming".to_string()],
            },
            link: "".to_string(),
            title: "<post-title>".to_string(),
            rendered: "<post-content>".to_string(),
        };
        let res = post_renderer.render(&content);
        assert_eq!(res, r##"
TITLE=[<post-title>]
AUTHOR=[&lt;Thiago&gt;]
DATE=[2024-01-02]
TIME=[03:04:05]
TAGS=[(&lt;rust&gt;)(programming)]
POST_CONTENT=[<post-content>]"##);
    }
}