176 lines
6.1 KiB
Rust
176 lines
6.1 KiB
Rust
use chrono::{DateTime, NaiveDateTime};
|
|
use html5ever::tendril::SliceExt;
|
|
use nipper::{Document, Node, Selection};
|
|
use rayon::prelude::*;
|
|
use regex::Regex;
|
|
use serde::Deserialize;
|
|
use std::borrow::{Borrow, Cow};
|
|
use std::env::current_dir;
|
|
use std::fs;
|
|
use std::fs::{read_to_string, File};
|
|
use std::io::ErrorKind::NotFound;
|
|
use std::io::{Error, Write};
|
|
use std::path::PathBuf;
|
|
|
|
extern crate markdown;
|
|
|
|
fn main() -> Result<(), Error> {
|
|
let schema_version = 1;
|
|
println!("Looking for a typeset.toml file...");
|
|
let cwd = current_dir()?;
|
|
let config_file = cwd.join("typeset.toml");
|
|
if !config_file.exists() {
|
|
eprintln!("typeset.toml not found!");
|
|
return Err(Error::from(NotFound));
|
|
}
|
|
let config: Config = toml::from_str(&*read_to_string(config_file.clone())?)?;
|
|
if schema_version != config.schema_version {
|
|
panic!("Schema version does not match this version of Typeset! Please update Typeset.")
|
|
}
|
|
let template_file = config_file.with_file_name(config.template);
|
|
let index_file = config_file.with_file_name(config.index);
|
|
let out_path = cwd.join(PathBuf::from(config.output));
|
|
if !template_file.exists() {
|
|
eprintln!("template does not exist!");
|
|
return Err(Error::from(NotFound));
|
|
}
|
|
if !index_file.exists() {
|
|
println!("Index not found, assuming it is not present")
|
|
}
|
|
println!("Read configuration successfully! Converting markdown files to html...");
|
|
|
|
let mut posts: Vec<Post> = vec![];
|
|
let input_files: Vec<PathBuf> = fs::read_dir(cwd)?
|
|
.filter(|file| {
|
|
let file = file.as_ref().unwrap();
|
|
Regex::new(&*config.input)
|
|
.expect("invalid input regex!")
|
|
.is_match(file.file_name().to_str().unwrap())
|
|
})
|
|
.map(|file| file.unwrap().path())
|
|
.collect();
|
|
println!("Found {} files matching the pattern", input_files.len());
|
|
posts.par_extend(input_files.par_iter().map(|file| {
|
|
let content = read_to_string(file).unwrap();
|
|
let content = content.splitn(2, "\n\n").collect::<Vec<&str>>();
|
|
let settings: PostSettings = toml::from_str(content[0]).unwrap();
|
|
let body = markdown::to_html(content[1]);
|
|
Post {
|
|
id: file.file_stem().unwrap().to_str().unwrap().to_string(),
|
|
body,
|
|
title: settings.title,
|
|
published: NaiveDateTime::parse_from_str(&*settings.published, &*config.time_format)
|
|
.unwrap(),
|
|
}
|
|
}));
|
|
println!("Successfully converted to HTML! Creating documents...");
|
|
let template = read_to_string(template_file)?;
|
|
let index = Document::from(read_to_string(index_file)?.as_str());
|
|
for post in &posts {
|
|
let template_html = Document::from(template.as_str());
|
|
let mut output_html = template_html;
|
|
let mut typeset_elements = output_html.select("meta[typeset]");
|
|
for mut element in typeset_elements.iter() {
|
|
match element.attr("typeset").unwrap().to_string().as_str() {
|
|
"page-title" => {
|
|
let title = element
|
|
.attr("content")
|
|
.unwrap()
|
|
.replace("$", post.title.as_str());
|
|
|
|
element.replace_with_html(format!(r#"<title>{}</title>"#, title));
|
|
}
|
|
"title" => {
|
|
element.replace_with_html(post.title.to_string());
|
|
}
|
|
"body" => {
|
|
element.replace_with_html(post.body.to_string());
|
|
}
|
|
"date" => element
|
|
.replace_with_html(post.published.format(&*config.time_format).to_string()),
|
|
_ => {
|
|
eprintln!("Unknown meta typeset element parsed!")
|
|
}
|
|
}
|
|
}
|
|
let output = output_html.html().to_string();
|
|
let path = out_path.join(PathBuf::from(format!("{}{}", &post.id, ".html")));
|
|
let mut file = File::create(path)?;
|
|
file.write_all(output.as_bytes())?;
|
|
}
|
|
println!("Writing index...");
|
|
posts.par_sort_by(|a, b| b.published.cmp(&a.published));
|
|
println!(
|
|
"Found {} post lists",
|
|
index.select(r#"meta[typeset="index-entry""#).length()
|
|
);
|
|
for mut index_ref in index.select(r#"meta[typeset="index-entry""#).iter() {
|
|
let n = index_ref
|
|
.attr("content")
|
|
.unwrap_or("".to_tendril())
|
|
.parse()
|
|
.unwrap_or(0);
|
|
let parent = nth_parent(index_ref.clone(), n);
|
|
let parent_html = parent.html();
|
|
for post in posts.iter() {
|
|
let html = parent_html.to_string();
|
|
|
|
parent.parent().append_html(html);
|
|
nth_children(parent.parent(), n)
|
|
.select(r#"meta[typeset="index-entry""#)
|
|
.replace_with_html(
|
|
format!(
|
|
"<a href=\"./{}.html\">{}</a>\n",
|
|
post.id, post.title
|
|
)
|
|
.as_str(),
|
|
);
|
|
}
|
|
parent.parent().children().iter().nth(0).unwrap().remove();
|
|
}
|
|
|
|
let output = index.html().to_string();
|
|
let path = out_path.join(PathBuf::from("index.html"));
|
|
let mut file = File::create(path)?;
|
|
file.write_all(output.as_bytes())?;
|
|
println!("Have a nice day :)");
|
|
Ok(())
|
|
}
|
|
#[derive(Debug, Clone, Eq, Ord, PartialEq, PartialOrd)]
|
|
struct Post {
|
|
id: String,
|
|
body: String,
|
|
title: String,
|
|
published: NaiveDateTime,
|
|
}
|
|
#[derive(Deserialize, Debug)]
|
|
struct PostSettings {
|
|
title: String,
|
|
published: String,
|
|
}
|
|
#[derive(Deserialize, Debug, Clone)]
|
|
pub struct Config {
|
|
pub schema_version: i32,
|
|
pub name: String,
|
|
pub index: String,
|
|
pub template: String,
|
|
pub ref_from_index: String,
|
|
pub input: String,
|
|
pub output: String,
|
|
pub time_format: String,
|
|
}
|
|
fn nth_parent(selection: Selection, n: usize) -> Selection {
|
|
let mut sel: Selection = selection;
|
|
for _ in 0..n {
|
|
sel = sel.parent();
|
|
}
|
|
return sel;
|
|
}
|
|
fn nth_children(selection: Selection, n: usize) -> Selection {
|
|
let mut sel: Selection = selection;
|
|
for _ in 0..n {
|
|
sel = sel.children();
|
|
}
|
|
return sel;
|
|
}
|