kamov/website
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

refactor

Browse source
This commit is contained in:
Maciej Jur 2024-07-05 13:59:07 +02:00
parent 46705d707f
commit fc01a1ed2a
Signed by: kamov
GPG key ID: 191CBFF5F72ECAFD
14 changed files with 1399 additions and 1316 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
rustfmt.toml Normal file
View file

@ -0,0 +1,2 @@
tab_spaces = 4
hard_tabs = true

39
src/html/home.rs
View file

@ -1,6 +1,6 @@
use hypertext::{html_elements, maud, maud_move, GlobalAttributes, Raw, Renderable};
use crate::text::md::parse;
use crate::{pipeline::Sack, text::md::parse};
const INTRO: &str = r#"
## かもし
@ -15,7 +15,7 @@ const INTRO: &str = r#"
"#;
fn intro() -> impl Renderable {
let (_, html, _) = parse(INTRO, None);
let (_, html, _) = parse(INTRO.into(), None);
maud!(
section .p-card.intro-jp lang="ja-JP" {
(Raw(html))
@ -23,18 +23,18 @@ fn intro() -> impl Renderable {
)
}
fn kanji() -> impl Renderable {
maud!(
section .p-card {
h2 .p-card__heading {
"Kanji of the Day"
}
div {
// <Widget client:load/>
}
}
)
}
// fn kanji() -> impl Renderable {
// maud!(
// section .p-card {
// h2 .p-card__heading {
// "Kanji of the Day"
// }
// div {
// // <Widget client:load/>
// }
// }
// )
// }
fn photo() -> impl Renderable {
maud!(
@ -51,10 +51,13 @@ fn photo() -> impl Renderable {
)
}
pub fn home<'data, 'home, R>(main: R) -> impl Renderable + 'home
pub(crate) fn home<'s, 'p, 'html>(
sack: &'s Sack,
main: impl Renderable + 'p,
) -> impl Renderable + 'html
where
'data: 'home,
R: Renderable + 'data,
's: 'html,
'p: 'html,
{
let main = maud_move!(
main .l-home {
@ -69,5 +72,5 @@ where
}
);
crate::html::page("Home", main, None)
crate::html::page(sack, main, "Home".into())
}

24
src/html/list.rs
View file

@ -1,20 +1,24 @@
use crate::{html::page, LinkDate};
use camino::Utf8PathBuf;
use chrono::{DateTime, Utc};
use hypertext::{html_elements, maud_move, GlobalAttributes, Renderable};
pub fn list<'data, 'list>(
title: &'data str,
groups: &'data [(i32, Vec<LinkDate>)],
) -> impl Renderable + 'list
use crate::html::page;
use crate::pipeline::Sack;
use crate::LinkDate;
pub fn list<'s, 'g, 'html>(
sack: &'s Sack,
groups: &'g [(i32, Vec<LinkDate>)],
title: String,
) -> impl Renderable + 'html
where
'data: 'list,
's: 'html,
'g: 'html,
{
let heading = title.clone();
let list = maud_move!(
main .page-list-main {
article .page-list {
header .markdown {
h1 { (title) }
h1 { (heading) }
}
@for (year, group) in groups {
@ -24,7 +28,7 @@ where
}
);
page(title, list, None)
page(sack, list, title)
}
fn section(year: i32, group: &[LinkDate]) -> impl Renderable + '_ {

1
src/html/misc.rs
View file

@ -3,7 +3,6 @@ use hypertext::{html_elements, maud_move, GlobalAttributes, Raw, Renderable};
use crate::pipeline::{Sack, TreePage};
use crate::text::md::Outline;
/// Render the outline for a document
pub(crate) fn show_outline(outline: Outline) -> impl Renderable {
maud_move!(

79
src/html/mod.rs
View file

@ -13,13 +13,13 @@ use camino::Utf8Path;
use chrono::Datelike;
use hypertext::{html_elements, maud, maud_move, GlobalAttributes, Raw, Renderable};
use crate::REPO;
pub(crate) use home::home;
pub(crate) use post::Post;
pub(crate) use slideshow::Slideshow;
pub(crate) use wiki::Wiki;
use crate::{pipeline::Sack, Mode};
const JS_RELOAD: &str = r#"
const socket = new WebSocket("ws://localhost:1337");
socket.addEventListener("message", (event) => {
@ -37,7 +37,10 @@ const JS_IMPORTS: &str = r#"
}
"#;
fn head(title: &str) -> impl Renderable + '_ {
fn head<'s, 'html>(sack: &'s Sack, title: String) -> impl Renderable + 'html
where
's: 'html,
{
let title = format!("{} | kamoshi.org", title);
maud_move!(
@ -60,7 +63,9 @@ fn head(title: &str) -> impl Renderable + '_ {
script type="importmap" {(Raw(JS_IMPORTS))}
@if matches!(sack.ctx.mode, Mode::Watch) {
script { (Raw(JS_RELOAD)) }
}
)
}
@ -109,14 +114,17 @@ fn navbar() -> impl Renderable {
)
}
pub fn footer(path: Option<&Utf8Path>) -> impl Renderable {
let copy = format!("Copyright &copy; {} Maciej Jur", &REPO.year);
pub fn footer<'s, 'html>(sack: &'s Sack) -> impl Renderable + 'html
where
's: 'html,
{
let copy = format!("Copyright &copy; {} Maciej Jur", &sack.ctx.year);
let mail = "maciej@kamoshi.org";
let href = format!("mailto:{}", mail);
let link = Utf8Path::new(&REPO.link)
let link = Utf8Path::new(&sack.ctx.link)
.join("src/commit")
.join(&REPO.hash);
let link = match path {
.join(&sack.ctx.hash);
let link = match sack.get_file() {
Some(path) => link.join(path),
None => link,
};
@ -133,10 +141,10 @@ pub fn footer(path: Option<&Utf8Path>) -> impl Renderable {
}
div .repo {
a href=(link.as_str()) {
(&REPO.hash)
(&sack.ctx.hash)
}
div {
(&REPO.date)
(&sack.ctx.date)
}
}
a .right.footer__cc-wrap rel="license" href="http://creativecommons.org/licenses/by/4.0/" {
@ -146,15 +154,19 @@ pub fn footer(path: Option<&Utf8Path>) -> impl Renderable {
)
}
fn bare<'data, 'html, R>(title: &'data str, main: R) -> impl Renderable + 'html
fn bare<'s, 'p, 'html>(
sack: &'s Sack,
main: impl Renderable + 'p,
title: String,
) -> impl Renderable + 'html
where
'data : 'html,
R: Renderable + 'data
's: 'html,
'p: 'html,
{
maud_move!(
(Raw("<!DOCTYPE html>"))
html lang="en" {
(head(title))
(head(sack, title))
body {
(main)
@ -163,31 +175,30 @@ fn bare<'data, 'html, R>(title: &'data str, main: R) -> impl Renderable + 'html
)
}
fn page<'data, 'main, 'html, T>(
title: &'data str,
main: T,
path: Option<&'data Utf8Path>,
fn page<'s, 'p, 'html>(
sack: &'s Sack,
main: impl Renderable + 'p,
title: String,
) -> impl Renderable + 'html
where
'main : 'html,
'data : 'html,
T: Renderable + 'main
's: 'html,
'p: 'html,
{
maud_move!(
(Raw("<!DOCTYPE html>"))
html lang="en" {
(head(title))
(head(sack, title))
body {
(navbar())
(main)
(footer(path))
(footer(sack))
}
}
)
}
pub(crate) fn to_list(list: Vec<crate::LinkDate>) -> String {
pub(crate) fn to_list(sack: &Sack, list: Vec<crate::LinkDate>, title: String) -> String {
let mut groups = HashMap::<i32, Vec<_>>::new();
for page in list {
@ -204,12 +215,15 @@ pub(crate) fn to_list(list: Vec<crate::LinkDate>) -> String {
groups.sort_by(|a, b| b.0.cmp(&a.0));
list::list("", &groups).render().into()
list::list(sack, &groups, title).render().into()
}
pub(crate) fn map() -> impl Renderable {
pub(crate) fn map<'s, 'html>(sack: &'s Sack) -> impl Renderable + 'html
where
's: 'html,
{
page(
"Map",
sack,
maud!(
main {
div #map style="height: 100%; width: 100%" {}
@ -219,17 +233,20 @@ pub(crate) fn map() -> impl Renderable {
}
}
),
None,
String::from("Map"),
)
}
pub(crate) fn search() -> impl Renderable {
pub(crate) fn search<'s, 'html>(sack: &'s Sack) -> impl Renderable + 'html
where
's: 'html,
{
page(
"Search",
sack,
maud!(
main #app {}
script type="module" src="/js/search/dist/search.js" {}
),
None,
String::from("Search"),
)
}

35
src/html/post.rs
View file

@ -6,7 +6,7 @@ use serde::Deserialize;
use crate::pipeline::{Content, Sack};
use crate::text::md::Outline;
use crate::{Linkable, LinkDate};
use crate::{LinkDate, Linkable};
/// Represents a simple post.
#[derive(Deserialize, Debug, Clone)]
@ -18,24 +18,22 @@ pub(crate) struct Post {
}
impl Content for Post {
fn parse(data: &str, lib: Option<&Library>) -> (Outline, String, Option<Vec<String>>) {
fn parse(data: String, lib: Option<&Library>) -> (Outline, String, Option<Vec<String>>) {
crate::text::md::parse(data, lib)
}
fn transform<'f, 'm, 's, 'html, T>(
&'f self,
content: T,
outline: Outline,
fn render<'s, 'p, 'html>(
self,
sack: &'s Sack,
parsed: impl Renderable + 'p,
outline: Outline,
bib: Option<Vec<String>>,
) -> impl Renderable + 'html
where
'f: 'html,
'm: 'html,
's: 'html,
T: Renderable + 'm,
'p: 'html,
{
post(self, content, outline, bib, sack)
post(self, sack, parsed, outline, bib)
}
fn as_link(&self, path: Utf8PathBuf) -> Option<Linkable> {
@ -50,19 +48,18 @@ impl Content for Post {
}
}
pub fn post<'f, 'm, 's, 'html, T>(
fm: &'f Post,
content: T,
pub fn post<'s, 'p, 'html>(
fm: Post,
sack: &'s Sack,
content: impl Renderable + 'p,
outline: Outline,
bib: Option<Vec<String>>,
sack: &'s Sack,
) -> impl Renderable + 'html
where
'f: 'html,
'm: 'html,
's: 'html,
T: Renderable + 'm
'p: 'html,
{
let heading = fm.title.clone();
let main = maud_move!(
main .wiki-main {
@ -79,7 +76,7 @@ pub fn post<'f, 'm, 's, 'html, T>(
article .wiki-article /*class:list={classlist)*/ {
header class="markdown" {
h1 #top { (fm.title.clone()) }
h1 #top { (heading) }
}
section .wiki-article__markdown.markdown {
(content)
@ -92,5 +89,5 @@ pub fn post<'f, 'm, 's, 'html, T>(
}
);
crate::html::page(&fm.title, main, sack.get_file())
crate::html::page(sack, main, fm.title.clone())
}

90
src/html/slideshow.rs
View file

@ -1,13 +1,20 @@
use camino::Utf8PathBuf;
use chrono::{DateTime, Utc};
use hayagriva::Library;
use hypertext::{html_elements, maud_move, Renderable, GlobalAttributes, Raw};
use hypertext::{html_elements, maud_move, GlobalAttributes, Raw, Renderable};
use serde::Deserialize;
use crate::pipeline::{Content, Sack};
use crate::text::md::Outline;
use crate::{Link, LinkDate, Linkable};
const CSS: &str = r#"
.slides img {
margin-left: auto;
margin-right: auto;
max-height: 60vh;
}
"#;
/// Represents a slideshow
#[derive(Deserialize, Debug, Clone)]
@ -19,19 +26,42 @@ pub(crate) struct Slideshow {
}
impl Content for Slideshow {
fn transform<'f, 'm, 's, 'html, T>(
&'f self,
content: T,
fn parse(data: String, _: Option<&Library>) -> (Outline, String, Option<Vec<String>>) {
let html = data
.split("\n-----\n")
.map(|chunk| {
chunk
.split("\n---\n")
.map(|s| crate::text::md::parse(s.to_owned(), None))
.map(|e| e.1)
.collect::<Vec<_>>()
})
.map(|stack| match stack.len() > 1 {
true => format!(
"<section>{}</section>",
stack
.into_iter()
.map(|slide| format!("<section>{slide}</section>"))
.collect::<String>()
),
false => format!("<section>{}</section>", stack[0]),
})
.collect::<String>();
(Outline(vec![]), html, None)
}
fn render<'s, 'p, 'html>(
self,
sack: &'s Sack,
parsed: impl Renderable + 'p,
_: Outline,
_: &'s Sack,
_bib: Option<Vec<String>>,
_: Option<Vec<String>>,
) -> impl Renderable + 'html
where
'f: 'html,
'm: 'html,
's: 'html,
T: Renderable + 'm {
show(self, content)
'p: 'html,
{
show(self, sack, parsed)
}
fn as_link(&self, path: Utf8PathBuf) -> Option<Linkable> {
@ -44,28 +74,20 @@ impl Content for Slideshow {
date: self.date.to_owned(),
}))
}
fn parse(data: &str, _: Option<&Library>) -> (Outline, String, Option<Vec<String>>) {
let html = data
.split("\n-----\n")
.map(|chunk| chunk.split("\n---\n").map(|s| crate::text::md::parse(s, None)).map(|e| e.1).collect::<Vec<_>>())
.map(|stack| match stack.len() > 1 {
true => format!("<section>{}</section>", stack.into_iter().map(|slide| format!("<section>{slide}</section>")).collect::<String>()),
false => format!("<section>{}</section>", stack[0])
})
.collect::<String>();
(Outline(vec![]), html, None)
}
}
pub fn show<'data, 'show>(
fm: &'data Slideshow,
slides: impl Renderable + 'data
) -> impl Renderable + 'show
pub fn show<'s, 'p, 'html>(
fm: Slideshow,
sack: &'s Sack,
slides: impl Renderable + 'p,
) -> impl Renderable + 'html
where
'data: 'show
's: 'html,
'p: 'html,
{
crate::html::bare(&fm.title, maud_move!(
crate::html::bare(
sack,
maud_move!(
div .reveal {
div .slides {
(slides)
@ -76,12 +98,8 @@ pub fn show<'data, 'show>(
(Raw("import 'reveal';"))
}
style {r#"
.slides img {
margin-left: auto;
margin-right: auto;
max-height: 60vh;
}
"#}
))
style { (Raw(CSS)) }
),
fm.title.clone(),
)
}

43
src/html/wiki.rs
View file

@ -14,19 +14,22 @@ pub struct Wiki {
}
impl Content for Wiki {
fn transform<'f, 'm, 's, 'html, T>(
&'f self,
content: T,
outline: Outline,
fn parse(data: String, lib: Option<&Library>) -> (Outline, String, Option<Vec<String>>) {
crate::text::md::parse(data, lib)
}
fn render<'s, 'p, 'html>(
self,
sack: &'s Sack,
parsed: impl Renderable + 'p,
outline: Outline,
bib: Option<Vec<String>>,
) -> impl Renderable + 'html
where
'f: 'html,
'm: 'html,
's: 'html,
T: Renderable + 'm {
wiki(self, content, outline, sack, bib)
'p: 'html,
{
wiki(self, sack, parsed, outline, bib)
}
fn as_link(&self, path: Utf8PathBuf) -> Option<Linkable> {
@ -36,24 +39,20 @@ impl Content for Wiki {
desc: None,
}))
}
fn parse(data: &str, lib: Option<&Library>) -> (Outline, String, Option<Vec<String>>) {
crate::text::md::parse(data, lib)
}
}
fn wiki<'data, 'html, 'sack, T>(
fm: &'data Wiki,
content: T,
fn wiki<'s, 'p, 'html>(
matter: Wiki,
sack: &'s Sack,
parsed: impl Renderable + 'p,
_: Outline,
sack: &'sack Sack,
bib: Option<Vec<String>>,
) -> impl Renderable + 'html
where
'sack: 'html,
'data: 'html,
T: Renderable + 'data
's: 'html,
'p: 'html,
{
let heading = matter.title.clone();
let main = maud_move!(
main .wiki-main {
@ -75,10 +74,10 @@ fn wiki<'data, 'html, 'sack, T>(
article .wiki-article /*class:list={classlist)*/ {
header class="markdown" {
h1 #top { (fm.title.clone()) }
h1 #top { (heading) }
}
section .wiki-article__markdown.markdown {
(content)
(parsed)
}
@if let Some(bib) = bib {
@ -88,5 +87,5 @@ fn wiki<'data, 'html, 'sack, T>(
}
);
crate::html::page(&fm.title, main, sack.get_file())
crate::html::page(sack, main, matter.title.to_owned())
}

323
src/main.rs
View file

@ -1,25 +1,26 @@
mod build;
mod html;
mod md;
mod pipeline;
mod text;
mod ts;
mod utils;
mod watch;
use std::collections::HashSet;
use std::fs;
use std::process::Command;
use camino::{Utf8Path, Utf8PathBuf};
use chrono::{DateTime, Datelike, Utc};
use clap::{Parser, ValueEnum};
use pipeline::{Asset, AssetKind, Content, FileItemKind, Output, PipelineItem, Sack};
use gray_matter::engine::YAML;
use gray_matter::Matter;
use hypertext::{Raw, Renderable};
use once_cell::sync::Lazy;
use pipeline::{Asset, AssetKind, Content, FileItemKind, Output, PipelineItem};
use serde::Deserialize;
use crate::pipeline::Virtual;
use crate::build::build_styles;
use crate::pipeline::Virtual;
#[derive(Parser, Debug, Clone)]
struct Args {
@ -34,35 +35,14 @@ enum Mode {
}
#[derive(Debug)]
struct BuildInfo {
struct BuildContext {
pub mode: Mode,
pub year: i32,
pub date: String,
pub link: String,
pub hash: String,
}
static REPO: Lazy<BuildInfo> = Lazy::new(|| {
let time = chrono::Utc::now();
BuildInfo {
year: time.year(),
date: time.format("%Y/%m/%d %H:%M").to_string(),
link: "https://git.kamoshi.org/kamov/website".into(),
hash: String::from_utf8(
Command::new("git")
.args(["rev-parse", "--short", "HEAD"])
.output()
.unwrap()
.stdout
)
.unwrap()
.trim()
.into()
}
});
#[derive(Debug, Clone)]
pub struct Link {
pub path: Utf8PathBuf,
@ -82,88 +62,54 @@ pub enum Linkable {
Date(LinkDate),
}
fn main() {
let args = Args::parse();
let time = chrono::Utc::now();
fn to_index<T>(item: PipelineItem) -> PipelineItem
where
T: for<'de> Deserialize<'de> + Content + 'static,
{
let meta = match item {
PipelineItem::Skip(meta) if matches!(meta.kind, FileItemKind::Index) => meta,
_ => return item,
let ctx = BuildContext {
mode: args.mode,
year: time.year(),
date: time.format("%Y/%m/%d %H:%M").to_string(),
link: "https://git.kamoshi.org/kamov/website".into(),
hash: String::from_utf8(
Command::new("git")
.args(["rev-parse", "--short", "HEAD"])
.output()
.expect("Couldn't load git revision")
.stdout,
)
.expect("Invalid UTF8")
.trim()
.into(),
};
let dir = meta.path.parent().unwrap().strip_prefix("content").unwrap();
let dir = match meta.path.file_stem().unwrap() {
"index" => dir.to_owned(),
name => dir.join(name),
};
let path = dir.join("index.html");
match meta.path.extension() {
Some("md" | "mdx" | "lhs") => {
let data = fs::read_to_string(&meta.path).unwrap();
let (fm, md) = md::preflight::<T>(&data);
let link = T::as_link(&fm, Utf8Path::new("/").join(dir));
let call = move |sack: &Sack| {
let lib = sack.get_library();
let (outline, html, bib) = T::parse(&md, lib);
T::transform(&fm, Raw(html), outline, sack, bib).render().into()
};
Output {
kind: Asset {
kind: pipeline::AssetKind::Html(Box::new(call)),
meta,
}.into(),
path,
link,
}.into()
},
_ => meta.into(),
match args.mode {
Mode::Build => {
build(&ctx);
}
Mode::Watch => {
build(&ctx);
watch::watch().unwrap()
}
}
}
fn to_bundle(item: PipelineItem) -> PipelineItem {
let meta = match item {
PipelineItem::Skip(meta) if matches!(meta.kind, FileItemKind::Bundle) => meta,
_ => return item,
};
struct Source {
path: &'static str,
exts: HashSet<&'static str>,
func: fn(PipelineItem) -> PipelineItem,
}
let path = meta.path.strip_prefix("content").unwrap().to_owned();
match meta.path.extension() {
// any image
Some("jpg" | "png" | "gif") => {
Output {
kind: Asset {
kind: AssetKind::Image,
meta,
}.into(),
path,
link: None,
}.into()
},
// bibliography
Some("bib") => {
let data = fs::read_to_string(&meta.path).unwrap();
let data = hayagriva::io::from_biblatex_str(&data).unwrap();
Output {
kind: Asset {
kind: AssetKind::Bibtex(data),
meta,
}.into(),
path,
link: None,
}.into()
},
_ => meta.into(),
impl Source {
fn get(&self) -> Vec<PipelineItem> {
pipeline::gather(self.path, &self.exts)
.into_iter()
.map(self.func)
.collect()
}
}
fn build() {
fn build(ctx: &BuildContext) {
if fs::metadata("dist").is_ok() {
println!("Cleaning dist");
fs::remove_dir_all("dist").unwrap();
@ -171,28 +117,38 @@ fn build() {
fs::create_dir("dist").unwrap();
let assets: Vec<Output> = [
pipeline::gather("content/about.md", &["md"].into())
.into_iter()
.map(to_index::<crate::html::Post> as fn(PipelineItem) -> PipelineItem),
pipeline::gather("content/posts/**/*", &["md", "mdx"].into())
.into_iter()
.map(to_index::<crate::html::Post>),
pipeline::gather("content/slides/**/*", &["md", "lhs"].into())
.into_iter()
.map(to_index::<crate::html::Slideshow>),
pipeline::gather("content/wiki/**/*", &["md"].into())
.into_iter()
.map(to_index::<crate::html::Wiki>),
]
.into_iter()
.flatten()
let sources = vec![
Source {
path: "content/about.md",
exts: ["md"].into(),
func: as_index::<crate::html::Post>,
},
Source {
path: "content/posts/**/*",
exts: ["md", "mdx"].into(),
func: as_index::<crate::html::Post>,
},
Source {
path: "content/slides/**/*",
exts: ["md", "lhs"].into(),
func: as_index::<crate::html::Slideshow>,
},
Source {
path: "content/wiki/**/*",
exts: ["md"].into(),
func: as_index::<crate::html::Wiki>,
},
];
let assets: Vec<Output> = sources
.iter()
.flat_map(Source::get)
.map(to_bundle)
.filter_map(|item| match item {
PipelineItem::Skip(skip) => {
println!("Skipping {}", skip.path);
None
},
}
PipelineItem::Take(take) => Some(take),
})
.collect();
@ -201,37 +157,48 @@ fn build() {
assets,
vec![
Output {
kind: Virtual::new(|_| crate::html::map().render().to_owned().into()).into(),
kind: Virtual::new(|sack| crate::html::map(sack).render().to_owned().into()).into(),
path: "map/index.html".into(),
link: None,
},
Output {
kind: Virtual::new(|_| crate::html::search().render().to_owned().into()).into(),
kind: Virtual::new(|sack| crate::html::search(sack).render().to_owned().into())
.into(),
path: "search/index.html".into(),
link: None,
},
Output {
kind: Asset {
kind: pipeline::AssetKind::Html(Box::new(|_| {
kind: pipeline::AssetKind::html(|sack| {
let data = std::fs::read_to_string("content/index.md").unwrap();
let (_, html, _) = text::md::parse(&data, None);
crate::html::home(Raw(html)).render().to_owned().into()
})),
let (_, html, _) = text::md::parse(data, None);
crate::html::home(sack, Raw(html))
.render()
.to_owned()
.into()
}),
meta: pipeline::FileItem {
kind: pipeline::FileItemKind::Index,
path: "content/index.md".into()
path: "content/index.md".into(),
},
}
}.into(),
.into(),
path: "index.html".into(),
link: None,
},
Output {
kind: Virtual::new(|sack| crate::html::to_list(sack.get_links("posts/**/*.html"))).into(),
kind: Virtual::new(|sack| {
crate::html::to_list(sack, sack.get_links("posts/**/*.html"), "Posts".into())
})
.into(),
path: "posts/index.html".into(),
link: None,
},
Output {
kind: Virtual::new(|sack| crate::html::to_list(sack.get_links("slides/**/*.html"))).into(),
kind: Virtual::new(|sack| {
crate::html::to_list(sack, sack.get_links("slides/**/*.html"), "Slideshows".into())
})
.into(),
path: "slides/index.html".into(),
link: None,
},
@ -243,7 +210,7 @@ fn build() {
{
let now = std::time::Instant::now();
pipeline::render_all(&assets);
pipeline::render_all(ctx, &assets);
println!("Elapsed: {:.2?}", now.elapsed());
}
@ -273,14 +240,100 @@ fn build() {
println!("{}", String::from_utf8(res.stderr).unwrap());
}
fn main() {
let args = Args::parse();
pub fn parse_frontmatter<T>(raw: &str) -> (T, String)
where
T: for<'de> Deserialize<'de>,
{
let matter = Matter::<YAML>::new();
let result = matter.parse(raw);
match args.mode {
Mode::Build => build(),
Mode::Watch => {
build();
watch::watch().unwrap()
},
(
// Just the front matter
result.data.unwrap().deserialize::<T>().unwrap(),
// The rest of the content
result.content,
)
}
fn as_index<T>(item: PipelineItem) -> PipelineItem
where
T: for<'de> Deserialize<'de> + Content + Clone + 'static,
{
let meta = match item {
PipelineItem::Skip(e) if matches!(e.kind, FileItemKind::Index) => e,
_ => return item,
};
let dir = meta.path.parent().unwrap().strip_prefix("content").unwrap();
let dir = match meta.path.file_stem().unwrap() {
"index" => dir.to_owned(),
name => dir.join(name),
};
let path = dir.join("index.html");
match meta.path.extension() {
Some("md" | "mdx" | "lhs") => {
let data = fs::read_to_string(&meta.path).unwrap();
let (fm, md) = parse_frontmatter::<T>(&data);
let link = T::as_link(&fm, Utf8Path::new("/").join(dir));
Output {
kind: Asset {
kind: pipeline::AssetKind::html(move |sack| {
let lib = sack.get_library();
let (outline, parsed, bib) = T::parse(md.clone(), lib);
T::render(fm.clone(), sack, Raw(parsed), outline, bib)
.render()
.into()
}),
meta,
}
.into(),
path,
link,
}
.into()
}
_ => meta.into(),
}
}
fn to_bundle(item: PipelineItem) -> PipelineItem {
let meta = match item {
PipelineItem::Skip(meta) if matches!(meta.kind, FileItemKind::Bundle) => meta,
_ => return item,
};
let path = meta.path.strip_prefix("content").unwrap().to_owned();
match meta.path.extension() {
// any image
Some("jpg" | "png" | "gif") => Output {
kind: Asset {
kind: AssetKind::Image,
meta,
}
.into(),
path,
link: None,
}
.into(),
// bibliography
Some("bib") => {
let data = fs::read_to_string(&meta.path).unwrap();
let data = hayagriva::io::from_biblatex_str(&data).unwrap();
Output {
kind: Asset {
kind: AssetKind::Bibtex(data),
meta,
}
.into(),
path,
link: None,
}
.into()
}
_ => meta.into(),
}
}

43
src/md/matter.rs
View file

@ -1,43 +0,0 @@
use gray_matter::{engine::YAML, Matter};
use serde::Deserialize;
pub fn preflight<T>(raw: &str) -> (T, String)
where
T: for<'de> Deserialize<'de>,
{
let matter = Matter::<YAML>::new();
let result = matter.parse(raw);
(
// Just the front matter
result.data.unwrap().deserialize::<T>().unwrap(),
// The actual markdown content
result.content,
)
}
mod isodate {
use chrono::{DateTime, Utc};
use serde::{self, Deserialize, Deserializer};
// pub fn serialize<S>(
// date: &DateTime<Utc>,
// serializer: S,
// ) -> Result<S::Ok, S::Error>
// where
// S: Serializer,
// {
// let s = date.to_rfc3339();
// serializer.serialize_str(&s)
// }
pub fn deserialize<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let dt = chrono::DateTime::parse_from_rfc3339(&s).map_err(serde::de::Error::custom)?;
Ok(dt.into())
}
}

3
src/md/mod.rs
View file

@ -1,3 +0,0 @@
mod matter;
pub use matter::preflight;

51
src/pipeline.rs
View file

@ -11,7 +11,7 @@ use hayagriva::Library;
use hypertext::Renderable;
use crate::text::md::Outline;
use crate::{Link, LinkDate, Linkable};
use crate::{BuildContext, Link, LinkDate, Linkable};
/// Represents a piece of content that can be rendered as a page. This trait needs to be
/// implemented for the front matter associated with some web page as that is what ultimately
@ -19,21 +19,23 @@ use crate::{Link, LinkDate, Linkable};
/// rendered page on the website.
pub(crate) trait Content {
/// Parse the document. Pass an optional library for bibliography.
fn parse(document: &str, library: Option<&Library>) -> (Outline, String, Option<Vec<String>>);
/// This generates the initial HTML markup from content.
fn parse(document: String, library: Option<&Library>)
-> (Outline, String, Option<Vec<String>>);
fn transform<'fm, 'md, 'sack, 'html, T>(
&'fm self,
content: T,
/// Render the full page from parsed content.
fn render<'s, 'p, 'html>(
self,
sack: &'s Sack,
parsed: impl Renderable + 'p,
outline: Outline,
sack: &'sack Sack,
bib: Option<Vec<String>>,
) -> impl Renderable + 'html
where
'fm: 'html,
'md: 'html,
'sack: 'html,
T: Renderable + 'md;
's: 'html,
'p: 'html;
/// Get link for this content
fn as_link(&self, path: Utf8PathBuf) -> Option<Linkable>;
}
@ -66,6 +68,12 @@ pub(crate) enum AssetKind {
Image,
}
impl AssetKind {
pub fn html(f: impl Fn(&Sack) -> String + 'static) -> Self {
Self::Html(Box::new(f))
}
}
/// Asset corresponding to a file on disk.
pub(crate) struct Asset {
/// The kind of a processed asset.
@ -138,6 +146,7 @@ impl From<Output> for PipelineItem {
/// This struct allows for querying the website hierarchy. It is passed to each rendered website
/// page, so that it can easily access the website metadata.
pub(crate) struct Sack<'a> {
pub ctx: &'a BuildContext,
/// Literally all of the content
hole: &'a [Output],
/// Current path for the page being rendered
@ -147,10 +156,6 @@ pub(crate) struct Sack<'a> {
}
impl<'a> Sack<'a> {
pub fn new(hole: &'a [Output], path: &'a Utf8PathBuf, file: Option<&'a Utf8PathBuf>) -> Self {
Self { hole, path, file }
}
pub fn get_links(&self, path: &str) -> Vec<LinkDate> {
let pattern = glob::Pattern::new(path).expect("Bad glob pattern");
self.hole
@ -260,17 +265,25 @@ fn to_source(path: Utf8PathBuf, exts: &HashSet<&'static str>) -> FileItem {
FileItem { kind, path }
}
pub fn render_all(items: &[Output]) {
pub fn render_all(ctx: &BuildContext, items: &[Output]) {
for item in items {
let file = match &item.kind {
OutputKind::Asset(a) => Some(&a.meta.path),
OutputKind::Virtual(_) => None,
};
render(item, &Sack::new(items, &item.path, file));
render(
item,
Sack {
ctx,
hole: items,
path: &item.path,
file,
},
);
}
}
fn render(item: &Output, sack: &Sack) {
fn render(item: &Output, sack: Sack) {
let o = Utf8Path::new("dist").join(&item.path);
fs::create_dir_all(o.parent().unwrap()).unwrap();
@ -281,7 +294,7 @@ fn render(item: &Output, sack: &Sack) {
match &real.kind {
AssetKind::Html(closure) => {
let mut file = File::create(&o).unwrap();
file.write_all(closure(sack).as_bytes()).unwrap();
file.write_all(closure(&sack).as_bytes()).unwrap();
println!("HTML: {} -> {}", i, o);
}
AssetKind::Bibtex(_) => {}
@ -294,7 +307,7 @@ fn render(item: &Output, sack: &Sack) {
}
OutputKind::Virtual(Virtual(ref closure)) => {
let mut file = File::create(&o).unwrap();
file.write_all(closure(sack).as_bytes()).unwrap();
file.write_all(closure(&sack).as_bytes()).unwrap();
println!("Virtual: -> {}", o);
}
}

135
src/text/md.rs
View file

@ -1,6 +1,11 @@
use std::collections::HashMap;
use hayagriva::{archive::ArchivedStyle, citationberg::{IndependentStyle, Locale, Style}, BibliographyDriver, BibliographyRequest, BufWriteFormat, CitationItem, CitationRequest, Library};
use hayagriva::{
archive::ArchivedStyle,
citationberg::{IndependentStyle, Locale, Style},
BibliographyDriver, BibliographyRequest, BufWriteFormat, CitationItem, CitationRequest,
Library,
};
use hypertext::Renderable;
use once_cell::sync::Lazy;
use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag, TagEnd, TextMergeStream};
@ -8,52 +13,50 @@ use regex::Regex;
use crate::ts;
static OPTS: Lazy<Options> = Lazy::new(||
static OPTS: Lazy<Options> = Lazy::new(|| {
Options::empty()
.union(Options::ENABLE_MATH)
.union(Options::ENABLE_TABLES)
.union(Options::ENABLE_TASKLISTS)
.union(Options::ENABLE_STRIKETHROUGH)
.union(Options::ENABLE_SMART_PUNCTUATION)
);
});
static KATEX_I: Lazy<katex::Opts> = Lazy::new(||
static KATEX_I: Lazy<katex::Opts> = Lazy::new(|| {
katex::opts::Opts::builder()
.output_type(katex::OutputType::Mathml)
.build()
.unwrap()
);
});
static KATEX_B: Lazy<katex::Opts> = Lazy::new(||
static KATEX_B: Lazy<katex::Opts> = Lazy::new(|| {
katex::opts::Opts::builder()
.output_type(katex::OutputType::Mathml)
.display_mode(true)
.build()
.unwrap()
);
});
static LOCALE: Lazy<Vec<Locale>> = Lazy::new(hayagriva::archive::locales);
static STYLE: Lazy<IndependentStyle> = Lazy::new(||
match ArchivedStyle::InstituteOfPhysicsNumeric.get() {
static STYLE: Lazy<IndependentStyle> =
Lazy::new(|| match ArchivedStyle::InstituteOfPhysicsNumeric.get() {
Style::Independent(style) => style,
Style::Dependent(_) => unreachable!(),
}
);
});
pub struct Outline(pub Vec<(String, String)>);
pub fn parse(text: &str, lib: Option<&Library>) -> (Outline, String, Option<Vec<String>>) {
pub fn parse(text: String, lib: Option<&Library>) -> (Outline, String, Option<Vec<String>>) {
let (outline, stream) = {
let stream = Parser::new_ext(text, *OPTS);
let stream = Parser::new_ext(&text, *OPTS);
let mut stream: Vec<_> = TextMergeStream::new(stream).collect();
let outline = set_heading_ids(&mut stream);
(outline, stream)
};
let stream = stream.into_iter()
let stream = stream
.into_iter()
.map(make_math)
.map(make_emoji)
.collect::<Vec<_>>();
@ -75,13 +78,20 @@ pub fn parse(text: &str, lib: Option<&Library>) -> (Outline, String, Option<Vec<
(outline, html, bib)
}
fn make_bib<'a, 'b>(stream: Vec<Event<'a>>, lib: &'b Library) -> (Vec<Event<'a>>, Option<Vec<String>>) {
fn make_bib<'a, 'b>(
stream: Vec<Event<'a>>,
lib: &'b Library,
) -> (Vec<Event<'a>>, Option<Vec<String>>) {
let mut driver = BibliographyDriver::new();
for event in stream.iter() {
match event {
Event::InlineMath(ref text) => match lib.get(text) {
Some(entry) => driver.citation(CitationRequest::from_items(vec![CitationItem::with_entry(entry)], &STYLE, &LOCALE)),
Some(entry) => driver.citation(CitationRequest::from_items(
vec![CitationItem::with_entry(entry)],
&STYLE,
&LOCALE,
)),
None => (),
},
_ => (),
@ -89,36 +99,51 @@ fn make_bib<'a, 'b>(stream: Vec<Event<'a>>, lib: &'b Library) -> (Vec<Event<'a>>
}
// add fake citation to make all entries show up
driver.citation(CitationRequest::from_items(lib.iter().map(CitationItem::with_entry).collect(), &STYLE, &LOCALE));
driver.citation(CitationRequest::from_items(
lib.iter().map(CitationItem::with_entry).collect(),
&STYLE,
&LOCALE,
));
let res = driver.finish(BibliographyRequest { style: &STYLE, locale: None, locale_files: &LOCALE });
let res = driver.finish(BibliographyRequest {
style: &STYLE,
locale: None,
locale_files: &LOCALE,
});
let mut n = 0;
let stream = stream.into_iter()
let stream = stream
.into_iter()
.map(|event| match event {
Event::InlineMath(name) => {
let mut buffer = String::from("<cite>");
match res.citations.get(n) {
Some(rf) => rf.citation.write_buf(&mut buffer, BufWriteFormat::Html).unwrap(),
Some(rf) => rf
.citation
.write_buf(&mut buffer, BufWriteFormat::Html)
.unwrap(),
None => buffer.push_str(&name),
};
buffer.push_str("</cite>");
n += 1;
Event::InlineHtml(buffer.into())
},
_ => event
}
_ => event,
})
.collect();
let bib = res.bibliography.map(|bib|
bib.items.iter()
let bib = res.bibliography.map(|bib| {
bib.items
.iter()
.map(|x| {
let mut buffer = String::new();
x.content.write_buf(&mut buffer, BufWriteFormat::Html).unwrap();
x.content
.write_buf(&mut buffer, BufWriteFormat::Html)
.unwrap();
buffer
})
.collect::<Vec<_>>()
);
});
(stream, bib)
}
@ -156,15 +181,13 @@ fn annotate_(input: &str) -> Vec<Annotated_> {
fn make_cite(event: Event) -> Vec<Event> {
match event {
Event::Text(ref text) => {
annotate_(text)
Event::Text(ref text) => annotate_(text)
.into_iter()
.map(|e| match e {
Annotated_::Text(text) => Event::Text(text.to_owned().into()),
Annotated_::Cite(cite) => Event::InlineMath(cite.to_owned().into()),
})
.collect()
},
.collect(),
_ => vec![event],
}
}
@ -179,36 +202,43 @@ fn set_heading_ids(events: &mut [Event]) -> Outline {
match event {
Event::Start(ref mut tag @ Tag::Heading { .. }) => {
ptr = Some(tag);
},
Event::Text(ref text) if ptr.is_some() => {
buf.push_str(text)
},
}
Event::Text(ref text) if ptr.is_some() => buf.push_str(text),
Event::End(TagEnd::Heading(..)) => {
let txt = std::mem::take(&mut buf);
let url = txt.to_lowercase().replace(' ', "-");
let url = match cnt.get_mut(&url) {
Some(ptr) => { *ptr += 1; format!("{url}-{ptr}") },
None => { cnt.insert(url.clone(), 0); url },
Some(ptr) => {
*ptr += 1;
format!("{url}-{ptr}")
}
None => {
cnt.insert(url.clone(), 0);
url
}
};
match ptr.take().unwrap() {
Tag::Heading { ref mut id, .. } => *id = Some(url.clone().into()),
_ => unreachable!(),
}
out.push((txt, url));
},
}
_ => (),
}
};
}
Outline(out)
}
fn make_math(event: Event) -> Event {
match event {
Event::InlineMath(math) => Event::InlineHtml(katex::render_with_opts(&math, &*KATEX_I).unwrap().into()),
Event::DisplayMath(math) => Event::Html(katex::render_with_opts(&math, &*KATEX_B).unwrap().into()),
_ => event
Event::InlineMath(math) => {
Event::InlineHtml(katex::render_with_opts(&math, &*KATEX_I).unwrap().into())
}
Event::DisplayMath(math) => {
Event::Html(katex::render_with_opts(&math, &*KATEX_B).unwrap().into())
}
_ => event,
}
}
@ -228,21 +258,19 @@ fn make_code(es: Vec<Event>) -> Vec<Event> {
let html = ts::highlight(&lang, &code).render().as_str().to_owned();
buff.push(Event::Html(html.into()));
code.clear();
},
}
Event::Text(text) => match lang {
None => buff.push(Event::Text(text)),
Some(_) => code.push_str(&text),
},
_ => buff.push(event)
_ => buff.push(event),
}
}
buff
}
static RE_RUBY: Lazy<Regex> = Lazy::new(||
Regex::new(r"\[([^\]]+)\]\{([^}]+)\}").unwrap()
);
static RE_RUBY: Lazy<Regex> = Lazy::new(|| Regex::new(r"\[([^\]]+)\]\{([^}]+)\}").unwrap());
#[derive(Debug)]
enum Annotated<'a> {
@ -250,7 +278,6 @@ enum Annotated<'a> {
Ruby(&'a str, &'a str),
}
fn annotate(input: &str) -> Vec<Annotated> {
let mut parts: Vec<Annotated> = Vec::new();
let mut last_index = 0;
@ -281,7 +308,9 @@ fn make_ruby(event: Event) -> Vec<Event> {
.into_iter()
.map(|el| match el {
Annotated::Text(text) => Event::Text(text.to_owned().into()),
Annotated::Ruby(t, f) => Event::InlineHtml(format!("<ruby>{t}<rp>(</rp><rt>{f}</rt><rp>)</rp></ruby>").into()),
Annotated::Ruby(t, f) => Event::InlineHtml(
format!("<ruby>{t}<rp>(</rp><rt>{f}</rt><rp>)</rp></ruby>").into(),
),
})
.collect(),
_ => vec![event],
@ -314,9 +343,9 @@ fn make_emoji(event: Event) -> Event {
match buf {
None => event,
Some(buf) => Event::Text(buf.into())
Some(buf) => Event::Text(buf.into()),
}
}
},
_ => event,
}
}

41
src/ts/mod.rs
View file

@ -1,11 +1,10 @@
use std::borrow::Cow;
use hypertext::{html_elements, maud_move, Raw, Renderable, GlobalAttributes};
use tree_sitter_highlight::{Highlighter, HighlightEvent};
mod captures;
mod configs;
use std::borrow::Cow;
use hypertext::{html_elements, maud_move, GlobalAttributes, Raw, Renderable};
use tree_sitter_highlight::{HighlightEvent, Highlighter};
pub enum Event {
Write(String),
@ -13,13 +12,9 @@ pub enum Event {
Close,
}
pub fn highlight<'data, 'html>(
lang: &'data str,
code: &'data str
) -> impl Renderable + 'html
pub fn highlight<'data, 'html>(lang: &'data str, code: &'data str) -> impl Renderable + 'html
where
'data: 'html
'data: 'html,
{
maud_move!(
figure .listing.kanagawa data-lang=(lang) {
@ -37,11 +32,13 @@ fn to_html(lang: &str, code: &str) -> String {
.into_iter()
.map(|event| match event {
Event::Write(text) => Cow::from(
text.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;")
),
Event::Enter(class) => Cow::from(
format!("<span class=\"{}\">", class.replace('.', "-"))
text.replace('&', "&amp;")
.replace('<', "&lt;")
.replace('>', "&gt;"),
),
Event::Enter(class) => {
Cow::from(format!("<span class=\"{}\">", class.replace('.', "-")))
}
Event::Close => Cow::from("</span>"),
})
.collect()
@ -50,17 +47,15 @@ fn to_html(lang: &str, code: &str) -> String {
fn get_events(lang: &str, src: &str) -> Vec<Event> {
let config = match configs::get_config(lang) {
Some(c) => c,
None => return vec![Event::Write(src.into())]
None => return vec![Event::Write(src.into())],
};
let mut hl = Highlighter::new();
let highlights = hl.highlight(
config,
src.as_bytes(),
None,
|name| configs::get_config(name)
).unwrap();
let highlights = hl
.highlight(config, src.as_bytes(), None, |name| {
configs::get_config(name)
})
.unwrap();
let mut out = vec![];
for event in highlights {