use crate::ast::{State, StateDiagram, StateStmt, Transition};
use crate::parser::common::{
PResult, attempt, consume_line, has_input, identifier, inline_ws, keyword, quoted_string,
rest_of_line, skip_line, skip_ws_and_comments,
};
use winnow::{
Parser,
combinator::{alt, delimited, fail, opt, preceded},
token::take_while,
};
pub fn state_diagram<'i>(input: &mut &'i str) -> PResult<'i, StateDiagram> {
let _ = alt((keyword("stateDiagram-v2"), keyword("stateDiagram"))).parse_next(input)?;
skip_ws_and_comments(input)?;
parse_body(input)
}
fn parse_body<'i>(input: &mut &'i str) -> PResult<'i, StateDiagram> {
let mut states = Vec::new();
let mut transitions = Vec::new();
let mut order = Vec::new();
while has_input(input) {
skip_ws_and_comments(input)?;
if !has_input(input) {
break;
}
if input.starts_with('}') {
break;
}
if let Some(s) = attempt(state_decl, input) {
order.push(StateStmt::Decl(states.len()));
states.push(s);
continue;
}
if let Some(t) = attempt(transition, input) {
order.push(StateStmt::Trans(transitions.len()));
transitions.push(t);
continue;
}
if let Some(s) = attempt(bare_state_decl, input) {
order.push(StateStmt::Decl(states.len()));
states.push(s);
continue;
}
skip_line(input)?;
}
Ok(StateDiagram {
states,
transitions,
order,
})
}
fn state_ref<'i>(input: &mut &'i str) -> PResult<'i, String> {
alt((
"[*]".map(|s: &str| s.to_string()),
quoted_string,
identifier,
))
.parse_next(input)
}
fn state_decl<'i>(input: &mut &'i str) -> PResult<'i, State> {
keyword("state").parse_next(input)?;
inline_ws(input)?;
let description = opt(delimited('"', take_while(0.., |c: char| c != '"'), '"'))
.parse_next(input)?
.map(|s: &str| s.trim().to_string());
inline_ws(input)?;
let id = if description.is_some() {
keyword("as").parse_next(input)?;
inline_ws(input)?;
identifier.parse_next(input)?
} else {
identifier.parse_next(input)?
};
inline_ws(input)?;
let annotation =
opt(delimited("<<", take_while(0.., |c: char| c != '>'), ">>")).parse_next(input)?;
inline_ws(input)?;
if let Some(anno) = annotation {
return match anno.trim() {
"fork" => Ok(State::Fork { id }),
"join" => Ok(State::Join { id }),
_ => {
consume_line(input)?;
Ok(State::Simple { id, description })
}
};
}
if input.starts_with('{') {
let _ = '{'.parse_next(input)?;
let inner = parse_body(input)?;
let _ = '}'.parse_next(input)?;
consume_line(input)?;
return Ok(State::Composite {
id,
inner: Box::new(inner),
});
}
consume_line(input)?;
Ok(State::Simple { id, description })
}
fn bare_state_decl<'i>(input: &mut &'i str) -> PResult<'i, State> {
let start = *input;
let id = identifier.parse_next(input)?;
inline_ws(input)?;
let is_bare = input.is_empty()
|| input.starts_with(':')
|| input.starts_with('\n')
|| input.starts_with("\r\n")
|| input.starts_with(';');
if !is_bare {
*input = start;
return fail.parse_next(input);
}
if input.starts_with(':') {
let _ = ':'.parse_next(input)?;
inline_ws(input)?;
let desc = rest_of_line.parse_next(input)?.trim().to_string();
consume_line(input)?;
Ok(State::Simple {
id,
description: Some(desc),
})
} else {
consume_line(input)?;
Ok(State::Simple {
id,
description: None,
})
}
}
fn transition<'i>(input: &mut &'i str) -> PResult<'i, Transition> {
let from = state_ref.parse_next(input)?;
inline_ws(input)?;
let _ = "-->".parse_next(input)?;
inline_ws(input)?;
let to = state_ref.parse_next(input)?;
inline_ws(input)?;
let label = opt(preceded(':', rest_of_line))
.parse_next(input)?
.map(|s| s.trim().to_string());
consume_line(input)?;
Ok(Transition { from, to, label })
}
#[cfg(test)]
mod tests {
use super::*;
fn parse(input: &str) -> StateDiagram {
let mut stream: &str = input;
let d = state_diagram.parse_next(&mut stream).unwrap();
assert!(stream.is_empty(), "trailing input: {:?}", stream);
d
}
#[test]
fn start_end_transitions() {
let d = parse("stateDiagram-v2\n[*] --> Idle\nIdle --> [*]");
assert_eq!(d.transitions.len(), 2);
assert_eq!(d.transitions[0].from, "[*]");
assert_eq!(d.transitions[0].to, "Idle");
assert_eq!(d.transitions[1].to, "[*]");
}
#[test]
fn labeled_transition() {
let d = parse("stateDiagram-v2\nA --> B : start");
assert_eq!(d.transitions[0].label.as_deref(), Some("start"));
}
#[test]
fn composite_state() {
let d = parse("stateDiagram-v2\nstate Foo {\nA --> B\n}");
assert_eq!(d.states.len(), 1);
match &d.states[0] {
State::Composite { id, inner } => {
assert_eq!(id, "Foo");
assert_eq!(inner.transitions.len(), 1);
}
_ => panic!("expected composite"),
}
}
#[test]
fn described_state() {
let d = parse("stateDiagram-v2\nstate \"Active\" as Act");
assert_eq!(d.states.len(), 1);
match &d.states[0] {
State::Simple { id, description } => {
assert_eq!(id, "Act");
assert_eq!(description.as_deref(), Some("Active"));
}
_ => panic!(),
}
}
}