use crate::ast::{ArrowType, Edge, Flowchart, Node, NodeShape, Subgraph};
use crate::parser::common::{
PResult, attempt, bare_label, direction, has_input, identifier, inline_ws,
inline_ws_and_comments, peek_end, rest_of_line, shape_label, skip_ws_and_comments, ws1,
};
use winnow::{
Parser,
combinator::{alt, fail, opt, peek, preceded},
token::{any, take_while},
};
fn node_shape_with_text<'i>(
input: &mut &'i str,
) -> PResult<'i, (Option<NodeShape>, Option<String>)> {
let long_delims = alt((
shape_label("(((", ")))").map(|t| (Some(NodeShape::DoubleCircle), Some(t))),
shape_label("((", "))").map(|t| (Some(NodeShape::Circle), Some(t))),
shape_label("[(", ")]").map(|t| (Some(NodeShape::Cylinder), Some(t))),
shape_label("([", "])").map(|t| (Some(NodeShape::Stadium), Some(t))),
shape_label("[[", "]]").map(|t| (Some(NodeShape::Subroutine), Some(t))),
shape_label("{{", "}}").map(|t| (Some(NodeShape::Hexagon), Some(t))),
shape_label("[/", "/]").map(|t| (Some(NodeShape::Parallelogram), Some(t))),
shape_label("[\\", "\\]").map(|t| (Some(NodeShape::ParallelogramAlt), Some(t))),
shape_label("[/", "\\]").map(|t| (Some(NodeShape::Trapezoid), Some(t))),
));
let short_delims = alt((
shape_label("[\\", "/]").map(|t| (Some(NodeShape::TrapezoidAlt), Some(t))),
shape_label("(", ")").map(|t| (Some(NodeShape::Rounded), Some(t))),
shape_label("[", "]").map(|t| (Some(NodeShape::Rectangle), Some(t))),
shape_label("{", "}").map(|t| (Some(NodeShape::Diamond), Some(t))),
shape_label(">", "]").map(|t| (Some(NodeShape::Asymmetric), Some(t))),
));
alt((long_delims, short_delims)).parse_next(input)
}
fn node_suffix<'i>(input: &mut &'i str) -> PResult<'i, ()> {
loop {
if input.starts_with(":::") {
let _ = ":::".parse_next(input)?;
let _ = take_while(0.., |c: char| {
c.is_alphanumeric() || matches!(c, '_' | '-' | '.')
})
.parse_next(input)?;
continue;
}
if input.starts_with("@{") {
let _ = shape_label("@{", "}").parse_next(input)?;
continue;
}
break;
}
Ok(())
}
fn node_definition<'i>(input: &mut &'i str) -> PResult<'i, Node> {
let _ = peek((identifier, node_shape_with_text)).parse_next(input)?;
let id = identifier.parse_next(input)?;
let (shape, txt) = node_shape_with_text.parse_next(input)?;
let _ = node_suffix(input);
Ok(Node {
id,
shape,
text: txt,
})
}
fn bare_node<'i>(input: &mut &'i str) -> PResult<'i, Node> {
let start = *input;
let id = identifier.parse_next(input)?;
let _ = node_suffix(input);
let rest = *input;
let is_end = rest.is_empty()
|| rest.starts_with('\n')
|| rest.starts_with("\r\n")
|| rest.starts_with(';');
if is_end {
Ok(Node {
id,
shape: None,
text: None,
})
} else {
*input = start;
fail.parse_next(input)
}
}
fn arrow_type<'i>(input: &mut &'i str) -> PResult<'i, ArrowType> {
let first = alt((
"<-->".map(|_| ArrowType::Both),
"o--o".map(|_| ArrowType::MultiCircle),
"x--x".map(|_| ArrowType::MultiCross),
"--o".map(|_| ArrowType::Circle),
"--x".map(|_| ArrowType::Cross),
"~~~".map(|_| ArrowType::Invisible),
));
let second = alt((
"==>".map(|_| ArrowType::Thick),
"-.->".map(|_| ArrowType::Dotted),
"-->".map(|_| ArrowType::Solid),
"---".map(|_| ArrowType::NoArrow),
));
alt((first, second)).parse_next(input)
}
fn link_arrow<'i>(input: &mut &'i str) -> PResult<'i, (ArrowType, Option<String>)> {
alt((
(
alt(("--", "-.", "==", "~~~")),
shape_label("|", "|"),
arrow_type,
)
.map(|(_, label, arrow)| (arrow, Some(label))),
(
alt(("--", "-.", "==")),
inline_ws,
bare_label,
inline_ws,
arrow_type,
)
.map(|(_, _, label, _, arrow)| (arrow, Some(label))),
(arrow_type, opt(shape_label("|", "|"))).map(|(arrow, label)| (arrow, label)),
arrow_type.map(|arrow| (arrow, None)),
))
.parse_next(input)
}
fn edge_endpoint<'i>(input: &mut &'i str) -> PResult<'i, (String, Option<Node>)> {
let id = identifier.parse_next(input)?;
let node = attempt(node_shape_with_text, input).map(|(shape, text)| Node {
id: id.clone(),
shape,
text,
});
let _ = node_suffix(input);
Ok((id, node))
}
fn endpoint_list<'i>(input: &mut &'i str) -> PResult<'i, (Vec<String>, Vec<Node>)> {
let (first_id, first_node) = edge_endpoint.parse_next(input)?;
let mut ids = vec![first_id];
let mut nodes = Vec::new();
if let Some(n) = first_node {
nodes.push(n);
}
loop {
let before = *input;
inline_ws_and_comments(input)?;
if !input.starts_with('&') {
*input = before;
break;
}
let _ = '&'.parse_next(input)?;
inline_ws_and_comments(input)?;
match attempt(edge_endpoint, input) {
Some((id, node)) => {
ids.push(id);
nodes.extend(node);
}
None => {
*input = before;
break;
}
}
}
Ok((ids, nodes))
}
fn chain_edges<'i>(input: &mut &'i str) -> PResult<'i, (Vec<Edge>, Vec<Node>)> {
let (mut sources, mut nodes) = endpoint_list.parse_next(input)?;
let mut edges: Vec<Edge> = Vec::new();
loop {
let before = *input;
inline_ws_and_comments(input)?;
let Some((arrow, label)) = attempt(link_arrow, input) else {
*input = before;
break;
};
inline_ws_and_comments(input)?;
let (targets, target_nodes) = endpoint_list.parse_next(input)?;
nodes.extend(target_nodes);
for s in &sources {
for t in &targets {
edges.push(Edge {
source: s.clone(),
target: t.clone(),
arrow_type: arrow.clone(),
label: label.clone(),
});
}
}
sources = targets;
}
if edges.is_empty() {
return Err(winnow::error::InputError::at(*input));
}
Ok((edges, nodes))
}
fn subgraph<'i>(input: &mut &'i str) -> PResult<'i, Subgraph> {
let _ = "subgraph".parse_next(input)?;
skip_ws_and_comments(input)?;
let title = opt(rest_of_line).parse_next(input)?;
skip_ws_and_comments(input)?;
let sub_direction = opt(preceded(("direction", ws1), direction)).parse_next(input)?;
skip_ws_and_comments(input)?;
let mut nodes = Vec::new();
let mut edges = Vec::new();
let mut subgraphs = Vec::new();
while has_input(input) {
skip_ws_and_comments(input)?;
if peek_end(input).is_ok() {
break;
}
if let Some(sub) = attempt(subgraph, input) {
subgraphs.push(sub);
continue;
}
if let Some((chain, declared)) = attempt(chain_edges, input) {
edges.extend(chain);
nodes.extend(declared);
continue;
}
if let Some(node) = attempt(node_definition, input) {
nodes.push(node);
continue;
}
if let Some(node) = attempt(bare_node, input) {
nodes.push(node);
continue;
}
let before = input.len();
let _ = take_while(0.., |c: char| c != ';' && c != '\n' && c != '\r').parse_next(input)?;
let _ = opt(("\r\n", "\n")).parse_next(input)?;
if input.len() == before {
let _ = any.parse_next(input)?;
}
}
let _ = "end".parse_next(input)?;
let mut node_ids: std::collections::HashSet<String> =
nodes.iter().map(|n| n.id.clone()).collect();
for e in &edges {
for ep in [&e.source, &e.target] {
if node_ids.insert(ep.clone()) {
nodes.push(Node {
id: ep.clone(),
shape: None,
text: None,
});
}
}
}
Ok(Subgraph {
title,
direction: sub_direction,
nodes,
edges,
subgraphs,
})
}
fn keyword_ci<'i>(kw: &'static str) -> impl FnMut(&mut &'i str) -> PResult<'i, ()> {
move |input: &mut &'i str| {
let head = input
.get(..kw.len())
.ok_or_else(|| winnow::error::InputError::at(*input))?;
if head.eq_ignore_ascii_case(kw) {
*input = &input[kw.len()..];
Ok(())
} else {
Err(winnow::error::InputError::at(*input))
}
}
}
pub fn flowchart_diagram<'i>(input: &mut &'i str) -> PResult<'i, Flowchart> {
alt((keyword_ci("graph"), keyword_ci("flowchart"))).parse_next(input)?;
skip_ws_and_comments(input)?;
let dir = opt(direction).parse_next(input)?;
skip_ws_and_comments(input)?;
let mut nodes = Vec::new();
let mut edges = Vec::new();
let mut subgraphs = Vec::new();
while has_input(input) {
skip_ws_and_comments(input)?;
if input.is_empty() {
break;
}
if let Some(sub) = attempt(subgraph, input) {
subgraphs.push(sub);
continue;
}
if let Some((chain, declared)) = attempt(chain_edges, input) {
edges.extend(chain);
nodes.extend(declared);
continue;
}
if let Some(node) = attempt(node_definition, input) {
nodes.push(node);
continue;
}
if let Some(node) = attempt(bare_node, input) {
nodes.push(node);
continue;
}
let before = input.len();
let _ = take_while(0.., |c: char| c != ';' && c != '\n' && c != '\r').parse_next(input)?;
let _ = opt(("\r\n", "\n")).parse_next(input)?;
if input.len() == before {
let _ = any.parse_next(input)?;
}
}
let mut node_ids: std::collections::HashSet<String> =
nodes.iter().map(|n| n.id.clone()).collect();
for e in &edges {
for ep in [&e.source, &e.target] {
if node_ids.insert(ep.clone()) {
nodes.push(Node {
id: ep.clone(),
shape: None,
text: None,
});
}
}
}
Ok(Flowchart {
direction: dir,
nodes,
edges,
subgraphs,
})
}
pub fn trailing_ws<'i>(input: &mut &'i str) -> PResult<'i, ()> {
skip_ws_and_comments(input)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::Direction;
fn parse(input: &str) -> Flowchart {
let mut stream: &str = input;
let fc = flowchart_diagram.parse_next(&mut stream).unwrap();
assert!(stream.is_empty(), "trailing input: {:?}", stream);
fc
}
#[test]
fn simple_chain() {
let fc = parse("flowchart TD\nA[Start] --> B{Decision} --> C[End]");
assert_eq!(fc.direction, Some(Direction::TD));
}
#[test]
fn nodes_and_edges_separate() {
let fc = parse("flowchart TD\nA[Start]\nB{Decision}\nC[End]\nA --> B\nB --> C");
assert_eq!(fc.nodes.len(), 3);
assert_eq!(fc.edges.len(), 2);
assert_eq!(fc.nodes[0].shape, Some(NodeShape::Rectangle));
assert_eq!(fc.nodes[0].text.as_deref(), Some("Start"));
assert_eq!(fc.nodes[1].shape, Some(NodeShape::Diamond));
assert_eq!(fc.edges[0].arrow_type, ArrowType::Solid);
assert_eq!(fc.edges[0].source, "A");
assert_eq!(fc.edges[0].target, "B");
}
#[test]
fn labeled_edges() {
let fc = parse("flowchart LR\nA -->|Yes| B\nA -->|No| C");
assert_eq!(fc.edges.len(), 2);
assert_eq!(fc.edges[0].label.as_deref(), Some("Yes"));
assert_eq!(fc.edges[1].label.as_deref(), Some("No"));
}
#[test]
fn bare_label_edge_with_spaces() {
let fc = parse(
"flowchart TD\nA[Start]\nB{Check}\nC[End]\nA --> B\nB -- yes --> C\nB -- no --> A",
);
assert_eq!(fc.edges.len(), 3, "应解析出 3 条边");
assert_eq!(fc.edges[1].source, "B");
assert_eq!(fc.edges[1].target, "C");
assert_eq!(fc.edges[1].label.as_deref(), Some("yes"));
assert_eq!(fc.edges[2].source, "B");
assert_eq!(fc.edges[2].target, "A");
assert_eq!(fc.edges[2].label.as_deref(), Some("no"));
}
#[test]
fn all_shapes() {
let fc = parse(
"flowchart TD\nA[rect]\nB(rounded)\nC([stadium])\nD[[subroutine]]\nE{diamond}\nF{{hexagon}}\nG((circle))\nH(((double)))\nI[(cylinder)]\nJ>asym]\nK[/para/]\nL[\\para_alt\\]\nM[/trap\\]\nN[\\trap_alt/]",
);
let shapes: Vec<_> = fc.nodes.iter().map(|n| n.shape.clone()).collect();
assert_eq!(
shapes,
vec![
Some(NodeShape::Rectangle),
Some(NodeShape::Rounded),
Some(NodeShape::Stadium),
Some(NodeShape::Subroutine),
Some(NodeShape::Diamond),
Some(NodeShape::Hexagon),
Some(NodeShape::Circle),
Some(NodeShape::DoubleCircle),
Some(NodeShape::Cylinder),
Some(NodeShape::Asymmetric),
Some(NodeShape::Parallelogram),
Some(NodeShape::ParallelogramAlt),
Some(NodeShape::Trapezoid),
Some(NodeShape::TrapezoidAlt),
]
);
}
#[test]
fn arrow_types() {
let fc = parse(
"flowchart LR\nA --> B\nC -.-> D\nE ==> F\nG --- H\nI --o J\nK --x L\nM <--> N\nO ~~~ P\nQ o--o R\nS x--x T",
);
let arrows: Vec<_> = fc.edges.iter().map(|e| e.arrow_type.clone()).collect();
assert_eq!(
arrows,
vec![
ArrowType::Solid,
ArrowType::Dotted,
ArrowType::Thick,
ArrowType::NoArrow,
ArrowType::Circle,
ArrowType::Cross,
ArrowType::Both,
ArrowType::Invisible,
ArrowType::MultiCircle,
ArrowType::MultiCross,
]
);
}
#[test]
fn subgraph_with_title() {
let fc =
parse("flowchart TD\nsubgraph One\nA --> B\nend\nsubgraph Two\nC --> D\nend\nA --> C");
assert_eq!(fc.subgraphs.len(), 2);
assert_eq!(fc.subgraphs[0].title.as_deref(), Some("One"));
assert_eq!(fc.subgraphs[0].edges.len(), 1);
assert_eq!(fc.edges.len(), 1);
}
#[test]
fn nested_subgraph() {
let fc = parse("flowchart TD\nsubgraph outer\nsubgraph inner\nA --> B\nend\nend\nC --> A");
assert_eq!(fc.subgraphs.len(), 1);
assert_eq!(fc.subgraphs[0].title.as_deref(), Some("outer"));
assert_eq!(fc.subgraphs[0].subgraphs.len(), 1);
assert_eq!(fc.subgraphs[0].subgraphs[0].title.as_deref(), Some("inner"));
assert_eq!(fc.subgraphs[0].nodes.len(), 0);
assert_eq!(fc.subgraphs[0].subgraphs[0].nodes.len(), 2);
assert_eq!(fc.subgraphs[0].subgraphs[0].edges.len(), 1);
assert_eq!(fc.edges.len(), 1);
}
#[test]
fn subgraph_direction_is_preserved() {
let fc = parse("flowchart TD\nsubgraph One\ndirection LR\nA --> B\nend");
assert_eq!(fc.subgraphs[0].direction, Some(Direction::LR));
}
#[test]
fn quoted_ids_and_comments() {
let fc = parse("flowchart TD\nA[\"Start\"]\nB[End]\nA --> B");
assert_eq!(fc.nodes[0].text.as_deref(), Some("Start"));
assert_eq!(fc.edges.len(), 1);
}
#[test]
fn labels_may_contain_spaces_and_punctuation() {
let fc = parse(
"flowchart TD\nA[Hello World] --> B[HTTP/2]\nB[Start-Here] --> C[foo.bar]\nC -->|Get money| D[End]",
);
assert_eq!(fc.edges.len(), 3, "3 条边都应解析");
let texts: Vec<_> = fc
.nodes
.iter()
.map(|n| n.text.clone().unwrap_or_default())
.collect();
assert!(texts.contains(&"Hello World".to_string()));
assert!(texts.contains(&"HTTP/2".to_string()));
assert!(texts.contains(&"Start-Here".to_string()));
assert!(texts.contains(&"foo.bar".to_string()));
assert_eq!(fc.edges[2].label.as_deref(), Some("Get money"));
}
#[test]
fn bare_labels_may_contain_spaces() {
let fc = parse("flowchart TD\nA -- yes please --> B\nB -- e-mail --> C");
assert_eq!(fc.edges.len(), 2);
assert_eq!(fc.edges[0].label.as_deref(), Some("yes please"));
assert_eq!(fc.edges[1].label.as_deref(), Some("e-mail"));
}
#[test]
fn labels_may_contain_apostrophes() {
let fc = parse("flowchart TD\nA[Don't stop] --> B[It's fine]\nB -- Don't go --> C");
assert_eq!(fc.nodes[0].text.as_deref(), Some("Don't stop"));
assert_eq!(fc.nodes[1].text.as_deref(), Some("It's fine"));
assert_eq!(fc.edges[1].label.as_deref(), Some("Don't go"));
}
#[test]
fn quoted_label_may_contain_closing_delimiter() {
let fc = parse("flowchart TD\nA[\"a]b\"] --> B[\"c}d\"]");
assert_eq!(fc.nodes[0].text.as_deref(), Some("a]b"));
assert_eq!(fc.nodes[1].text.as_deref(), Some("c}d"));
assert_eq!(fc.edges.len(), 1);
}
#[test]
fn style_and_extended_shape_suffixes_are_consumed() {
let fc = parse(
"flowchart TD\nA[Hello]:::important --> B[World]\nB:::other --> C@{ shape: rect, label: \"C\" }",
);
assert_eq!(fc.edges.len(), 2, "带后缀的边不得丢失");
assert_eq!(fc.nodes[0].text.as_deref(), Some("Hello"));
let ids: Vec<_> = fc.nodes.iter().map(|n| n.id.as_str()).collect();
assert!(ids.contains(&"A"));
assert!(ids.contains(&"B"));
assert!(ids.contains(&"C"));
}
}