599 lines
18 KiB
Rust
599 lines
18 KiB
Rust
use crate::markup5ever::tendril::TendrilSink;
|
|
use actix_files::NamedFile;
|
|
use actix_web::error::ErrorInternalServerError;
|
|
use actix_web::{error, get, http, middleware, web, App, Error, HttpResponse, HttpServer};
|
|
use anyhow::anyhow;
|
|
use chrono::{DateTime, Local};
|
|
use clap::{App as ClapApp, Arg};
|
|
use html5ever::serialize::{serialize, SerializeOpts};
|
|
use kuchiki::{parse_fragment, Attribute, ExpandedName, NodeRef};
|
|
use linkify::LinkFinder;
|
|
use log::{info, trace};
|
|
use markup5ever::QualName;
|
|
use percent_encoding::{percent_decode_str, utf8_percent_encode};
|
|
use pulldown_cmark::{html, Event, Options, Parser, Tag};
|
|
use regex::{Captures, Regex};
|
|
use slug::slugify;
|
|
use std::cmp::Reverse;
|
|
use std::collections::HashMap;
|
|
use std::fs::File;
|
|
use std::io::Read;
|
|
use std::net::SocketAddr;
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::Mutex;
|
|
use std::time::{Duration, SystemTime};
|
|
use std::{env, fs};
|
|
use tera::{Context, Tera};
|
|
|
|
#[macro_use]
|
|
extern crate markup5ever;
|
|
|
|
#[derive(Clone)]
|
|
struct State {
|
|
garden_dir: PathBuf,
|
|
index_file: Option<String>,
|
|
title: Option<String>,
|
|
server_name: String,
|
|
tera: Tera,
|
|
}
|
|
|
|
struct MutableState {
|
|
garden_cache: Mutex<GardenCache>,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct GardenCache {
|
|
pages: HashMap<String, ParsedPage>,
|
|
files: Vec<PathBuf>,
|
|
tags: HashMap<String, u32>,
|
|
}
|
|
|
|
impl Default for GardenCache {
|
|
fn default() -> Self {
|
|
GardenCache {
|
|
pages: HashMap::new(),
|
|
files: vec![],
|
|
tags: HashMap::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct ParsedPage {
|
|
timestamp: Option<SystemTime>,
|
|
title: String,
|
|
html: String,
|
|
links: Vec<String>,
|
|
}
|
|
|
|
const VERSION: &str = env!("CARGO_PKG_VERSION");
|
|
|
|
fn main() -> anyhow::Result<()> {
|
|
let env = env_logger::Env::default().filter_or(env_logger::DEFAULT_FILTER_ENV, "info");
|
|
env_logger::init_from_env(env);
|
|
|
|
let app = ClapApp::new("gardenserver")
|
|
.version(VERSION)
|
|
.author("Tomáš Mládek <t@mldk.cz>")
|
|
.arg(Arg::with_name("DIRECTORY").required(true).index(1))
|
|
.arg(
|
|
Arg::with_name("BIND")
|
|
.long("bind")
|
|
.default_value("127.0.0.1:8642")
|
|
.help("address and port to bind the Web interface on")
|
|
.required(true),
|
|
)
|
|
.arg(
|
|
Arg::with_name("INDEX_FILE")
|
|
.takes_value(true)
|
|
.short("i")
|
|
.long("index")
|
|
.help("File to be served at the root."),
|
|
)
|
|
.arg(
|
|
Arg::with_name("TITLE")
|
|
.takes_value(true)
|
|
.short("t")
|
|
.long("title")
|
|
.help("Title of this digital garden."),
|
|
)
|
|
.arg(
|
|
Arg::with_name("SERVER_NAME")
|
|
.takes_value(true)
|
|
.short("u")
|
|
.long("garden-url")
|
|
.help("Hostname of the server of this digital garden (for metadata)."),
|
|
);
|
|
|
|
let matches = app.get_matches();
|
|
|
|
let directory = Path::new(matches.value_of("DIRECTORY").unwrap());
|
|
|
|
info!(
|
|
"Starting GardenServer {} of {}...",
|
|
VERSION,
|
|
directory.display()
|
|
);
|
|
|
|
let tera = Tera::new("templates/**/*.html")?;
|
|
|
|
let sys = actix::System::new("gardenserver");
|
|
|
|
let bind: SocketAddr = matches
|
|
.value_of("BIND")
|
|
.unwrap()
|
|
.parse()
|
|
.expect("Incorrect bind format.");
|
|
info!("Starting server at: http://{}", &bind);
|
|
|
|
let mutable_state = web::Data::new(MutableState {
|
|
garden_cache: Mutex::new(update_garden(directory, GardenCache::default())?),
|
|
});
|
|
|
|
let state = State {
|
|
garden_dir: directory.to_path_buf(),
|
|
index_file: matches.value_of("INDEX_FILE").map(|s| s.to_string()),
|
|
title: matches.value_of("TITLE").map(|s| s.to_string()),
|
|
server_name: matches
|
|
.value_of("SERVER_NAME")
|
|
.map_or(matches.value_of("BIND").unwrap().to_string(), |s| {
|
|
s.to_string()
|
|
}),
|
|
tera,
|
|
};
|
|
|
|
// Start HTTP server
|
|
HttpServer::new(move || {
|
|
App::new()
|
|
.wrap(middleware::Logger::default())
|
|
.data(state.clone())
|
|
.app_data(mutable_state.clone())
|
|
.service(actix_files::Files::new("/static", "templates"))
|
|
.service(render)
|
|
})
|
|
.bind(&bind)?
|
|
.run();
|
|
|
|
Ok(sys.run()?)
|
|
}
|
|
|
|
#[get("{path:.*}")]
|
|
async fn render(
|
|
request: web::HttpRequest,
|
|
data: web::Data<State>,
|
|
state: web::Data<MutableState>,
|
|
path: web::Path<String>,
|
|
) -> Result<HttpResponse, Error> {
|
|
let mut cache = state.garden_cache.lock().unwrap();
|
|
*cache = update_garden(&data.garden_dir, (*cache).clone())
|
|
.map_err(error::ErrorInternalServerError)?;
|
|
|
|
// Redirect to index if path is empty.
|
|
if path.is_empty() {
|
|
let location = match data.index_file.as_ref() {
|
|
Some(index_file) => index_file.clone(),
|
|
None => cache
|
|
.files
|
|
.iter()
|
|
.filter(|f| f.to_str().unwrap().ends_with(".md"))
|
|
.collect::<Vec<&PathBuf>>()
|
|
.first()
|
|
.unwrap_or(&cache.files.first().unwrap())
|
|
.display()
|
|
.to_string(),
|
|
};
|
|
|
|
return Ok(HttpResponse::Found()
|
|
.header(http::header::LOCATION, location.as_str())
|
|
.finish());
|
|
}
|
|
|
|
let full_path = data.garden_dir.join(path.as_str());
|
|
|
|
// Redirect to ".md" version if requested path matches a .md file without the extension
|
|
if !full_path.exists() && Path::new(&format!("{}.md", full_path.to_str().unwrap())).exists() {
|
|
return Ok(HttpResponse::Found()
|
|
.header(http::header::LOCATION, format!("{}.md", path.to_string()))
|
|
.finish());
|
|
}
|
|
|
|
// If the path is not a markdown file (e.g. photos), just return it as it is.
|
|
if full_path.exists() && !path.ends_with(".md") {
|
|
return NamedFile::open(full_path)?.into_response(&request);
|
|
}
|
|
|
|
// Otherwise, retrieve it and check backlinks
|
|
let filename = full_path
|
|
.components()
|
|
.last()
|
|
.unwrap()
|
|
.as_os_str()
|
|
.to_str()
|
|
.unwrap();
|
|
|
|
let normalized_name = normalize_name(filename);
|
|
|
|
let mut backlinks: Vec<String> = vec![];
|
|
for (path, page) in cache.pages.iter() {
|
|
if page
|
|
.links
|
|
.iter()
|
|
.any(|link| normalize_name(link.as_str()) == normalized_name)
|
|
{
|
|
backlinks.push(normalize_name(path));
|
|
}
|
|
}
|
|
|
|
// Special case - graph view
|
|
let mut graph_page = ParsedPage {
|
|
timestamp: None,
|
|
title: "".to_string(),
|
|
html: "".to_string(),
|
|
links: vec![],
|
|
};
|
|
|
|
let page = if path.as_str() != "!graph" {
|
|
cache.pages.get(path.as_ref())
|
|
} else {
|
|
let mut context = Context::new();
|
|
|
|
let mut nodes: Vec<HashMap<String, String>> = vec![];
|
|
let mut links: Vec<HashMap<String, String>> = vec![];
|
|
|
|
let page_ids: Vec<String> = cache.pages.keys().map(|n| normalize_name(n)).collect();
|
|
|
|
cache.pages.iter().for_each(|(path, page)| {
|
|
let normalized_path = normalize_name(path);
|
|
nodes.push(
|
|
[("id".to_string(), normalized_path.clone())]
|
|
.iter()
|
|
.cloned()
|
|
.collect(),
|
|
);
|
|
page.links
|
|
.iter()
|
|
.map(|l| normalize_name(l))
|
|
.filter(|link| page_ids.contains(link))
|
|
.for_each(|link| {
|
|
links.push(
|
|
[
|
|
("source".to_string(), normalized_path.clone()),
|
|
("target".to_string(), link),
|
|
]
|
|
.iter()
|
|
.cloned()
|
|
.collect(),
|
|
)
|
|
})
|
|
});
|
|
|
|
context.insert("nodes", &nodes);
|
|
context.insert("links", &links);
|
|
|
|
graph_page.title = "Graph View".to_string();
|
|
graph_page.html = data
|
|
.tera
|
|
.render("graph.html", &context)
|
|
.map_err(ErrorInternalServerError)?;
|
|
Some(&graph_page)
|
|
};
|
|
|
|
// Recently changed
|
|
let mut recently_changed = cache
|
|
.pages
|
|
.clone()
|
|
.into_iter()
|
|
.filter_map(|(path, page)| {
|
|
page.timestamp
|
|
.map(|ts| (path, SystemTime::now().duration_since(ts).unwrap()))
|
|
})
|
|
.collect::<Vec<(String, Duration)>>();
|
|
recently_changed.sort_by_key(|i| i.1);
|
|
|
|
let timeago = timeago::Formatter::new();
|
|
|
|
// Render context generation
|
|
let mut context = Context::new();
|
|
context.insert("version", VERSION);
|
|
context.insert(
|
|
"garden_title",
|
|
data.title.as_ref().unwrap_or(&"Digital Garden".to_string()),
|
|
);
|
|
context.insert("files", &cache.files);
|
|
|
|
let mut tags: Vec<(&String, &u32)> = cache.tags.iter().collect();
|
|
tags.sort_by_key(|(t, _)| *t);
|
|
tags.sort_by_key(|(_, n)| Reverse(*n));
|
|
context.insert("tags", &tags);
|
|
|
|
context.insert(
|
|
"recently_changed",
|
|
&recently_changed
|
|
.into_iter()
|
|
.map(|(path, duration)| (path, timeago.convert(duration)))
|
|
.collect::<Vec<(String, String)>>(),
|
|
);
|
|
context.insert(
|
|
"page_title",
|
|
&match page {
|
|
Some(page) => page.title.clone(),
|
|
None => filename.to_string(),
|
|
},
|
|
);
|
|
context.insert(
|
|
"content",
|
|
&match page {
|
|
Some(page) => page.html.clone(),
|
|
None => data
|
|
.tera
|
|
.render("_not_found.html", &Context::new())
|
|
.map_err(ErrorInternalServerError)?,
|
|
},
|
|
);
|
|
context.insert("backlinks", &backlinks);
|
|
context.insert(
|
|
"mtime",
|
|
&match page {
|
|
Some(page) => {
|
|
if let Some(timestamp) = page.timestamp {
|
|
let mtime: DateTime<Local> = timestamp.into();
|
|
Some(mtime.format("%c").to_string())
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
None => None,
|
|
},
|
|
);
|
|
context.insert("server_name", &data.server_name);
|
|
context.insert("path", &path.to_string());
|
|
|
|
Ok(HttpResponse::Ok().body(
|
|
data.tera
|
|
.render("main.html", &context)
|
|
.map_err(ErrorInternalServerError)?,
|
|
))
|
|
}
|
|
|
|
fn update_garden<P: AsRef<Path>>(
|
|
garden_path: P,
|
|
current: GardenCache,
|
|
) -> anyhow::Result<GardenCache> {
|
|
let garden_path = garden_path.as_ref();
|
|
|
|
let mut files: Vec<PathBuf> = fs::read_dir(&garden_path)?
|
|
.filter_map(|entry| {
|
|
if let Ok(entry) = entry {
|
|
let path = entry.path();
|
|
if path.is_file() {
|
|
let stripped_path = path.strip_prefix(&garden_path).unwrap().to_path_buf();
|
|
if !stripped_path.to_str().unwrap().starts_with('.') {
|
|
return Some(stripped_path);
|
|
}
|
|
}
|
|
}
|
|
None
|
|
})
|
|
.collect();
|
|
files.sort_by(move |a, b| {
|
|
let a_sort = a.file_stem().unwrap_or_else(|| a.as_os_str());
|
|
let b_sort = b.file_stem().unwrap_or_else(|| b.as_os_str());
|
|
a_sort.cmp(b_sort)
|
|
});
|
|
files.sort_by_key(|p| match p.extension() {
|
|
None => -1,
|
|
Some(ext) => {
|
|
if ext == "md" {
|
|
0
|
|
} else {
|
|
1
|
|
}
|
|
}
|
|
});
|
|
|
|
if files.is_empty() {
|
|
return Err(anyhow!("Garden is empty."));
|
|
}
|
|
|
|
let mut pages = current.pages;
|
|
let mut tags = current.tags;
|
|
|
|
let markdown_paths = files
|
|
.iter()
|
|
.filter(|p| p.to_str().unwrap_or("").ends_with(".md"));
|
|
for path in markdown_paths {
|
|
trace!("Loading {} into cache...", path.display());
|
|
let full_path = garden_path.join(path);
|
|
let mtime = full_path.metadata().unwrap().modified().ok();
|
|
if let Some(page) = pages.get(path.to_str().unwrap()) {
|
|
if let (Some(fs_time), Some(last_time)) = (mtime, page.timestamp) {
|
|
if fs_time == last_time {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut file = File::open(&full_path)?;
|
|
let mut file_string = String::new();
|
|
file.read_to_string(&mut file_string)?;
|
|
let markdown_source = preprocess_markdown(file_string);
|
|
let result = parse_garden(&markdown_source)?;
|
|
|
|
pages.insert(
|
|
String::from(path.to_str().unwrap()),
|
|
ParsedPage {
|
|
timestamp: mtime,
|
|
html: result.html,
|
|
links: result.links,
|
|
title: match result.title {
|
|
Some(title) => title,
|
|
_ => String::from(
|
|
path.components()
|
|
.last()
|
|
.unwrap()
|
|
.as_os_str()
|
|
.to_str()
|
|
.unwrap_or("???"),
|
|
),
|
|
},
|
|
},
|
|
);
|
|
|
|
result.tags.into_iter().for_each(|tag| {
|
|
*tags.entry(tag).or_insert(0) += 1;
|
|
});
|
|
}
|
|
|
|
let result = GardenCache { pages, files, tags };
|
|
trace!("{:#?}", result);
|
|
Ok(result)
|
|
}
|
|
|
|
struct ParseResult {
|
|
html: String,
|
|
title: Option<String>,
|
|
links: Vec<String>,
|
|
tags: Vec<String>,
|
|
}
|
|
|
|
fn parse_garden<S: AsRef<str>>(text: S) -> anyhow::Result<ParseResult> {
|
|
let mut current_top_heading = 999;
|
|
let mut top_heading_text: Option<String> = None;
|
|
|
|
let mut last_nontext_event: Option<Event> = None;
|
|
|
|
let mut links: Vec<String> = vec![];
|
|
let mut tags: Vec<String> = vec![];
|
|
|
|
let parser = Parser::new_ext(text.as_ref(), Options::all()).map(|event| {
|
|
if let Event::Start(Tag::Link(_, dest, _)) = &event {
|
|
links.push(dest.to_string());
|
|
}
|
|
|
|
if let Some(Event::Start(Tag::Link(_, _, _))) = &last_nontext_event {
|
|
if let Event::Text(str) = &event {
|
|
if str.starts_with('#') {
|
|
tags.push(str[1..].to_string());
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(Event::Start(Tag::Heading(hl))) = last_nontext_event {
|
|
if hl < current_top_heading {
|
|
current_top_heading = hl;
|
|
if let Event::Text(str) = &event {
|
|
top_heading_text = Some(str.clone().into_string());
|
|
}
|
|
}
|
|
}
|
|
|
|
last_nontext_event = Some(event.clone());
|
|
|
|
event
|
|
});
|
|
|
|
let mut html = String::new();
|
|
html::push_html(&mut html, parser);
|
|
html = postprocess_html(html)?;
|
|
|
|
Ok(ParseResult {
|
|
html,
|
|
title: top_heading_text,
|
|
links,
|
|
tags,
|
|
})
|
|
}
|
|
|
|
fn preprocess_markdown(string: String) -> String {
|
|
let double_brackets = Regex::new(r"\[\[(?P<inner>[\w\- .]+)\]\]").unwrap();
|
|
let finder = LinkFinder::new();
|
|
|
|
let result = double_brackets
|
|
.replace_all(&string, |caps: &Captures| {
|
|
format!(
|
|
"[{}]({})",
|
|
&caps[1],
|
|
utf8_percent_encode(&caps[1], percent_encoding::NON_ALPHANUMERIC)
|
|
)
|
|
})
|
|
.to_string();
|
|
|
|
let tags = Regex::new(r"#([\w]+)").unwrap();
|
|
let result = tags
|
|
.replace_all(&result, |caps: &Captures| {
|
|
format!(
|
|
"[{}]({})",
|
|
&caps[0],
|
|
utf8_percent_encode(&caps[1], percent_encoding::NON_ALPHANUMERIC)
|
|
)
|
|
})
|
|
.to_string();
|
|
|
|
let result_vec = Vec::from(result.as_str());
|
|
let start_delims = vec![b'(', b'<'];
|
|
let end_delims = vec![b')', b'>'];
|
|
// link.end() is the first char AFTER the link!
|
|
let links = finder.links(result.as_str()).filter(|link| {
|
|
link.start() == 0
|
|
|| link.end() == result.len()
|
|
|| !start_delims.contains(&result_vec[link.start() - 1])
|
|
|| !end_delims.contains(&result_vec[link.end()])
|
|
});
|
|
|
|
let mut offset = 0;
|
|
let mut result_string = result.to_string();
|
|
for link in links {
|
|
let orig = link.as_str();
|
|
let new = format!("<{}>", orig);
|
|
result_string.replace_range((link.start() + offset)..(link.end() + offset), new.as_str());
|
|
offset += new.len() - orig.len();
|
|
}
|
|
|
|
result_string
|
|
}
|
|
|
|
fn postprocess_html<T: AsRef<str>>(document: T) -> anyhow::Result<String> {
|
|
let document_bytes = String::from(document.as_ref());
|
|
let frag = parse_fragment(QualName::new(None, ns!(html), local_name!("body")), vec![])
|
|
.from_utf8()
|
|
.read_from(&mut document_bytes.as_bytes())
|
|
.unwrap();
|
|
|
|
frag.select("h1,h2,h3,h4,h5")
|
|
.unwrap()
|
|
.into_iter()
|
|
.for_each(|el| {
|
|
let id = slugify(el.text_contents());
|
|
el.attributes.borrow_mut().insert("id", id.clone());
|
|
el.as_node().prepend(NodeRef::new_element(
|
|
QualName::new(None, ns!(html), local_name!("a")),
|
|
vec![
|
|
(
|
|
ExpandedName::new(ns!(), local_name!("class")),
|
|
Attribute {
|
|
prefix: None,
|
|
value: "anchor".to_string(),
|
|
},
|
|
),
|
|
(
|
|
ExpandedName::new(ns!(), local_name!("href")),
|
|
Attribute {
|
|
prefix: None,
|
|
value: format!("#{}", id),
|
|
},
|
|
),
|
|
],
|
|
));
|
|
});
|
|
|
|
let mut bytes = vec![];
|
|
serialize(&mut bytes, &frag, SerializeOpts::default())?;
|
|
Ok(String::from_utf8(bytes)?)
|
|
}
|
|
|
|
fn normalize_name(filename: &str) -> String {
|
|
let decoded = percent_decode_str(filename).decode_utf8_lossy();
|
|
let result = decoded.strip_suffix(".md");
|
|
String::from(result.unwrap_or_else(|| decoded.as_ref()))
|
|
}
|