diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/get_routes.rs | 2 | ||||
| -rw-r--r-- | src/lua.rs | 44 | ||||
| -rw-r--r-- | src/lua/template.rs | 333 | ||||
| -rw-r--r-- | src/main.rs | 49 | ||||
| -rw-r--r-- | src/post_routes.rs | 2 |
5 files changed, 423 insertions, 7 deletions
diff --git a/src/get_routes.rs b/src/get_routes.rs index 5e65637..951c7b6 100644 --- a/src/get_routes.rs +++ b/src/get_routes.rs @@ -109,7 +109,7 @@ fn view_blob<C: Controller>( return Ok(page.into()); } if let Some(renderer) = get_renderer(&ctx.path) { - renderer(text, &mut page, RenderMode::View); + renderer(text, &mut page, RenderMode::View, &ctx); } else { page.body .push_str(&format!("<pre>{}</pre>", html_escape(text))); @@ -11,7 +11,10 @@ use rlua::Table; use crate::Context; +use self::template::ArgIndex; + mod serde; +pub mod template; pub struct Script<'a> { pub lua_module_name: &'a str, @@ -113,6 +116,47 @@ impl<'a> Script<'a> { } } +fn module_path(module_name: &str) -> String { + format!("modules/{}.lua", module_name) +} + +pub struct ModuleFunction<'a> { + pub module_name: &'a str, + pub function_name: &'a str, +} + +pub fn call( + modfn: &ModuleFunction, + args: impl Iterator<Item = (ArgIndex, String)>, + ctx: &Context, +) -> Result<String, ScriptError> { + let filename = module_path(modfn.module_name); + + let lua_entr = ctx + .branch_head() + .unwrap() + .tree() + .and_then(|tree| tree.get_path(Path::new(&filename))) + .map_err(|_| ScriptError::ModuleNotFound)?; + + let lua_blob = ctx.repo.find_blob(lua_entr.id()).unwrap(); + let lua_code = from_utf8(lua_blob.content()).map_err(|_| ScriptError::ModuleNotUtf8)?; + + lua_context(|ctx| { + let module: Table = ctx.load(lua_code).eval()?; + let view: Function = module.get(modfn.function_name)?; + let lua_args = ctx.create_table()?; + for (idx, val) in args { + match idx { + ArgIndex::Str(s) => lua_args.set(s, val)?, + ArgIndex::Num(n) => lua_args.set(n, val)?, + } + } + view.call(lua_args) + }) + .map_err(ScriptError::LuaError) +} + impl Display for ScriptError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { diff --git a/src/lua/template.rs b/src/lua/template.rs new file mode 100644 index 0000000..de13481 --- /dev/null +++ b/src/lua/template.rs @@ -0,0 +1,333 @@ +use logos::Logos; + +use super::ModuleFunction; + +#[derive(Logos, Debug, PartialEq)] +pub(crate) enum Token { + #[token("{{")] + OpenCall, + + #[token("\\}}")] + EscapedCloseCall, + + #[token("}}")] + CloseCall, + + #[regex("<pre( +[^>]*)?>")] + OpenPre, + + #[regex("</pre>")] + ClosePre, + + #[regex("<raw>")] + OpenRaw, + + #[regex("</raw>")] + CloseRaw, + + #[token("<!--")] + OpenComment, + + #[token("-->")] + CloseComment, + + #[error] + Other, +} + +fn strip_marker(num: usize) -> String { + format!("\x7fUNIQ-{:05X}-QINU\x7f", num) +} + +#[derive(Logos, Debug, PartialEq)] +pub(crate) enum MarkerToken { + #[regex("\x7fUNIQ-[A-F0-9][A-F0-9][A-F0-9][A-F0-9][A-F0-9]-QINU\x7f")] + StripMarker, + + #[error] + Other, +} + +#[derive(Debug)] +pub enum TokenType { + OpenPre, + ClosePre, + OpenRaw, + CloseRaw, + OpenCall, + CloseCall, +} + +#[derive(Debug)] +pub(crate) enum Sub<'a> { + Call(&'a str), + Raw(&'a str), + Pre { attrs: &'a str, content: &'a str }, + StrayToken(TokenType, &'a str), +} + +pub(crate) struct ParserState<'a> { + substitutions: Vec<Sub<'a>>, +} + +impl<'a> ParserState<'a> { + fn new() -> Self { + Self { + substitutions: Vec::new(), + } + } + + fn add(&mut self, sub: Sub<'a>) -> usize { + let idx = self.substitutions.len(); + self.substitutions.push(sub); + idx + } + + pub(crate) fn postprocess( + &self, + text: &str, + render: impl Fn(&Sub<'a>, &mut String) -> std::fmt::Result, + ) -> String { + let mut out = String::new(); + let mut lex = MarkerToken::lexer(text); + while let Some(tok) = lex.next() { + match tok { + MarkerToken::StripMarker => match usize::from_str_radix(&lex.slice()[6..11], 16) { + Ok(idx) => { + render(&self.substitutions[idx], &mut out); + } + Err(e) => out.push_str(lex.slice()), + }, + MarkerToken::Other => out.push_str(lex.slice()), + } + } + out.push_str(lex.remainder()); + out + } +} + +pub(crate) fn preprocess(text: &str) -> (String, ParserState) { + let mut stripped = String::new(); + let mut lex = Token::lexer(text); + let mut state = ParserState::new(); + + while let Some(tok) = lex.next() { + match tok { + Token::OpenComment => { + let span = lex.span(); + + stripped.push_str(if lex.any(|t| matches!(&t, Token::CloseComment)) { + &lex.source()[span.start..lex.span().end] + } else { + &lex.source()[span.start..] + }); + } + Token::OpenRaw => { + let span = lex.span(); + let slice = lex.slice(); + + stripped.push_str(&strip_marker(state.add( + if lex.any(|t| matches!(&t, Token::CloseRaw)) { + Sub::Raw(&lex.source()[span.end..lex.span().start]) + } else { + lex = Token::lexer(&lex.source()[span.end..]); + Sub::StrayToken(TokenType::OpenRaw, slice) + }, + ))); + } + Token::OpenCall => { + let span = lex.span(); + let slice = lex.slice(); + + stripped.push_str(&strip_marker(state.add( + if lex.any(|t| matches!(&t, Token::CloseCall)) { + Sub::Call(&lex.source()[span.end..lex.span().start]) + } else { + lex = Token::lexer(&lex.source()[span.end..]); + Sub::StrayToken(TokenType::OpenCall, slice) + }, + ))); + } + Token::OpenPre => { + let span = lex.span(); + let slice = lex.slice(); + + stripped.push_str(&strip_marker(state.add( + if lex.any(|t| matches!(&t, Token::ClosePre)) { + Sub::Pre { + attrs: &lex.source()[span.start + 4..span.end - 1], + content: &lex.source()[span.end..lex.span().start], + } + } else { + lex = Token::lexer(&lex.source()[span.end..]); + Sub::StrayToken(TokenType::OpenPre, slice) + }, + ))); + } + Token::CloseCall => { + stripped.push_str(&strip_marker( + state.add(Sub::StrayToken(TokenType::CloseCall, lex.slice())), + )); + } + Token::ClosePre => { + stripped.push_str(&strip_marker( + state.add(Sub::StrayToken(TokenType::ClosePre, lex.slice())), + )); + } + Token::CloseRaw => { + stripped.push_str(&strip_marker( + state.add(Sub::StrayToken(TokenType::CloseRaw, lex.slice())), + )); + } + _ => { + stripped.push_str(lex.slice()); + } + } + } + stripped.push_str(lex.remainder()); + + (stripped, state) +} + +#[cfg(test)] +mod tests { + use std::fmt::Write; + + use crate::lua::template::preprocess; + + use super::Sub; + + fn debug_format(sub: &Sub, out: &mut String) -> std::fmt::Result { + write!(out, "{:?}", sub) + } + + #[test] + fn test_parse() { + let (text, state) = preprocess("{{foobar}} <pre lang=js>foo</pre> <raw>{{test</raw>}}"); + let out = state.postprocess(&text, debug_format); + assert_eq!( + out, + r#"Call("foobar") Pre { attrs: " lang=js", content: "foo" } Raw("{{test")StrayToken(CloseCall, "}}")"# + ); + } + + #[test] + fn test_stray_open_tokens() { + let (text, state) = preprocess("{{ <pre> <raw>"); + let out = state.postprocess(&text, debug_format); + assert_eq!( + out, + r#"StrayToken(OpenCall, "{{") StrayToken(OpenPre, "<pre>") StrayToken(OpenRaw, "<raw>")"# + ); + } + + #[test] + fn test_stray_close_tokens() { + let (text, state) = preprocess("}} </pre> </raw>"); + let out = state.postprocess(&text, debug_format); + assert_eq!( + out, + r#"StrayToken(CloseCall, "}}") StrayToken(ClosePre, "</pre>") StrayToken(CloseRaw, "</raw>")"# + ); + } + + #[test] + fn test_comment() { + let (text, _state) = + preprocess("<!-- {{foobar}} <pre lang=js>foo</pre> <raw>{{test</raw>}}"); + assert_eq!( + text, + r#"<!-- {{foobar}} <pre lang=js>foo</pre> <raw>{{test</raw>}}"# + ); + } + + #[test] + fn test_call_after_stray_open() { + let (text, state) = preprocess("<pre> {{foo}}"); + let out = state.postprocess(&text, debug_format); + assert_eq!(out, r#"StrayToken(OpenPre, "<pre>") Call("foo")"#); + } +} + +#[derive(Logos, Debug, PartialEq)] +enum CallInnerToken { + #[token("\\|")] + EscapedPipe, + + #[regex("\\}}")] + EscapedClose, + + #[token("|")] + Pipe, + + #[error] + Other, +} + +#[derive(Debug)] +pub enum ArgIndex { + Str(String), + Num(usize), +} + +fn parse_arg(text: &str, cur_idx: &mut usize) -> (ArgIndex, String) { + if let Some((key, val)) = text.split_once('=') { + let key = key.trim(); + let idx = match key.parse::<usize>() { + Ok(n) => ArgIndex::Num(n), + Err(_) => ArgIndex::Str(key.to_string()), + }; + (idx, val.trim().to_string()) + } else { + let ret = (ArgIndex::Num(*cur_idx), text.trim().to_string()); + *cur_idx += 1; + ret + } +} + +pub fn parse_call_args(text: &str) -> (ModuleFunction, std::vec::IntoIter<(ArgIndex, String)>) { + let mut args = Vec::new(); + let mut arg = String::new(); + + let mut iter = text.splitn(2, '|'); + let arg0 = iter.next().unwrap(); + + let mut idx = 1; + + if let Some(rest) = iter.next() { + let mut lexer = CallInnerToken::lexer(rest); + while let Some(tok) = lexer.next() { + match tok { + CallInnerToken::EscapedClose => arg.push_str("}}"), + CallInnerToken::EscapedPipe => arg.push('|'), + CallInnerToken::Other => arg.push_str(lexer.slice()), + CallInnerToken::Pipe => { + args.push(parse_arg(&arg, &mut idx)); + arg = String::new(); + idx += 1; + } + } + } + arg.push_str(lexer.remainder()); + args.push(parse_arg(&arg, &mut idx)); + } + + let mut parts = arg0.splitn(2, '.'); + + let module_name; + let mut function_name = parts.next().unwrap(); + if let Some(next) = parts.next() { + module_name = function_name; + function_name = next; + } else { + module_name = "default"; + } + + ( + ModuleFunction { + module_name, + function_name, + }, + args.into_iter(), + ) +} diff --git a/src/main.rs b/src/main.rs index 2cd3a5d..e2fea85 100644 --- a/src/main.rs +++ b/src/main.rs @@ -18,7 +18,6 @@ use hyper::StatusCode; use hyper::{Body, Server}; use origins::HttpOrigin; use percent_encoding::percent_decode_str; -use pulldown_cmark::html; use pulldown_cmark::Options; use pulldown_cmark::Parser; use serde::Deserialize; @@ -28,6 +27,7 @@ use sputnik::request::SputnikParts; use sputnik::response::SputnikBuilder; use std::convert::Infallible; use std::env; +use std::fmt::Write; use std::path::Path; use std::sync::Arc; @@ -516,14 +516,53 @@ enum RenderMode { Preview, } -fn render_markdown(input: &str, page: &mut Page, _mode: RenderMode) { - let parser = Parser::new_ext(input, Options::all()); +fn render_markdown(text: &str, page: &mut Page, _mode: RenderMode, ctx: &Context) { + let md_options = Options::all(); + page.body.push_str("<div class=markdown-output>"); - html::push_html(&mut page.body, parser); + #[cfg(feature = "lua")] + { + use lua::template::{parse_call_args, Sub}; + + let (text, state) = lua::template::preprocess(text); + let parser = Parser::new_ext(&text, md_options); + let mut out = String::new(); + pulldown_cmark::html::push_html(&mut out, parser); + + let out = state.postprocess(&out, |sub, out| match *sub { + Sub::Raw(raw) => out.write_str(&html_escape(raw)), + Sub::Pre { attrs, content } => { + write!(out, "<pre {attrs}>{}</pre>", html_escape(content)) + } + Sub::StrayToken(_, text) => out.write_str(&html_escape(text)), + Sub::Call(text) => { + let (modfn, args) = parse_call_args(text); + + // TODO: cache module source code to avoid unnecessary git reads for repeated templates + match lua::call(&modfn, args, ctx) { + Ok(output) => out.write_str(&output), + Err(err) => write!( + out, + "<span class=error>{}: {}</span>", + html_escape(modfn.module_name), // TODO: link module + &html_escape(err.to_string()), + ), + } + } + }); + page.body.push_str(&out); + } + #[cfg(not(feature = "lua"))] + { + let parser = Parser::new_ext(text, md_options); + let mut out = String::new(); + pulldown_cmark::html::push_html(&mut out, parser); + page.body.push_str(&out); + } page.body.push_str("</div>"); } -fn get_renderer(path: &Utf8Path) -> Option<fn(&str, &mut Page, RenderMode)> { +fn get_renderer(path: &Utf8Path) -> Option<fn(&str, &mut Page, RenderMode, ctx: &Context)> { match path.extension() { Some("md") => Some(render_markdown), _ => None, diff --git a/src/post_routes.rs b/src/post_routes.rs index 51b35ec..fda1619 100644 --- a/src/post_routes.rs +++ b/src/post_routes.rs @@ -361,6 +361,6 @@ async fn preview_edit<C: Controller>( let form: EditForm = body.into_form().await?; let new_text = form.text.replace("\r\n", "\n"); let mut page = edit_text_form(&form, None, controller, &ctx, parts); - get_renderer(&ctx.path).unwrap()(&new_text, &mut page, RenderMode::Preview); + get_renderer(&ctx.path).unwrap()(&new_text, &mut page, RenderMode::Preview, &ctx); Ok(page.into()) } |