use std::collections::HashMap;
use std::sync::{Arc, OnceLock};
pub(super) fn diagram_svg(
source: &str,
labels: &HashMap<String, String>,
) -> Result<String, String> {
let anchors = |id: &str| {
labels.get(id).map(|label| markdoc_mermaid::Anchor {
label: label.clone(),
href: String::new(),
})
};
markdoc_mermaid::render(
source,
&anchors,
&markdoc_mermaid::Options {
class: String::new(),
link: false,
themeable: false,
layout: markdoc_mermaid::Layout::default(),
},
)
.map(|diagram| diagram.svg)
.map_err(|e| e.to_string())
}
fn svg_options() -> &'static usvg::Options<'static> {
static OPTIONS: OnceLock<usvg::Options<'static>> = OnceLock::new();
OPTIONS.get_or_init(|| {
let mut options = usvg::Options::default();
let mut db = usvg::fontdb::Database::new();
db.load_system_fonts();
if let Some(family) = resolvable_sans(&db) {
db.set_sans_serif_family(family.clone());
options.font_family = family;
}
options.fontdb = Arc::new(db);
options
})
}
fn resolvable_sans(db: &usvg::fontdb::Database) -> Option<String> {
let installed = |want: &str| {
db.faces()
.any(|face| face.families.iter().any(|(family, _)| family == want))
};
for want in [
"Noto Sans",
"DejaVu Sans",
"Liberation Sans",
"Arial",
"Helvetica",
] {
if installed(want) {
return Some(want.to_string());
}
}
db.faces()
.next()
.and_then(|face| face.families.first().map(|(family, _)| family.clone()))
}
fn text_nodes(group: &usvg::Group) -> usize {
group
.children()
.iter()
.map(|node| match node {
usvg::Node::Text(_) => 1,
usvg::Node::Group(g) => text_nodes(g),
_ => 0,
})
.sum()
}
pub(super) fn diagram_tree(
source: &str,
labels: &HashMap<String, String>,
) -> Result<usvg::Tree, String> {
let svg = diagram_svg(source, labels)?;
let tree = usvg::Tree::from_data(svg.as_bytes(), svg_options())
.map_err(|e| format!("the diagram SVG could not be read back: {e}"))?;
ensure_labels_survived(&svg, &tree)?;
Ok(tree)
}
fn ensure_labels_survived(svg: &str, tree: &usvg::Tree) -> Result<(), String> {
if svg.contains("<text") && text_nodes(tree.root()) == 0 {
return Err("the diagram's labels were dropped because no usable \
font was found. usvg shapes text when it parses, so this \
would otherwise print as correctly-placed, entirely blank \
boxes. Install a sans-serif font -- Noto Sans, DejaVu \
Sans or Liberation Sans -- where markdoc-pdf runs."
.to_string());
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn labels() -> HashMap<String, String> {
HashMap::from([
("step_one".to_string(), "6.4 Cannot connect".to_string()),
(
"step_two".to_string(),
"6.5 Can you ping the switch?".to_string(),
),
])
}
const SRC: &str = "flowchart TD\n step_one --> step_two\n";
fn drawn_text(svg: &str) -> String {
svg.split("<tspan")
.skip(1)
.filter_map(|tspan| {
let body = &tspan[tspan.find('>')? + 1..];
Some(&body[..body.find("</tspan>")?])
})
.collect::<Vec<_>>()
.join(" ")
}
#[test]
fn a_node_is_drawn_with_the_numbered_heading_it_points_at() {
let svg = diagram_svg(SRC, &labels()).expect("renders");
assert!(
drawn_text(&svg).contains("6.5 Can you ping the switch?"),
"{svg}"
);
}
#[test]
fn colours_are_literal_because_usvg_resolves_var_to_black() {
let svg = diagram_svg(SRC, &labels()).expect("renders");
assert!(!svg.contains("var(--"), "{svg}");
}
#[test]
fn no_click_is_emitted_because_usvg_discards_links() {
let svg = diagram_svg(SRC, &labels()).expect("renders");
assert!(!svg.contains("<a "), "{svg}");
}
#[test]
fn the_root_keeps_its_size_so_the_page_can_scale_it() {
let svg = diagram_svg(SRC, &labels()).expect("renders");
let open = &svg[..svg.find('>').unwrap()];
assert!(open.contains("width="), "{open}");
assert!(open.contains("height="), "{open}");
}
#[test]
fn a_diagram_that_will_not_parse_reports_why_rather_than_panicking() {
assert!(diagram_svg("", &labels()).is_err());
}
#[test]
fn the_parsed_tree_still_has_its_text() {
let tree = diagram_tree(SRC, &labels()).expect("renders");
assert!(
text_nodes(tree.root()) > 0,
"the diagram parsed to shapes with no text -- check the fontdb"
);
}
#[test]
fn labels_dropped_for_want_of_a_font_are_an_error_not_a_blank_diagram() {
let svg = diagram_svg(SRC, &labels()).expect("renders");
let bare = usvg::Options::default();
let tree = usvg::Tree::from_data(svg.as_bytes(), &bare).expect("parses");
assert!(svg.contains("<text"), "the fixture must contain text");
assert_eq!(
text_nodes(tree.root()),
0,
"an empty fontdb should have dropped every label"
);
assert!(
ensure_labels_survived(&svg, &tree).is_err(),
"the guard must turn a blank diagram into an error"
);
}
#[test]
fn a_font_the_diagram_never_names_is_still_used_for_its_labels() {
let svg = diagram_svg(SRC, &labels()).expect("renders");
let mut system = usvg::fontdb::Database::new();
system.load_system_fonts();
let named_by_the_stack = ["DejaVu Sans", "Liberation Sans", "Arial", "Helvetica"];
let picked = system.faces().find_map(|face| match &face.source {
usvg::fontdb::Source::File(path) => {
let family = face.families.first()?.0.clone();
(!named_by_the_stack.contains(&family.as_str()) && !svg.contains(&family))
.then(|| (path.clone(), family))
}
_ => None,
});
let Some((path, family)) = picked else {
panic!("no system font file to test with -- install any sans font");
};
let mut lone = usvg::fontdb::Database::new();
lone.load_font_file(&path).expect("loads");
let unmapped = usvg::Options {
font_family: "sans-serif".to_string(),
fontdb: Arc::new(lone.clone()),
..Default::default()
};
let dropped = usvg::Tree::from_data(svg.as_bytes(), &unmapped).expect("parses");
assert_eq!(
text_nodes(dropped.root()),
0,
"{family} should not have been reachable through the keyword alone"
);
lone.set_sans_serif_family(family.clone());
let mapped = usvg::Options {
font_family: family.clone(),
fontdb: Arc::new(lone),
..Default::default()
};
let kept = usvg::Tree::from_data(svg.as_bytes(), &mapped).expect("parses");
assert!(
text_nodes(kept.root()) > 0,
"pointing sans-serif at {family} should have kept the labels"
);
assert!(ensure_labels_survived(&svg, &kept).is_ok());
}
}