use crate::ast::{Cardinality, ErAttribute, ErDiagram, ErEntity, ErRelationship};
use crate::parser::common::{
PResult, attempt, consume_line, has_input, identifier, inline_ws_and_comments, keyword,
quoted_string, rest_of_line, skip_line, skip_ws_and_comments,
};
use winnow::{
Parser,
combinator::{alt, opt, preceded},
token::take_while,
};
pub fn er_diagram<'i>(input: &mut &'i str) -> PResult<'i, ErDiagram> {
crate::parser::common::keyword("erDiagram").parse_next(input)?;
skip_ws_and_comments(input)?;
let mut entities = Vec::new();
let mut relationships = Vec::new();
while has_input(input) {
skip_ws_and_comments(input)?;
if input.is_empty() {
break;
}
if let Some(e) = attempt(entity, input) {
entities.push(e);
continue;
}
if let Some(r) = attempt(relationship, input) {
relationships.push(r);
continue;
}
skip_line(input)?;
}
Ok(ErDiagram {
entities,
relationships,
})
}
fn entity<'i>(input: &mut &'i str) -> PResult<'i, ErEntity> {
let name = entity_name.parse_next(input)?;
skip_ws_and_comments(input)?;
if !input.starts_with('{') {
return Err(winnow::error::InputError::at(*input));
}
let mut attributes = Vec::new();
if input.starts_with('{') {
let _ = '{'.parse_next(input)?;
loop {
skip_ws_and_comments(input)?;
if input.starts_with('}') || !has_input(input) {
break;
}
let type_ = alt((quoted_string, identifier)).parse_next(input)?;
skip_ws_and_comments(input)?;
let attr_name = alt((quoted_string, identifier)).parse_next(input)?;
let _ = take_while(0.., |c: char| c == ' ' || c == '\t').parse_next(input)?;
let constraint = if has_input(input)
&& !input.starts_with('\n')
&& !input.starts_with('\r')
&& !input.starts_with('}')
{
let tok = identifier.parse_next(input)?;
Some(tok)
} else {
None
};
let _ =
take_while(0.., |c: char| c != '\n' && c != '}' && c != '\r').parse_next(input)?;
attributes.push(ErAttribute {
type_,
name: attr_name,
constraint,
});
}
let _ = '}'.parse_next(input)?;
}
consume_line(input)?;
Ok(ErEntity { name, attributes })
}
fn cardinality_pair<'i>(input: &mut &'i str) -> PResult<'i, (Cardinality, Cardinality)> {
use Cardinality::*;
let card_first = alt((
"||".map(|_| ExactlyOne),
"|o".map(|_| ZeroOrOne),
"}o".map(|_| ZeroOrMany),
"}|".map(|_| OneOrMany),
))
.parse_next(input)?;
let _ = alt(("--", "..")).parse_next(input)?;
let card_second = alt((
"||".map(|_| ExactlyOne),
"|o".map(|_| ZeroOrOne),
"}o".map(|_| ZeroOrMany),
"}|".map(|_| OneOrMany),
"o{".map(|_| OneOrMany),
"|{".map(|_| OneOrMany),
"o|".map(|_| ZeroOrOne),
))
.parse_next(input)?;
Ok((card_first, card_second))
}
fn relationship<'i>(input: &mut &'i str) -> PResult<'i, ErRelationship> {
let first_entity = entity_ref.parse_next(input)?;
skip_ws_and_comments(input)?;
let (cardinality_first, cardinality_second) = cardinality_pair.parse_next(input)?;
skip_ws_and_comments(input)?;
let second_entity = entity_ref.parse_next(input)?;
skip_ws_and_comments(input)?;
let label = opt(preceded(':', rest_of_line))
.parse_next(input)?
.map(|s| {
let t = s.trim();
if t.len() >= 2 && t.starts_with('"') && t.ends_with('"') {
t[1..t.len() - 1].to_string()
} else {
t.to_string()
}
});
consume_line(input)?;
Ok(ErRelationship {
first_entity,
second_entity,
cardinality_first,
cardinality_second,
label,
})
}
fn entity_ref<'i>(input: &mut &'i str) -> PResult<'i, String> {
alt((quoted_string, entity_name)).parse_next(input)
}
fn entity_name<'i>(input: &mut &'i str) -> PResult<'i, String> {
let name = identifier.parse_next(input)?;
let cp = *input;
inline_ws_and_comments(input)?;
if let Some(alias) = attempt(
preceded((keyword("as"), inline_ws_and_comments), identifier),
input,
) {
return Ok(alias);
}
*input = cp;
Ok(name)
}
#[cfg(test)]
mod tests {
use super::*;
fn parse(input: &str) -> ErDiagram {
let mut stream: &str = input;
let d = er_diagram.parse_next(&mut stream).unwrap();
assert!(stream.is_empty(), "trailing input: {:?}", stream);
d
}
#[test]
fn entity_with_attributes() {
let d = parse("erDiagram\nCUSTOMER {\nint id PK\nstring name\n}");
assert_eq!(d.entities.len(), 1);
assert_eq!(d.entities[0].name, "CUSTOMER");
assert_eq!(d.entities[0].attributes.len(), 2);
assert_eq!(d.entities[0].attributes[0].type_, "int");
assert_eq!(d.entities[0].attributes[0].name, "id");
}
#[test]
fn relationship_cardinality() {
let d = parse("erDiagram\nCUSTOMER ||--o{ ORDER : places");
assert_eq!(d.relationships.len(), 1);
let r = &d.relationships[0];
assert_eq!(r.first_entity, "CUSTOMER");
assert_eq!(r.second_entity, "ORDER");
assert_eq!(r.cardinality_first, Cardinality::ExactlyOne);
assert_eq!(r.cardinality_second, Cardinality::OneOrMany);
assert_eq!(r.label.as_deref(), Some("places"));
}
#[test]
fn relationship_cardinality_all_symbols() {
let d = parse(
"erDiagram\nA ||--|| B : ExactlyOne\nC |o--|o D : ZeroOrOne\nE }|--|{ F : OneOrMany\nG }o--o| H : ZeroOrMany",
);
assert_eq!(d.relationships.len(), 4);
assert_eq!(
d.relationships[1].cardinality_second,
Cardinality::ZeroOrOne
);
assert_eq!(
d.relationships[3].cardinality_second,
Cardinality::ZeroOrOne
);
}
}