Skip to main content

source_mesh_core/export/
mermaid.rs

1use std::io::Write;
2
3use anyhow::Result;
4
5use super::edge_style::CYCLE_EDGE_WIDTH;
6use super::edge_style::TEST_EDGE_COLOR;
7use super::edge_style::edge_label;
8use super::exporter::Exporter;
9use super::exporter::Options;
10use super::structure::Folder;
11use super::structure::IndexedGraph;
12use crate::cycle_presentation::group_color;
13use crate::model::DependencyKind;
14use crate::model::FolderGraph;
15
16pub struct Mermaid;
17
18impl Exporter for Mermaid {
19    fn write(&self, graph: &FolderGraph, output: &mut dyn Write) -> Result<()> {
20        self.write_with_options(graph, &Options::new(false, None), output)
21    }
22
23    fn write_grouped(&self, graph: &FolderGraph, output: &mut dyn Write) -> Result<()> {
24        self.write_with_options(graph, &Options::new(true, None), output)
25    }
26
27    fn write_with_options(&self, graph: &FolderGraph, options: &Options<'_>, output: &mut dyn Write) -> Result<()> {
28        let indexed_graph = IndexedGraph::with_cycles(graph, options.cycles())?;
29        let hierarchy = if options.group_folders() { Folder::hierarchy(&indexed_graph)? } else { Vec::new() };
30        writeln!(output, "flowchart LR")?;
31        if options.group_folders() {
32            for folder in hierarchy {
33                write_folder(&folder, output)?;
34            }
35        } else {
36            for (label, &index) in indexed_graph.nodes() {
37                write_node(label, index, output)?;
38            }
39        }
40        write_edges(&indexed_graph, output)
41    }
42}
43
44fn write_escaped_label(label: &str, output: &mut dyn Write) -> Result<()> {
45    for character in label.chars() {
46        if character.is_alphanumeric() || matches!(character, ' ' | '/' | '.' | '_' | '-' | ':') {
47            write!(output, "{character}")?;
48        } else {
49            write!(output, "#{};", u32::from(character))?;
50        }
51    }
52    Ok(())
53}
54
55fn write_node(label: &str, index: usize, output: &mut dyn Write) -> Result<()> {
56    write!(output, "    n{index}[\"")?;
57    write_escaped_label(label, output)?;
58    writeln!(output, "\"]")?;
59    Ok(())
60}
61
62fn write_folder(folder: &Folder<'_>, output: &mut dyn Write) -> Result<()> {
63    if folder.children().is_empty() {
64        return write_node(folder.display_label(), folder.index(), output);
65    }
66    write!(output, "    subgraph g{}[\"", folder.index())?;
67    write_escaped_label(folder.display_label(), output)?;
68    writeln!(output, "\"]")?;
69    if folder.dependency() {
70        write_node(folder.display_label(), folder.index(), output)?;
71    }
72    for child in folder.children() {
73        write_folder(child, output)?;
74    }
75    writeln!(output, "    end")?;
76    Ok(())
77}
78
79fn write_edges(graph: &IndexedGraph<'_>, output: &mut dyn Write) -> Result<()> {
80    for (index, edge) in graph.edges().iter().enumerate() {
81        let arrow = match edge.kind() {
82            DependencyKind::Production => "-->",
83            DependencyKind::Test => "-.->",
84        };
85        writeln!(output, "    n{} {arrow}|{}| n{}", edge.source(), edge_label(edge.kind(), edge.weight()), edge.target())?;
86        if let Some(group) = edge.cycle_group() {
87            let color = group_color(group, graph.cycle_group_count());
88            writeln!(output, "    linkStyle {index} stroke:{color},color:{color},stroke-width:{CYCLE_EDGE_WIDTH}px")?;
89        }
90        if edge.cycle_group().is_none() && edge.kind() == DependencyKind::Test {
91            writeln!(output, "    linkStyle {index} stroke:{TEST_EDGE_COLOR},color:{TEST_EDGE_COLOR}")?;
92        }
93    }
94    Ok(())
95}