use chrono::NaiveDate;
use pulldown_cmark::{html, Parser};
use regex::Regex;
use std::fs;
use std::path;
use config::Config;
#[derive(Debug, PartialEq)]
pub enum EntryKind {
Page,
Post,
}
#[derive(Debug)]
pub struct Entry {
pub kind: EntryKind,
pub title: String,
pub slug: String,
pub body: String,
pub date: Option,
}
impl Entry {
pub fn render(&self, template: &str, config: &Config) -> String {
let parser = Parser::new(&self.body);
let mut html_buf = String::new();
html::push_html(&mut html_buf, parser);
let formatted_date = match self.date {
Some(date) => date.format("%Y-%m-%d").to_string(),
None => String::from(""),
};
template
.replace(
"{{ page_title }}",
&format!("{} | {}", &self.title, &config.site_name),
)
.replace("{{ title }}", &self.title)
.replace("{{ slug }}", &self.slug)
.replace("{{ body }}", &html_buf.to_string())
.replace("{{ date }}", &formatted_date)
}
}
pub fn read_entry_dir(cwd: &path::Path) -> Vec {
match fs::read_dir(cwd) {
Ok(entries) => entries.into_iter().map(|entry| entry.unwrap()).collect(),
Err(err) => panic!(err),
}
}
pub fn parse_entry(kind: EntryKind, contents: &str, path: &path::Path) -> Entry {
lazy_static! {
static ref RE_WITH_DATE: Regex =
Regex::new(r"^# (?P.*) \| (?P<date>\d{4}-\d{2}-\d{2})\n\n(?s)(?P<body>.*)")
.unwrap();
static ref RE_WITHOUT_DATE: Regex =
Regex::new(r"^# (?P<title>.*)\n\n(?s)(?P<body>.*)").unwrap();
static ref SLUG_RE: Regex = Regex::new(r"(?P<slug>\S+).md").unwrap();
}
let filename = &path.file_name().unwrap().to_str().unwrap();
let slug = SLUG_RE
.captures(filename)
.expect("Couldn't parse slug from filename")["slug"]
.to_string();
if kind == EntryKind::Post {
let captures = &RE_WITH_DATE
.captures(&contents)
.expect("Couldn't parse post");
let title = captures["title"].to_string();
let body = captures["body"].to_string();
let date = Some(
NaiveDate::parse_from_str(&captures["date"], "%Y-%m-%d").expect("Couldn't parse date"),
);
Entry {
kind,
title,
body,
slug,
date,
}
} else {
let captures = &RE_WITHOUT_DATE
.captures(&contents)
.expect("Couldn't parse page");
let title = captures["title"].to_string();
let body = captures["body"].to_string();
Entry {
kind,
title,
body,
slug,
date: None,
}
}
}
pub fn write_entry(
cwd: &path::Path,
layout: &str,
post_template: &str,
entry: &Entry,
config: &Config,
) {
let root_path = match entry.kind {
EntryKind::Post => cwd.join("public").join("posts").join(&entry.slug),
EntryKind::Page => cwd.join("public").join(&entry.slug),
};
match fs::create_dir(&root_path) {
Ok(_) => {}
Err(err) => match err.kind() {
std::io::ErrorKind::AlreadyExists => {}
_ => panic!(err),
},
}
let template = layout.replace("{{ contents }}", &post_template);
fs::write(
&root_path.join("index.html"),
entry.render(&template, &config),
)
.expect("Unable to write file");
}
pub fn write_entry_listing(
cwd: &path::Path,
layout: &str,
post_listing_template: &str,
post_item_template: &str,
posts: &Vec<Entry>,
config: &Config,
) {
fs::write(
cwd.join("public").join("index.html"),
render_post_listing(
layout,
post_listing_template,
post_item_template,
posts,
config,
),
)
.expect("Unable to write file");
}
pub fn render_post_listing(
layout: &str,
post_listing_template: &str,
post_item_template: &str,
posts: &Vec<Entry>,
config: &Config,
) -> String {
layout
.replace("{{ page_title }}", &format!("{}", config.site_name))
.replace(
"{{ contents }}",
&post_listing_template.replace(
"{{ post_listing }}",
&posts
.iter()
.map(|post| post.render(&post_item_template, &config))
.collect::<Vec<String>>()
.join("\n"),
),
)
}
#[cfg(test)]
mod tests {
use chrono::NaiveDate;
use uuid::Uuid;
use std::{env, fs, path};
use super::*;
#[test]
fn test_render_post() {
let config = Config {
site_name: String::from("Test Site"),
url: String::from("testsite.com"),
description: String::from("recent posts from testsite.com"),
};
let post = Entry {
title: String::from("hello world"),
body: String::from("lorem ipsum dolor sit amet"),
slug: String::from("hello-world"),
date: Some(NaiveDate::from_ymd(2019, 1, 1)),
kind: EntryKind::Post,
};
let output = post.render(
"<html><head><title>{{ page_title }}{{ title }}
{{ body }}