edition = "2021"
[dependencies]
-time = { version = "0.3.34", features = ["formatting"] }
+time = { version = "0.3.34", features = ["macros", "formatting"] }
serde = { version = "1.0.197", features = ["derive"] }
serde_json = "1.0.114"
--- /dev/null
+use std::fs::write;
+use std::io::Result;
+use std::path::PathBuf;
+use crate::template::{find, parse, TemplateContext};
+
+const FILENAME: &str = "index.gmi";
+
+pub fn archive(_: &PathBuf, template_directory: &PathBuf, target: &PathBuf, context: &TemplateContext) -> Result<()> {
+ match find(template_directory, FILENAME) {
+ Some(template) => {
+ let parsed_template = parse(&template);
+ let rendered_template = parsed_template.render(context);
+ let location = target.join(FILENAME);
+ write(location, rendered_template)?;
+ },
+ None => {}
+ }
+ Ok(())
+}
--- /dev/null
+use std::fs::write;
+use std::io::Result;
+use std::path::PathBuf;
+use crate::template::{find, parse, TemplateContext};
+
+const FILENAME: &str = "index.gph";
+
+pub fn archive(_: &PathBuf, template_directory: &PathBuf, target: &PathBuf, context: &TemplateContext) -> Result<()> {
+ match find(template_directory, FILENAME) {
+ Some(template) => {
+ let parsed_template = parse(&template);
+ let rendered_template = parsed_template.render(context);
+ let location = target.join(FILENAME);
+ write(location, rendered_template)?;
+ },
+ None => {}
+ }
+ Ok(())
+}
+mod raw;
+mod gemini;
+mod gopher;
+
+use std::collections::HashMap;
+use std::fs::read_dir;
+use std::io::Result;
+use std::path::PathBuf;
+use time::{OffsetDateTime, format_description::FormatItem, macros::format_description};
+use crate::template::{TemplateContext, TemplateValue};
+
+const DATE_FORMAT: &[FormatItem<'_>] = format_description!("[year]-[month]-[day]");
+
+struct ArchiveEntry {
+ id: String,
+ slug: String
+}
+
+impl ArchiveEntry {
+ pub fn to_template_context(archive_entries: &Vec<ArchiveEntry>) -> TemplateContext {
+ let mut context = HashMap::new();
+
+ let archive_entries_collection = archive_entries
+ .iter()
+ .map(|archive_entry| archive_entry.to_template_value())
+ .collect();
+
+ context.insert(
+ "archive_length".to_string(),
+ TemplateValue::Unsigned(
+ archive_entries.len().try_into().unwrap()
+ )
+ );
+ context.insert(
+ "posts".to_string(),
+ TemplateValue::Collection(archive_entries_collection)
+ );
+
+ context
+ }
+
+ pub fn to_template_value(&self) -> TemplateContext {
+ let mut context = HashMap::new();
+
+ context.insert(
+ "id".to_string(),
+ TemplateValue::String(self.id.clone())
+ );
+
+ context.insert(
+ "slug".to_string(),
+ TemplateValue::String(self.slug.clone())
+ );
+
+ if let Some(title) = self.title() {
+ context.insert(
+ "title".to_string(),
+ TemplateValue::String(title)
+ );
+ }
+
+ context
+ }
+
+ fn title(&self) -> Option<String> {
+ let date = OffsetDateTime::from_unix_timestamp_nanos(
+ (self.id.parse::<u64>().ok()? * 1_000_000).into()
+ ).ok()?;
+ let short_date = date.format(&DATE_FORMAT).ok()?;
+ let title = self.slug.replace("-", " ");
+ Some(format!("{} {}", short_date, title))
+ }
+}
+
+fn read_archive(archive_directory: &PathBuf) -> Vec<ArchiveEntry> {
+ let mut archive_entries = Vec::new();
+ if let Ok(entries) = read_dir(&archive_directory) {
+ for entry in entries.filter_map(Result::ok) {
+ let entry_path = entry.path();
+ let post_id = entry.file_name();
+ if let Ok(entry_type) = entry.file_type() {
+ if entry_type.is_dir() {
+ if let Ok(candidates) = read_dir(&entry_path) {
+ for candidate in candidates.filter_map(Result::ok) {
+ let candidate_path = candidate.path();
+ match candidate_path.extension() {
+ Some(extension) => {
+ if extension == "gmi" {
+ if let Some(slug) = candidate_path.file_stem() {
+ if let (Some(post_id), Some(slug)) = (post_id.to_str(), slug.to_str()) {
+ archive_entries.push(ArchiveEntry {
+ id: post_id.to_string(),
+ slug: slug.to_string()
+ })
+ }
+ }
+ }
+ },
+ _ => continue
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ archive_entries
+ .sort_by(|a, b| b.id.cmp(&a.id));
+ archive_entries
+}
+
+
+pub fn archive(archive_directory: &PathBuf, template_directory: &PathBuf, output_directory: &PathBuf) -> Result<()> {
+ let archivers = available_archivers();
+ let archive_entries = read_archive(archive_directory);
+ let context = ArchiveEntry::to_template_context(&archive_entries);
+ for archiver in archivers {
+ archiver(archive_directory, template_directory, output_directory, &context)?;
+ }
+ return Ok(())
+}
+
+fn available_archivers() -> Vec<fn(&PathBuf, &PathBuf, &PathBuf, &TemplateContext) -> Result<()>> {
+ vec![
+ raw::archive,
+ gemini::archive,
+ gopher::archive
+ ]
+}
--- /dev/null
+use std::io::Result;
+use std::path::PathBuf;
+use crate::template::TemplateContext;
+use crate::utils::recursively_copy;
+
+pub fn archive(archive_directory: &PathBuf, _: &PathBuf, target: &PathBuf, _: &TemplateContext) -> Result<()> {
+ if archive_directory.exists() {
+ return recursively_copy(archive_directory, target);
+ }
+ Ok(())
+}
use crate::constants::METADATA_FILENAME;
use crate::gemini_parser::parse;
use crate::generator::generate;
+use crate::archiver::archive;
use crate::metadata::Metadata;
use crate::post::Post;
fn read_posts(&self, posts_directory: &PathBuf, max_posts: u8) -> Vec<Post> {
let mut posts = Vec::new();
- for i in 0..max_posts - 1 {
+ for i in 0..max_posts {
let post_directory = posts_directory.join(i.to_string());
match self.read_post(&post_directory, i) {
Some(post) => posts.push(post),
let _ = remove_dir_all(&configuration.archive_output_directory);
create_dir_all(&configuration.archive_output_directory)?;
+ archive(
+ &configuration.archive_directory,
+ &configuration.templates_directory,
+ &configuration.archive_output_directory
+ )?;
return Ok(())
}
use std::io::Result;
use crate::configuration::Configuration;
+use std::process::{Command, Stdio};
+
+const COMMAND: &str = "rsync";
pub struct Publish;
vec![]
}
- fn execute(&self, input: Option<&String>, _: &Configuration, _: &String) -> Result<()> {
- println!("Publish: {:?}!", input);
+ fn execute(&self, input: Option<&String>, configuration: &Configuration, _: &String) -> Result<()> {
+
+ let input = input.expect("You must provide a location to publish the blog");
+
+ Command::new(COMMAND)
+ .arg("--version")
+ .stdout(Stdio::null())
+ .stderr(Stdio::null())
+ .status()
+ .expect("Publishing requires rsync");
+
+
+ Command::new(COMMAND)
+ .arg("-r")
+ .arg(format!("{}/", &configuration.blog_output_directory.display()))
+ .arg(input.as_str())
+ .stdout(Stdio::null())
+ .stderr(Stdio::null())
+ .status()
+ .expect("Publishing requires rsync");
return Ok(())
}
use std::io::Result;
use crate::configuration::Configuration;
+use std::process::{Command, Stdio};
+
+const COMMAND: &str = "rsync";
pub struct PublishArchive;
vec![]
}
- fn execute(&self, input: Option<&String>, _: &Configuration, _: &String) -> Result<()> {
- println!("Publish Archive: {:?}!", input);
+ fn execute(&self, input: Option<&String>, configuration: &Configuration, _: &String) -> Result<()> {
+
+ let input = input.expect("You must provide a location to publish the archive");
+
+ Command::new(COMMAND)
+ .arg("--version")
+ .stdout(Stdio::null())
+ .stderr(Stdio::null())
+ .status()
+ .expect("Publishing requires rsync");
+
+
+ Command::new(COMMAND)
+ .arg("-r")
+ .arg(format!("{}/", &configuration.archive_output_directory.display()))
+ .arg(input.as_str())
+ .stdout(Stdio::null())
+ .stderr(Stdio::null())
+ .status()
+ .expect("Publishing requires rsync");
return Ok(())
}
-use std::fs::{copy, create_dir_all, read_dir};
use std::io::Result;
use std::path::PathBuf;
use crate::template::TemplateContext;
-
-fn recursively_copy(source: &PathBuf, target: &PathBuf) -> Result<()> {
- let entries = read_dir(source)?;
- for entry in entries {
- let entry = entry?;
- let entry_type = entry.file_type()?;
- let entry_name = entry.file_name();
- let entry_source = entry.path();
- let entry_target = target.join(entry_name);
-
- if entry_type.is_dir() {
- create_dir_all(&entry_target)?;
- recursively_copy(&entry_source, &entry_target)?;
- } else {
- copy(&entry_source, &entry_target)?;
- }
- }
-
- Ok(())
-}
+use crate::utils::recursively_copy;
pub fn generate(source: &PathBuf, _: &PathBuf, target: &PathBuf, _: &TemplateContext) -> Result<()> {
if source.exists() {
mod constants;
mod gemini_parser;
mod generator;
+mod archiver;
mod metadata;
mod post;
mod template;
+mod utils;
use std::iter::once;
use std::env::args;
--- /dev/null
+use std::io::Result;
+use std::path::PathBuf;
+use std::fs::{copy, create_dir_all, read_dir};
+
+pub fn recursively_copy(source: &PathBuf, target: &PathBuf) -> Result<()> {
+ let entries = read_dir(source)?;
+ for entry in entries {
+ let entry = entry?;
+ let entry_type = entry.file_type()?;
+ let entry_name = entry.file_name();
+ let entry_source = entry.path();
+ let entry_target = target.join(entry_name);
+
+ if entry_type.is_dir() {
+ create_dir_all(&entry_target)?;
+ recursively_copy(&entry_source, &entry_target)?;
+ } else {
+ copy(&entry_source, &entry_target)?;
+ }
+ }
+
+ Ok(())
+}
# Gemlog Archive
-{{= posts }}
+{{~ posts: post}}
+=> ./{{= post.id }}/{{= post.slug }}.gmi {{= post.title}} {{~}}
--- /dev/null
+Gemlog Archive
+
+{{~ posts: post}}
+[0|{{= post.title}}|./{{= post.id }}/{{= post.slug }}.gmi|server|port] {{~}}