use crate::ast::{Class, ClassDiagram, ClassMember, Relation, RelationKind, Visibility};
use crate::parser::common::{
PResult, attempt, consume_line, has_input, identifier, inline_ws, quoted_string, rest_of_line,
skip_line, skip_ws_and_comments,
};
use winnow::{
Parser,
combinator::{alt, delimited, opt},
token::take_while,
};
pub fn class_diagram<'i>(input: &mut &'i str) -> PResult<'i, ClassDiagram> {
crate::parser::common::keyword("classDiagram").parse_next(input)?;
skip_ws_and_comments(input)?;
let mut classes = Vec::new();
let mut relations = Vec::new();
while has_input(input) {
skip_ws_and_comments(input)?;
if input.is_empty() {
break;
}
if let Some(c) = attempt(class_decl, input) {
classes.push(c);
continue;
}
if let Some((name, m)) = attempt(member_decl, input) {
classes.push(Class {
name,
generic: None,
annotation: None,
members: vec![m],
});
continue;
}
if let Some(r) = attempt(relation, input) {
relations.push(r);
continue;
}
skip_line(input)?;
}
Ok(ClassDiagram { classes, relations })
}
fn class_decl<'i>(input: &mut &'i str) -> PResult<'i, Class> {
crate::parser::common::keyword("class").parse_next(input)?;
skip_ws_and_comments(input)?;
let name = identifier.parse_next(input)?;
let generic = if input.starts_with('~') {
let g = delimited('~', take_while(0.., |c: char| c != '~'), '~').parse_next(input)?;
Some(g.trim().to_string())
} else {
None
};
inline_ws(input)?;
let annotation = opt(delimited("<<", take_while(0.., |c: char| c != '>'), ">>"))
.parse_next(input)?
.map(|s: &str| s.trim().to_string());
inline_ws(input)?;
let mut members = Vec::new();
if input.starts_with('{') {
let _ = '{'.parse_next(input)?;
loop {
skip_ws_and_comments(input)?;
if input.starts_with('}') {
break;
}
if !has_input(input) {
break;
}
if let Some(m) = attempt(member, input) {
members.push(m);
} else {
let _ = take_while(1.., |c: char| c != '\n' && c != '}' && c != '\r')
.parse_next(input)?;
}
}
let _ = '}'.parse_next(input)?;
}
consume_line(input)?;
Ok(Class {
name,
generic,
annotation,
members,
})
}
fn member_decl<'i>(input: &mut &'i str) -> PResult<'i, (String, ClassMember)> {
let name = identifier.parse_next(input)?;
inline_ws(input)?;
let _ = ':'.parse_next(input)?;
inline_ws(input)?;
let member = member.parse_next(input)?;
Ok((name, member))
}
fn strip_parens(token: &str) -> String {
match token.find('(') {
Some(idx) => token[..idx].to_string(),
None => token.to_string(),
}
}
fn member_token<'i>(input: &mut &'i str) -> PResult<'i, String> {
take_while(1.., |c: char| {
c.is_ascii_alphanumeric() || c == '_' || c == '(' || c == ')' || c == '<' || c == '>'
})
.parse_next(input)
.map(|s: &str| s.trim().to_string())
}
fn member<'i>(input: &mut &'i str) -> PResult<'i, ClassMember> {
let visibility = opt(alt((
'+'.map(|_| Visibility::Public),
'-'.map(|_| Visibility::Private),
'#'.map(|_| Visibility::Protected),
'~'.map(|_| Visibility::Package),
)))
.parse_next(input)?;
inline_ws(input)?;
let first = member_token(input)?;
inline_ws(input)?;
let (name, mut type_, is_method) = if input.starts_with(':') {
let is_method = first.contains('(');
let name = strip_parens(&first);
(name, None, is_method)
} else {
let second = opt(member_token).parse_next(input)?;
inline_ws(input)?;
if let Some(second) = second {
if first.contains('(') {
let name = strip_parens(&first);
(name, Some(second), true)
} else {
(second, Some(first), false)
}
} else {
let is_method = first.contains('(');
(strip_parens(&first), None, is_method)
}
};
if input.starts_with(':') {
let _ = ':'.parse_next(input)?;
skip_ws_and_comments(input)?;
let t = rest_of_line.parse_next(input)?;
type_ = Some(t.trim().to_string());
}
consume_line(input)?;
Ok(ClassMember {
visibility,
name,
type_,
is_method,
})
}
fn relation<'i>(input: &mut &'i str) -> PResult<'i, Relation> {
let pre = opt(quoted_string).parse_next(input)?;
skip_ws_and_comments(input)?;
let source = identifier.parse_next(input)?;
skip_ws_and_comments(input)?;
let post = opt(quoted_string).parse_next(input)?;
skip_ws_and_comments(input)?;
let kind = relation_kind.parse_next(input)?;
skip_ws_and_comments(input)?;
let pre2 = opt(quoted_string).parse_next(input)?;
skip_ws_and_comments(input)?;
let target = identifier.parse_next(input)?;
skip_ws_and_comments(input)?;
let post2 = opt(quoted_string).parse_next(input)?;
skip_ws_and_comments(input)?;
let cardinality_first = pre.or(post);
let cardinality_second = pre2.or(post2);
let label = if input.starts_with(':') {
let _ = ':'.parse_next(input)?;
skip_ws_and_comments(input)?;
let l = rest_of_line.parse_next(input)?.trim().to_string();
consume_line(input)?;
Some(l)
} else {
None
};
Ok(Relation {
source,
target,
kind,
cardinality_first,
cardinality_second,
label,
})
}
fn relation_kind<'i>(input: &mut &'i str) -> PResult<'i, RelationKind> {
alt((
alt((
"<|--".map(|_| RelationKind::Inheritance),
"--|>".map(|_| RelationKind::Inheritance),
"--*>".map(|_| RelationKind::Composition),
"*--".map(|_| RelationKind::Composition),
"o--".map(|_| RelationKind::Aggregation),
"--o".map(|_| RelationKind::Aggregation),
)),
alt((
"-->".map(|_| RelationKind::Association),
"..|>".map(|_| RelationKind::Realization),
"<|..".map(|_| RelationKind::Realization),
"..>".map(|_| RelationKind::Dependency),
"<..".map(|_| RelationKind::Dependency),
"..".map(|_| RelationKind::Dashed),
"--".map(|_| RelationKind::Link),
)),
))
.parse_next(input)
}
#[cfg(test)]
mod tests {
use super::*;
fn parse(input: &str) -> ClassDiagram {
let mut stream: &str = input;
let d = class_diagram.parse_next(&mut stream).unwrap();
assert!(stream.is_empty(), "trailing input: {:?}", stream);
d
}
#[test]
fn simple_class() {
let d = parse("classDiagram\nclass Animal\nclass Dog");
assert_eq!(d.classes.len(), 2);
assert_eq!(d.classes[0].name, "Animal");
}
#[test]
fn class_with_members() {
let d = parse("classDiagram\nclass Animal {\n+String name\n+eat()\n#int age: 5\n}");
assert_eq!(d.classes.len(), 1);
let members = &d.classes[0].members;
assert_eq!(members.len(), 3);
assert_eq!(members[0].visibility, Some(Visibility::Public));
assert!(members[1].is_method); assert_eq!(members[1].name, "eat");
assert_eq!(members[2].type_.as_deref(), Some("5"));
}
#[test]
fn annotated_class() {
let d = parse("classDiagram\nclass Animal <<Interface>>");
assert_eq!(d.classes[0].annotation.as_deref(), Some("Interface"));
}
#[test]
fn members_declared_outside_class_block() {
let d = parse("classDiagram\nclass Animal\nAnimal : +int age\nAnimal : +isMammal()");
let animal = d
.classes
.iter()
.find(|c| c.name == "Animal")
.expect("Animal");
assert_eq!(d.classes.len(), 3, "parser 保留逐条声明,extract 负责合并");
assert_eq!(animal.members.len(), 0, "块内无成员");
assert_eq!(d.classes[1].members[0].name, "age");
assert_eq!(d.classes[2].members[0].name, "isMammal");
assert!(d.classes[2].members[0].is_method);
}
#[test]
fn relations() {
let d = parse("classDiagram\nDog --|> Animal\nCar *-- Wheel : has");
assert_eq!(d.relations.len(), 2);
assert_eq!(d.relations[0].kind, RelationKind::Inheritance);
assert_eq!(d.relations[0].source, "Dog");
assert_eq!(d.relations[0].target, "Animal");
assert_eq!(d.relations[1].kind, RelationKind::Composition);
assert_eq!(d.relations[1].label.as_deref(), Some("has"));
}
}