Fix format for util.rs

src/elements/graphviz.rs

@@ -0,0 +1,267 @@
+use std::{io::{Read, Write}, ops::Range, process::{Command, Stdio}, rc::Rc, sync::Once};
+
+use ariadne::{Fmt, Label, Report, ReportKind};
+use crypto::{digest::Digest, sha2::Sha512};
+use mlua::{Function, Lua};
+use regex::{Captures, Regex};
+
+use crate::{cache::cache::{Cached, CachedError}, compiler::compiler::{Compiler, Target}, document::{document::Document, element::{ElemKind, Element}}, parser::{parser::Parser, rule::RegexRule, source::{Source, Token}, util}};
+
+#[derive(Debug, PartialEq, Eq)]
+enum TexKind
+{
+	Block,
+	Inline,
+}
+
+impl From<&TexKind> for ElemKind
+{
+    fn from(value: &TexKind) -> Self {
+		match value {
+			TexKind::Inline => ElemKind::Inline,
+			_ => ElemKind::Block
+		}
+    }
+}
+
+#[derive(Debug)]
+struct Tex
+{
+	location: Token,
+	block: TexKind,
+	env: String,
+	tex: String,
+	caption: Option<String>,
+}
+
+impl Tex {
+    fn new(location: Token, block: TexKind, env: String, tex: String, caption: Option<String>) -> Self {
+        Self { location, block, env, tex, caption }
+    }
+
+	fn format_latex(fontsize: &String, preamble: &String, tex: &String) -> FormattedTex
+	{
+		FormattedTex(format!(r"\documentclass[{}pt,preview]{{standalone}}
+{}
+\begin{{document}}
+\begin{{preview}}
+{}
+\end{{preview}}
+\end{{document}}",
+		fontsize, preamble, tex))
+	}
+}
+
+struct FormattedTex(String);
+
+impl FormattedTex
+{
+	/// Renders latex to svg
+	fn latex_to_svg(&self, exec: &String, fontsize: &String) -> Result<String, String>
+	{
+		print!("Rendering LaTex `{}`... ", self.0);
+		let process = match Command::new(exec)
+			.arg("--fontsize").arg(fontsize)
+			.stdout(Stdio::piped())
+			.stdin(Stdio::piped())
+			.spawn()
+			{
+				Err(e) => return Err(format!("Could not spawn `{exec}`: {}", e)),
+				Ok(process) => process
+			};
+
+		if let Err(e) = process.stdin.unwrap().write_all(self.0.as_bytes())
+		{
+			panic!("Unable to write to `latex2svg`'s stdin: {}", e);
+		}
+
+		let mut result = String::new();
+		match process.stdout.unwrap().read_to_string(&mut result)
+		{
+			Err(e) => panic!("Unable to read `latex2svg` stdout: {}", e),
+			Ok(_) => {}
+		}
+		println!("Done!");
+
+		Ok(result)
+	}
+}
+
+impl Cached for FormattedTex
+{
+    type Key = String;
+    type Value = String;
+
+    fn sql_table() -> &'static str {
+		"CREATE TABLE IF NOT EXISTS cached_tex (
+				digest TEXT PRIMARY KEY,
+				svg    BLOB NOT NULL);"
+    }
+
+    fn sql_get_query() -> &'static str {
+		"SELECT svg FROM cached_tex WHERE digest = (?1)"
+    }
+
+    fn sql_insert_query() -> &'static str {
+		"INSERT INTO cached_tex (digest, svg) VALUES (?1, ?2)"
+    }
+
+    fn key(&self) -> <Self as Cached>::Key {
+		let mut hasher = Sha512::new();
+		hasher.input(self.0.as_bytes());
+
+		hasher.result_str()
+    }
+}
+
+impl Element for Tex {
+    fn location(&self) -> &Token { &self.location }
+
+    fn kind(&self) -> ElemKind { (&self.block).into() }
+
+    fn element_name(&self) -> &'static str { "LaTeX" }
+
+    fn to_string(&self) -> String { format!("{self:#?}") }
+
+    fn compile(&self, compiler: &Compiler, document: &dyn Document)
+		-> Result<String, String> {
+
+		match compiler.target() {
+			Target::HTML => {
+				static CACHE_INIT : Once = Once::new();
+				CACHE_INIT.call_once(|| if let Some(mut con) = compiler.cache() {
+					if let Err(e) = FormattedTex::init(&mut con)
+					{
+						eprintln!("Unable to create cache table: {e}");
+					}
+				});
+
+				let exec = document.get_variable(format!("tex.{}.exec", self.env).as_str())
+					.map_or("latex2svg".to_string(), |var| var.to_string());
+				// FIXME: Because fontsize is passed as an arg, verify that it cannot be used to execute python/shell code
+				let fontsize = document.get_variable(format!("tex.{}.fontsize", self.env).as_str())
+					.map_or("12".to_string(), |var| var.to_string());
+				let preamble = document.get_variable(format!("tex.{}.preamble", self.env).as_str())
+					.map_or("".to_string(), |var| var.to_string());
+				let prepend = if self.block == TexKind::Inline { "".to_string() }
+				else
+				{
+					document.get_variable(format!("tex.{}.block_prepend", self.env).as_str())
+						.map_or("".to_string(), |var| var.to_string()+"\n")
+				};
+
+				let latex = match self.block
+				{
+					TexKind::Inline => Tex::format_latex(
+						&fontsize,
+						&preamble,
+						&format!("${{{}}}$", self.tex)),
+					_ => Tex::format_latex(
+						&fontsize,
+						&preamble,
+						&format!("{prepend}{}", self.tex))
+				};
+
+				if let Some(mut con) = compiler.cache()
+				{
+					match latex.cached(&mut con, |s| s.latex_to_svg(&exec, &fontsize))
+					{
+						Ok(s) => Ok(s),
+						Err(e) => match e
+						{
+							CachedError::SqlErr(e) => Err(format!("Querying the cache failed: {e}")),
+							CachedError::GenErr(e) => Err(e)
+						}
+					}
+				}
+				else
+				{
+					latex.latex_to_svg(&exec, &fontsize)
+				}
+			}
+			_ => todo!("Unimplemented")
+		}
+    }
+}
+
+pub struct TexRule {
+	re: [Regex; 2],
+}
+
+impl TexRule {
+	pub fn new() -> Self {
+		Self {
+			re: [
+				Regex::new(r"\$\|(?:\[(.*)\])?(?:((?:\\.|[^\\\\])*?)\|\$)?").unwrap(),
+				Regex::new(r"\$(?:\[(.*)\])?(?:((?:\\.|[^\\\\])*?)\$)?").unwrap(),
+			],
+		}
+	}
+}
+
+impl RegexRule for TexRule
+{
+    fn name(&self) -> &'static str { "Tex" }
+
+    fn regexes(&self) -> &[regex::Regex] { &self.re }
+
+    fn on_regex_match(&self, index: usize, parser: &dyn Parser, document: &dyn Document, token: Token, matches: Captures)
+		-> Vec<Report<'_, (Rc<dyn Source>, Range<usize>)>> {
+		let mut reports = vec![];
+
+		let tex_env = matches.get(1)
+			.and_then(|env| Some(env.as_str().trim_start().trim_end()))
+			.and_then(|env| (!env.is_empty()).then_some(env))
+			.unwrap_or("main");
+
+		let tex_content = match matches.get(2)
+		{
+			// Unterminated `$`
+			None => {
+				reports.push(
+					Report::build(ReportKind::Error, token.source(), token.start())
+					.with_message("Unterminated Tex Code")
+					.with_label(
+						Label::new((token.source().clone(), token.range.clone()))
+						.with_message(format!("Missing terminating `{}` after first `{}`",
+							["|$", "$"][index].fg(parser.colors().info),
+							["$|", "$"][index].fg(parser.colors().info)))
+						.with_color(parser.colors().error))
+					.finish());
+				return reports;
+			}
+			Some(content) => {
+				let processed = util::process_escaped('\\', ["|$", "$"][index],
+					content.as_str().trim_start().trim_end());
+
+				if processed.is_empty()
+				{
+					reports.push(
+						Report::build(ReportKind::Warning, token.source(), content.start())
+						.with_message("Empty Tex Code")
+						.with_label(
+							Label::new((token.source().clone(), content.range()))
+							.with_message("Tex code is empty")
+							.with_color(parser.colors().warning))
+						.finish());
+				}
+				processed
+			}
+		};
+
+		// TODO: Caption
+
+		parser.push(document, Box::new(Tex::new(
+			token,
+			if index == 1 { TexKind::Inline } else { TexKind::Block },
+			tex_env.to_string(),
+			tex_content,
+			None,
+		)));
+
+		reports
+    }
+
+	// TODO
+	fn lua_bindings<'lua>(&self, _lua: &'lua Lua) -> Vec<(String, Function<'lua>)> { vec![] }
+}