1use std::{collections::HashMap, path::PathBuf};
2
3use gray_matter::{Matter, engine::YAML};
4use serde::{Deserialize, Serialize};
5use toml::Value;
6
7use crate::normalize_line_endings;
8
9#[derive(Debug, Serialize, Deserialize, Default, PartialEq, Clone)]
10pub struct Heading {
11    pub depth: u8,
12    pub text: String,
13    pub slug: String,
14}
15
16#[derive(Debug, Serialize, Deserialize, Default, Clone)]
17pub struct Document {
18    pub at_path: String,
19    pub metadata: BaseMetaData,
20    pub markdown: String,
21    pub excerpt: Option<String>,
22    pub html: Option<String>,
23    pub toc: Vec<Heading>,
24}
25
26#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
27#[serde(default)]
28pub struct BaseMetaData {
29    pub title: String,
30    pub description: String,
31    pub tags: Vec<String>,
32    pub keywords: Vec<String>,
33    pub template: String,
34
35    #[serde(flatten)]
36    pub user: HashMap<String, Value>,
37}
38
39impl Default for BaseMetaData {
40    fn default() -> Self {
41        Self {
42            title: Default::default(),
43            tags: Default::default(),
44            description: Default::default(),
45            keywords: Default::default(),
46            template: "default".into(),
47            user: Default::default(),
48        }
49    }
50}
51
52impl Document {
53    pub fn new_from_path(path: PathBuf) -> Self {
54        let contents_result = std::fs::read_to_string(&path);
55
56        if contents_result.is_err() {
57            dbg!("error reading file: {}", contents_result.err());
58            panic!("failed to read '{}'", path.display());
59        }
60
61        let matter = Matter::<YAML>::new();
62        let parseable = normalize_line_endings(contents_result.as_ref().unwrap().as_bytes());
63        let parse_result = matter.parse(&parseable);
64        let base_metadata_opt = match parse_result.data {
65            Some(data) => data.deserialize::<BaseMetaData>(),
66            None => Ok(BaseMetaData::default()),
67        };
68
69        if base_metadata_opt.is_err() {
70            dbg!("error parsing: {}", base_metadata_opt.err());
71            return Self::default();
72        }
73
74        let base_metadata = base_metadata_opt.unwrap();
75
76        if base_metadata.title.is_empty() {
77            panic!("title is required in your frontmatter!");
78        }
79
80        Self {
81            at_path: path.display().to_string(),
82            metadata: base_metadata,
83            markdown: parse_result.content,
84            excerpt: parse_result.excerpt,
85            ..Default::default()
86        }
87    }
88}
89
90#[cfg(test)]
91mod test {
92    use super::*;
93    use pretty_assertions::assert_eq;
94
95    #[test]
96    fn test_document_loading() {
97        let base_path_wd = std::env::current_dir()
98            .unwrap()
99            .as_os_str()
100            .to_os_string()
101            .to_str()
102            .unwrap()
103            .to_string();
104        let base_path = format!("{}/test_fixtures/markdown", base_path_wd);
105        let document = Document::new_from_path(format!("{}/full_frontmatter.md", base_path).into());
106
107        assert_eq!(
108            BaseMetaData {
109                tags: vec!["1".into()],
110                keywords: vec!["2".into()],
111                title: "test".into(),
112                description: "test".into(),
113                user: HashMap::new(),
114                template: "default".into(),
115            },
116            document.metadata
117        )
118    }
119
120    #[test]
121    #[should_panic]
122    fn test_bad_document_loading() {
123        let base_path_wd = std::env::current_dir()
124            .unwrap()
125            .as_os_str()
126            .to_os_string()
127            .to_str()
128            .unwrap()
129            .to_string();
130        let base_path = format!("{}/test_fixtures/markdown", base_path_wd);
131
132        Document::new_from_path(format!("{}/missing_frontmatter_keys.md", base_path).into());
133    }
134}