use crate::{
ast::{ClassDiagram, RelationKind, Visibility},
builder::ir::{
self,
common::{
ArrowKind, ArrowSpec, EdgePriority, LabelSpec, LineKind, NodeDetail, PortHint, PortSet,
SizeHint, StyleRef,
},
shape::ShapeKind,
unigraph::{EdgeKind, UGEdge, UGNode, Unigraph},
},
};
pub fn map_relation_kind(kind: &RelationKind) -> EdgeKind {
match kind {
RelationKind::Inheritance => EdgeKind::ClassExtends,
RelationKind::Composition => EdgeKind::ClassComposition,
RelationKind::Aggregation => EdgeKind::ClassAggregation,
RelationKind::Association => EdgeKind::ClassAssociation,
RelationKind::Dependency => EdgeKind::ClassDependency,
RelationKind::Realization => EdgeKind::ClassRealization,
RelationKind::Link => EdgeKind::ClassLink,
RelationKind::Dashed => EdgeKind::ClassDashed,
}
}
fn format_member(m: &crate::ast::ClassMember) -> String {
let prefix = match m.visibility {
Some(Visibility::Public) => "+",
Some(Visibility::Private) => "-",
Some(Visibility::Protected) => "#",
Some(Visibility::Package) => "~",
None => "",
};
if m.is_method {
match &m.type_ {
Some(ret) => format!("{}{}() : {}", prefix, m.name, ret),
None => format!("{}{}()", prefix, m.name),
}
} else {
match &m.type_ {
Some(t) => format!("{}{} {}", prefix, t, m.name),
None => format!("{}{}", prefix, m.name),
}
}
}
pub fn extract_class(cd: &ClassDiagram) -> Unigraph {
struct Merged {
name: String,
generic: Option<String>,
annotation: Option<String>,
members: Vec<crate::ast::ClassMember>,
}
let mut merged: Vec<Merged> = Vec::new();
let mut index: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
for cls in &cd.classes {
let pos = match index.get(&cls.name) {
Some(&p) => p,
None => {
let p = merged.len();
index.insert(cls.name.clone(), p);
merged.push(Merged {
name: cls.name.clone(),
generic: None,
annotation: None,
members: Vec::new(),
});
p
}
};
let m = &mut merged[pos];
m.members.extend(cls.members.iter().cloned());
if cls.generic.is_some() {
m.generic = cls.generic.clone();
}
if cls.annotation.is_some() {
m.annotation = cls.annotation.clone();
}
}
let mut nodes: Vec<UGNode> = Vec::new();
let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
for cls in &merged {
seen.insert(cls.name.clone());
let display_name = match &cls.generic {
Some(g) => format!("{}<{}>", cls.name, g),
None => cls.name.clone(),
};
let attrs: Vec<String> = cls
.members
.iter()
.filter(|m| !m.is_method)
.map(format_member)
.collect();
let methods: Vec<String> = cls
.members
.iter()
.filter(|m| m.is_method)
.map(format_member)
.collect();
nodes.push(UGNode {
id: cls.name.clone(),
kind: ir::common::NodeKind::Atom,
role: ir::common::NodeRole::Atom,
shape: ShapeKind::Rectangle,
label: ir::common::LabelOrMeasured::Spec(LabelSpec {
text: display_name,
spans: Vec::new(),
}),
ports: PortSet::default(),
size_hint: SizeHint::ByText,
style_ref: StyleRef::NodeDefault,
constraint: ir::common::NodeConstraint::Free,
detail: NodeDetail::Class {
annotation: cls.annotation.clone(),
attrs,
methods,
},
});
}
let mut edges: Vec<UGEdge> = Vec::new();
for (i, rel) in cd.relations.iter().enumerate() {
for id in [&rel.source, &rel.target] {
if !seen.contains(id.as_str()) {
seen.insert(id.clone());
nodes.push(UGNode {
id: id.clone(),
kind: ir::common::NodeKind::Atom,
role: ir::common::NodeRole::Atom,
shape: ShapeKind::Rectangle,
label: ir::common::LabelOrMeasured::Spec(LabelSpec {
text: id.clone(),
spans: Vec::new(),
}),
ports: PortSet::default(),
size_hint: SizeHint::ByText,
style_ref: StyleRef::NodeDefault,
constraint: ir::common::NodeConstraint::Free,
detail: NodeDetail::Class {
annotation: None,
attrs: Vec::new(),
methods: Vec::new(),
},
});
}
}
let end_arrow = match rel.kind {
RelationKind::Association | RelationKind::Dependency => ArrowKind::Arrow,
_ => ArrowKind::None,
};
let line_kind = match rel.kind {
RelationKind::Dependency | RelationKind::Dashed | RelationKind::Realization => {
LineKind::Dotted
}
_ => LineKind::Solid,
};
edges.push(UGEdge {
id: format!("r{}", i),
source: rel.source.clone(),
target: rel.target.clone(),
source_port: PortHint::Auto,
target_port: PortHint::Auto,
kind: map_relation_kind(&rel.kind),
label_text: rel.label.clone(),
label: None,
priority: EdgePriority::Primary,
routing_hint: ir::common::RoutingHint::Spline,
arrow: ArrowSpec {
start: ArrowKind::None,
end: end_arrow,
},
line_kind,
repulsion: 1.0,
cardinality: (None, None),
cardinality_text: (
rel.cardinality_first.clone(),
rel.cardinality_second.clone(),
),
});
}
Unigraph {
family: ir::unigraph::GraphFamily::Grid,
direction: crate::ast::Direction::TB,
nodes,
edges,
subgraphs: Vec::new(),
sequence_rows: None,
meta: ir::common::DiagramMeta {
title: None,
show_data: false,
},
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ast::{Class, ClassMember};
fn cls(name: &str, members: Vec<ClassMember>) -> Class {
Class {
name: name.to_string(),
generic: None,
annotation: None,
members,
}
}
#[test]
fn extracts_nodes_and_details() {
let cd = ClassDiagram {
classes: vec![
cls(
"Animal",
vec![ClassMember {
visibility: Some(Visibility::Protected),
name: "age".into(),
type_: Some("int".into()),
is_method: false,
}],
),
cls(
"Dog",
vec![ClassMember {
visibility: Some(Visibility::Public),
name: "bark".into(),
type_: Some("void".into()),
is_method: true,
}],
),
],
relations: vec![crate::ast::Relation {
source: "Dog".into(),
target: "Animal".into(),
kind: RelationKind::Inheritance,
cardinality_first: None,
cardinality_second: None,
label: None,
}],
};
let ug = extract_class(&cd);
assert_eq!(ug.family, crate::builder::ir::unigraph::GraphFamily::Grid);
assert_eq!(ug.nodes.len(), 2);
assert_eq!(ug.nodes[0].id, "Animal");
assert_eq!(ug.edges.len(), 1);
assert_eq!(ug.edges[0].kind, EdgeKind::ClassExtends);
let NodeDetail::Class { attrs, methods, .. } = &ug.nodes[0].detail else {
panic!("expected Class detail");
};
assert_eq!(attrs, &["#int age".to_string()]);
assert!(methods.is_empty());
}
#[test]
fn duplicate_class_declarations_are_merged() {
let cd = ClassDiagram {
classes: vec![
cls(
"Animal",
vec![ClassMember {
visibility: Some(Visibility::Public),
name: "name".into(),
type_: Some("String".into()),
is_method: false,
}],
),
cls(
"Animal",
vec![ClassMember {
visibility: Some(Visibility::Public),
name: "age".into(),
type_: Some("int".into()),
is_method: false,
}],
),
],
relations: vec![],
};
let ug = extract_class(&cd);
assert_eq!(ug.nodes.len(), 1, "同名类只应产生一个节点");
let NodeDetail::Class { attrs, .. } = &ug.nodes[0].detail else {
panic!("expected Class detail");
};
assert_eq!(attrs, &["+String name".to_string(), "+int age".to_string()]);
}
#[test]
fn maps_relation_kinds() {
assert_eq!(
map_relation_kind(&RelationKind::Inheritance),
EdgeKind::ClassExtends
);
assert_eq!(
map_relation_kind(&RelationKind::Composition),
EdgeKind::ClassComposition
);
assert_eq!(
map_relation_kind(&RelationKind::Aggregation),
EdgeKind::ClassAggregation
);
assert_eq!(
map_relation_kind(&RelationKind::Association),
EdgeKind::ClassAssociation
);
assert_eq!(
map_relation_kind(&RelationKind::Dependency),
EdgeKind::ClassDependency
);
}
#[test]
fn dependency_is_dotted() {
let cd = ClassDiagram {
classes: vec![cls("A", vec![]), cls("B", vec![])],
relations: vec![crate::ast::Relation {
source: "A".into(),
target: "B".into(),
kind: RelationKind::Dependency,
cardinality_first: None,
cardinality_second: None,
label: None,
}],
};
let ug = extract_class(&cd);
assert_eq!(ug.edges[0].line_kind, LineKind::Dotted);
}
}