use crate::ast::{
Message, MessageActivation, MessageArrow, Note, NotePlacement, Participant, ParticipantKind,
SequenceBlock, SequenceBlockKind, SequenceBranch, SequenceDiagram, SequenceItem,
SequenceStatement,
};
use crate::parser::common::{
PResult, attempt, consume_line, has_input, inline_ws, inline_ws_and_comments, keyword,
participant_kind, quoted_string, rest_of_line, skip_line, skip_ws_and_comments,
};
use winnow::{
Parser,
combinator::{alt, opt, preceded},
token::take_while,
};
pub fn sequence_diagram<'i>(input: &mut &'i str) -> PResult<'i, SequenceDiagram> {
keyword("sequenceDiagram").parse_next(input)?;
skip_ws_and_comments(input)?;
let mut participants = Vec::new();
let mut statements = Vec::new();
while has_input(input) {
skip_ws_and_comments(input)?;
if input.is_empty() {
break;
}
if let Some(p) = attempt(participant_decl, input) {
participants.push(p);
continue;
}
if let Some(stmt) = attempt(block_statement, input) {
statements.push(stmt);
continue;
}
if let Some(stmt) = attempt(note_statement, input) {
statements.push(stmt);
continue;
}
if let Some(stmt) = attempt(message_statement, input) {
statements.push(stmt);
continue;
}
skip_line(input)?;
}
Ok(SequenceDiagram {
participants,
statements,
})
}
fn participant_decl<'i>(input: &mut &'i str) -> PResult<'i, Participant> {
let kind = alt((
keyword("participant").map(|_| ParticipantKind::Participant),
participant_kind,
))
.parse_next(input)?;
inline_ws(input)?;
let name = p_name.parse_next(input)?;
inline_ws(input)?;
let alias = opt(preceded((keyword("as"), inline_ws), p_name)).parse_next(input)?;
inline_ws(input)?;
if !(input.is_empty() || input.starts_with('\n') || input.starts_with('\r')) {
return Err(winnow::error::InputError::at(*input));
}
let _ = opt(("\r\n", "\n")).parse_next(input)?;
Ok(Participant { name, alias, kind })
}
fn p_name<'i>(input: &mut &'i str) -> PResult<'i, String> {
alt((quoted_string, seq_id)).parse_next(input)
}
fn seq_id<'i>(input: &mut &'i str) -> PResult<'i, String> {
take_while(1.., |c: char| c.is_alphanumeric() || c == '_')
.map(|s: &str| s.to_string())
.parse_next(input)
}
fn message_statement<'i>(input: &mut &'i str) -> PResult<'i, SequenceStatement> {
let from = p_name.parse_next(input)?;
inline_ws_and_comments(input)?;
let (arrow, activation) = arrow_with_activation.parse_next(input)?;
inline_ws_and_comments(input)?;
let to = p_name.parse_next(input)?;
inline_ws_and_comments(input)?;
let text = opt(preceded(':', rest_of_line)).parse_next(input)?;
Ok(SequenceStatement::Message(Message {
from,
to,
arrow,
activation,
text,
}))
}
fn arrow_with_activation<'i>(
input: &mut &'i str,
) -> PResult<'i, (MessageArrow, Option<MessageActivation>)> {
let base = alt((
"<<->>".map(|_| MessageArrow::Both),
"<<-->>".map(|_| MessageArrow::Both),
"->>".map(|_| MessageArrow::SolidTip),
"-->>".map(|_| MessageArrow::DashedTip),
"->x".map(|_| MessageArrow::Cross),
"--x".map(|_| MessageArrow::Cross),
alt((
"--)".map(|_| MessageArrow::Open),
"-)".map(|_| MessageArrow::Open),
"->".map(|_| MessageArrow::Solid),
alt((
"-->".map(|_| MessageArrow::Dashed),
"-x".map(|_| MessageArrow::Cross),
alt((
"x->".map(|_| MessageArrow::Open),
"x-->".map(|_| MessageArrow::Open),
)),
)),
)),
))
.parse_next(input)?;
let activation = opt(alt((
'+'.map(|_| MessageActivation::Activate),
'-'.map(|_| MessageActivation::Deactivate),
)))
.parse_next(input)?;
Ok((base, activation))
}
fn note_statement<'i>(input: &mut &'i str) -> PResult<'i, SequenceStatement> {
keyword("Note").parse_next(input)?;
skip_ws_and_comments(input)?;
let placement = alt((
keyword("left of").map(|_| NotePlacement::LeftOf),
keyword("right of").map(|_| NotePlacement::RightOf),
keyword("over").map(|_| NotePlacement::Over),
))
.parse_next(input)?;
skip_ws_and_comments(input)?;
let targets = if placement == NotePlacement::Over {
let first = p_name.parse_next(input)?;
let mut targets = vec![first];
loop {
skip_ws_and_comments(input)?;
if let Ok(t) = preceded(',', preceded(skip_ws_and_comments, p_name)).parse_next(input) {
targets.push(t);
} else {
break;
}
}
targets
} else {
vec![p_name.parse_next(input)?]
};
skip_ws_and_comments(input)?;
let text = opt(preceded(':', rest_of_line))
.parse_next(input)?
.unwrap_or_default();
Ok(SequenceStatement::Note(Note {
placement,
targets,
text,
}))
}
fn at_block_end(input: &str) -> bool {
input.strip_prefix("end").is_some_and(|rest| {
rest.is_empty() || rest.starts_with(|c: char| c.is_whitespace() || c == ';')
})
}
fn block_statement<'i>(input: &mut &'i str) -> PResult<'i, SequenceStatement> {
let kind = alt((
keyword("loop").map(|_| SequenceBlockKind::Loop),
keyword("alt").map(|_| SequenceBlockKind::Alt),
keyword("opt").map(|_| SequenceBlockKind::Opt),
keyword("par").map(|_| SequenceBlockKind::Par),
keyword("critical").map(|_| SequenceBlockKind::Critical),
keyword("break").map(|_| SequenceBlockKind::Break),
keyword("rect").map(|_| SequenceBlockKind::Rect),
))
.parse_next(input)?;
inline_ws_and_comments(input)?;
let label = opt(rest_of_line).parse_next(input)?;
let mut branches = vec![SequenceBranch {
label: None,
items: Vec::new(),
}];
loop {
skip_ws_and_comments(input)?;
if !has_input(input) {
break;
}
if at_block_end(input) {
break;
}
if let Some(div_label) = scan_branch_divider(&kind, input) {
branches.push(SequenceBranch {
label: Some(div_label),
items: Vec::new(),
});
continue;
}
if let Some(SequenceStatement::Block(b)) = attempt(block_statement, input) {
branches
.last_mut()
.expect("branches 至少含首段")
.items
.push(SequenceItem::Block(b));
continue;
}
if let Some(SequenceStatement::Note(n)) = attempt(note_statement, input) {
branches
.last_mut()
.expect("branches 至少含首段")
.items
.push(SequenceItem::Note(n));
continue;
}
if let Some(SequenceStatement::Message(m)) = attempt(message_statement, input) {
branches
.last_mut()
.expect("branches 至少含首段")
.items
.push(SequenceItem::Message(m));
continue;
}
skip_line(input)?;
}
keyword("end").parse_next(input)?;
consume_line(input)?;
Ok(SequenceStatement::Block(SequenceBlock {
kind,
label,
branches,
}))
}
fn scan_branch_divider(kind: &SequenceBlockKind, input: &mut &str) -> Option<String> {
let kw = match kind {
SequenceBlockKind::Alt => "else",
SequenceBlockKind::Par => "and",
SequenceBlockKind::Critical => "option",
_ => return None,
};
let rest = input.strip_prefix(kw)?;
if !(rest.is_empty() || rest.starts_with(|c: char| c.is_whitespace() || c == ';')) {
return None;
}
let mut rest: &str = rest;
inline_ws_and_comments(&mut rest).ok();
let label = opt(rest_of_line)
.parse_next(&mut rest)
.ok()
.flatten()
.unwrap_or_default();
consume_line(&mut rest).ok()?;
*input = rest;
Some(label)
}
#[cfg(test)]
mod tests {
use super::*;
fn parse(input: &str) -> SequenceDiagram {
let mut stream: &str = input;
let d = sequence_diagram.parse_next(&mut stream).unwrap();
assert!(stream.is_empty(), "trailing input: {:?}", stream);
d
}
#[test]
fn basic_messages() {
let d = parse("sequenceDiagram\nAlice->>Bob: Hello\nBob-->>Alice: Hi");
assert_eq!(d.participants.len(), 0);
assert_eq!(d.statements.len(), 2);
match &d.statements[0] {
SequenceStatement::Message(m) => {
assert_eq!(m.from, "Alice");
assert_eq!(m.to, "Bob");
assert_eq!(m.arrow, MessageArrow::SolidTip);
assert_eq!(m.text.as_deref(), Some("Hello"));
}
_ => panic!("expected message"),
}
}
#[test]
fn participants_and_alias() {
let d = parse("sequenceDiagram\nparticipant Alice as A\nactor Bob\nAlice->>Bob: x");
assert_eq!(d.participants.len(), 2);
assert_eq!(d.participants[0].name, "Alice");
assert_eq!(d.participants[0].alias.as_deref(), Some("A"));
assert_eq!(d.participants[1].kind, ParticipantKind::Actor);
}
#[test]
fn activation_symbols() {
let d = parse("sequenceDiagram\nAlice->>+Bob: req\nBob-->>-Alice: resp");
match &d.statements[0] {
SequenceStatement::Message(m) => {
assert_eq!(m.activation, Some(MessageActivation::Activate));
}
_ => panic!(),
}
match &d.statements[1] {
SequenceStatement::Message(m) => {
assert_eq!(m.activation, Some(MessageActivation::Deactivate));
}
_ => panic!(),
}
}
#[test]
fn loop_block() {
let d = parse("sequenceDiagram\nloop every 5s\nAlice->>Bob: ping\nend");
match &d.statements[0] {
SequenceStatement::Block(b) => {
assert_eq!(b.kind, SequenceBlockKind::Loop);
assert_eq!(b.label.as_deref(), Some("every 5s"));
assert_eq!(b.branches.len(), 1);
assert_eq!(b.branches[0].items.len(), 1);
}
_ => panic!("expected block"),
}
}
#[test]
fn note_over() {
let d = parse("sequenceDiagram\nNote over Alice,Bob: discussion");
match &d.statements[0] {
SequenceStatement::Note(n) => {
assert_eq!(n.placement, NotePlacement::Over);
assert_eq!(n.targets, vec!["Alice", "Bob"]);
assert_eq!(n.text, "discussion");
}
_ => panic!("expected note"),
}
}
}