]> git.r.bdr.sh - rbdr/blog/blob - src/archiver/mod.rs
Set rust
[rbdr/blog] / src / archiver / mod.rs
1 mod raw;
2 mod gemini;
3 mod gopher;
4
5 use std::collections::HashMap;
6 use std::fs::read_dir;
7 use std::io::Result;
8 use std::path::PathBuf;
9 use time::{OffsetDateTime, format_description::FormatItem, macros::format_description};
10 use crate::template::{TemplateContext, TemplateValue};
11
12 const DATE_FORMAT: &[FormatItem<'_>] = format_description!("[year]-[month]-[day]");
13
14 struct ArchiveEntry {
15 id: String,
16 slug: String
17 }
18
19 impl ArchiveEntry {
20 pub fn to_template_context(archive_entries: &Vec<ArchiveEntry>) -> TemplateContext {
21 let mut context = HashMap::new();
22
23 let archive_entries_collection = archive_entries
24 .iter()
25 .map(|archive_entry| archive_entry.to_template_value())
26 .collect();
27
28 context.insert(
29 "archive_length".to_string(),
30 TemplateValue::Unsigned(
31 archive_entries.len().try_into().unwrap()
32 )
33 );
34 context.insert(
35 "posts".to_string(),
36 TemplateValue::Collection(archive_entries_collection)
37 );
38
39 context
40 }
41
42 pub fn to_template_value(&self) -> TemplateContext {
43 let mut context = HashMap::new();
44
45 context.insert(
46 "id".to_string(),
47 TemplateValue::String(self.id.clone())
48 );
49
50 context.insert(
51 "slug".to_string(),
52 TemplateValue::String(self.slug.clone())
53 );
54
55 if let Some(title) = self.title() {
56 context.insert(
57 "title".to_string(),
58 TemplateValue::String(title)
59 );
60 }
61
62 context
63 }
64
65 fn title(&self) -> Option<String> {
66 let date = OffsetDateTime::from_unix_timestamp_nanos(
67 (self.id.parse::<u64>().ok()? * 1_000_000).into()
68 ).ok()?;
69 let short_date = date.format(&DATE_FORMAT).ok()?;
70 let title = self.slug.replace("-", " ");
71 Some(format!("{} {}", short_date, title))
72 }
73 }
74
75 fn read_archive(archive_directory: &PathBuf) -> Vec<ArchiveEntry> {
76 let mut archive_entries = Vec::new();
77 if let Ok(entries) = read_dir(&archive_directory) {
78 for entry in entries.filter_map(Result::ok) {
79 let entry_path = entry.path();
80 let post_id = entry.file_name();
81 if let Ok(entry_type) = entry.file_type() {
82 if entry_type.is_dir() {
83 if let Ok(candidates) = read_dir(&entry_path) {
84 for candidate in candidates.filter_map(Result::ok) {
85 let candidate_path = candidate.path();
86 match candidate_path.extension() {
87 Some(extension) => {
88 if extension == "gmi" {
89 if let Some(slug) = candidate_path.file_stem() {
90 if let (Some(post_id), Some(slug)) = (post_id.to_str(), slug.to_str()) {
91 archive_entries.push(ArchiveEntry {
92 id: post_id.to_string(),
93 slug: slug.to_string()
94 })
95 }
96 }
97 }
98 },
99 _ => continue
100 }
101 }
102 }
103 }
104 }
105 }
106 }
107
108 archive_entries
109 .sort_by(|a, b| b.id.cmp(&a.id));
110 archive_entries
111 }
112
113
114 pub fn archive(archive_directory: &PathBuf, template_directory: &PathBuf, output_directory: &PathBuf) -> Result<()> {
115 let archivers = available_archivers();
116 let archive_entries = read_archive(archive_directory);
117 let context = ArchiveEntry::to_template_context(&archive_entries);
118 for archiver in archivers {
119 archiver(archive_directory, template_directory, output_directory, &context)?;
120 }
121 return Ok(())
122 }
123
124 fn available_archivers() -> Vec<fn(&PathBuf, &PathBuf, &PathBuf, &TemplateContext) -> Result<()>> {
125 vec![
126 raw::archive,
127 gemini::archive,
128 gopher::archive
129 ]
130 }