clin-rs 0.8.8

Encrypted terminal note-taking app inspired by Obsidian
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
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::fs;
use std::io::Write;
use std::path::Path;

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};

use super::variables::TemplateVariables;

#[derive(Debug, Clone, Deserialize)]
struct LegacyTemplateFile {
    template: LegacyTemplateMeta,
    #[serde(default)]
    title: TitleConfig,
    content: ContentConfig,
}

#[derive(Debug, Clone, Deserialize)]
struct LegacyTemplateMeta {
    name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Template {
    pub name: String,

    #[serde(default)]
    pub title: TitleConfig,

    pub content: ContentConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct TitleConfig {
    #[serde(default)]
    pub template: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ContentConfig {
    #[serde(default)]
    pub template: String,
}

#[derive(Debug, Clone)]
pub struct RenderedTemplate {
    pub title: Option<String>,
    pub content: String,
}

impl Template {
    pub fn load(path: &Path) -> Result<Self> {
        let content = fs::read_to_string(path).context("failed to read template file")?;

        if let Ok(template) = toml::from_str::<Template>(&content) {
            return Ok(template);
        }

        if let Ok(legacy) = toml::from_str::<LegacyTemplateFile>(&content) {
            return Ok(Template {
                name: legacy.template.name,
                title: legacy.title,
                content: legacy.content,
            });
        }

        anyhow::bail!("failed to parse template")
    }

    pub fn save(&self, path: &Path) -> Result<()> {
        let content = toml::to_string_pretty(self).context("failed to serialize template")?;

        if let Some(parent) = path.parent() {
            fs::create_dir_all(parent).context("failed to create templates directory")?;
        }

        let mut file = fs::File::create(path).context("failed to create template file")?;
        file.write_all(content.as_bytes())
            .context("failed to write template file")?;

        Ok(())
    }

    pub fn render(&self) -> RenderedTemplate {
        let vars = TemplateVariables::now();

        let title = self.title.template.as_ref().map(|t| vars.substitute(t));

        let content = vars.substitute(&self.content.template);

        RenderedTemplate { title, content }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_template_toml_roundtrip() {
        let template = Template {
            name: "Test".to_string(),
            title: TitleConfig {
                template: Some("Title - {date}".to_string()),
            },
            content: ContentConfig {
                template: "Content here".to_string(),
            },
        };

        let toml_str = toml::to_string_pretty(&template).unwrap();
        let parsed: Template = toml::from_str(&toml_str).unwrap();

        assert_eq!(template.name, parsed.name);
        assert_eq!(template.title.template, parsed.title.template);
        assert_eq!(template.content.template, parsed.content.template);
    }

    #[test]
    fn test_legacy_template_format_parse() {
        let legacy = r#"[template]
name = "Legacy"

[title]
template = "Legacy - {date}"

[content]
template = "Body"
"#;

        let parsed: LegacyTemplateFile = toml::from_str(legacy).unwrap();
        let converted = Template {
            name: parsed.template.name,
            title: parsed.title,
            content: parsed.content,
        };

        assert_eq!(converted.name, "Legacy");
        assert_eq!(converted.title.template.as_deref(), Some("Legacy - {date}"));
        assert_eq!(converted.content.template, "Body");
    }
}