use crate::ast::{ArrowType, Edge, Flowchart, Node, NodeShape, Subgraph};
use crate::parser::common::{
PResult, attempt, direction, has_input, identifier, inline_ws, inline_ws_and_comments,
peek_end, rest_of_line, skip_ws_and_comments, text, ws1,
};
use winnow::{
Parser,
combinator::{alt, delimited, 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 first = alt((
delimited(
"(((",
take_while(1.., |c: char| c != ')' && c != '\n' && c != '\r'),
")))",
)
.map(|t: &str| (Some(NodeShape::DoubleCircle), Some(t.trim().to_string()))),
delimited(
"\x28\x28",
take_while(1.., |c: char| c != ')' && c != '\n' && c != '\r'),
"\x29\x29",
)
.map(|t: &str| (Some(NodeShape::Circle), Some(t.trim().to_string()))),
delimited("\x5b\x28", text, "\x29\x5d")
.map(|t| (Some(NodeShape::Cylinder), Some(t)))
.map(|(s, t)| (s, t)),
delimited("([", text, "])").map(|t| (Some(NodeShape::Stadium), Some(t))),
delimited("[[", text, "]]").map(|t| (Some(NodeShape::Subroutine), Some(t))),
delimited("{{", text, "}}").map(|t| (Some(NodeShape::Hexagon), Some(t))),
delimited("(", text, ")").map(|t| (Some(NodeShape::Rounded), Some(t))),
delimited("[", text, "]").map(|t| (Some(NodeShape::Rectangle), Some(t))),
delimited("{", text, "}").map(|t| (Some(NodeShape::Diamond), Some(t))),
));
let second = alt((
delimited(">", text, "]").map(|t| (Some(NodeShape::Asymmetric), Some(t))),
delimited("[/", text, "/]").map(|t| (Some(NodeShape::Parallelogram), Some(t))),
delimited("[\\", text, "\\]").map(|t| (Some(NodeShape::ParallelogramAlt), Some(t))),
delimited("[/", text, "\\]").map(|t| (Some(NodeShape::Trapezoid), Some(t))),
delimited("[\\", text, "/]").map(|t| (Some(NodeShape::TrapezoidAlt), Some(t))),
));
alt((first, second)).parse_next(input)
}
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)?;
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 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(("--", "-.", "==", "~~~")),
delimited("|", text, "|"),
arrow_type,
)
.map(|(_, label, arrow)| (arrow, Some(label))),
(
alt(("--", "-.", "==")),
inline_ws,
text,
inline_ws,
arrow_type,
)
.map(|(_, _, label, _, arrow)| (arrow, Some(label))),
(arrow_type, opt(delimited("|", text, "|"))).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,
});
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 _ = opt(preceded(("direction", ws1), direction)).parse_next(input)?;
skip_ws_and_comments(input)?;
let mut nodes = Vec::new();
let mut edges = 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) {
nodes.extend(sub.nodes);
edges.extend(sub.edges);
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 _ = take_while(1.., |c: char| c != ';' && c != '\n').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,
nodes,
edges,
})
}
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].nodes.len(), 2);
assert_eq!(fc.subgraphs[0].edges.len(), 1);
assert_eq!(fc.edges.len(), 1);
}
#[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);
}
}