pub mod class;
pub mod common;
pub mod er;
pub mod flowchart;
pub mod gitgraph;
pub mod pie;
pub mod sequence;
pub mod state;
pub mod timeline;
use crate::ast::Diagram;
use crate::error::{ParseError, ParseResult};
use winnow::prelude::*;
pub struct WinnowParser;
impl WinnowParser {
pub fn parse_mermaid(input: &str) -> ParseResult<Diagram> {
let input = input.trim_start_matches('\u{feff}');
let trimmed = input.trim_start();
if trimmed.is_empty() {
return Err(ParseError::NoDiagram);
}
let lower = trimmed.to_ascii_lowercase();
let kw = |p: &str| {
lower
.strip_prefix(p)
.filter(|r| r.is_empty() || r.starts_with([' ', '\t', '\n', '\r', ':', '-']))
.map(|r| &trimmed[trimmed.len() - r.len()..])
};
if kw("sequencediagram").is_some() {
return Self::parse_sequence(trimmed);
}
if kw("classdiagram").is_some() {
return Self::parse_class(trimmed);
}
if kw("statediagram-v2").is_some() {
return Self::parse_state(trimmed);
}
if kw("statediagram").is_some() {
return Self::parse_state(trimmed);
}
if kw("erdiagram").is_some() {
return Self::parse_er(trimmed);
}
if kw("pie").is_some() {
return Self::parse_pie(trimmed);
}
if kw("timeline").is_some() {
return Self::parse_timeline(trimmed);
}
if kw("gitgraph").is_some() {
return Self::parse_gitgraph(trimmed);
}
if kw("flowchart").is_some() || kw("graph").is_some() {
return Self::parse_flowchart(trimmed);
}
Err(ParseError::UnsupportedDiagram)
}
pub fn parse_flowchart(input: &str) -> ParseResult<Diagram> {
run(flowchart::flowchart_diagram, flowchart::trailing_ws, input).map(Diagram::Flowchart)
}
pub fn parse_sequence(input: &str) -> ParseResult<Diagram> {
run(
sequence::sequence_diagram,
common::skip_ws_and_comments,
input,
)
.map(Diagram::Sequence)
}
pub fn parse_class(input: &str) -> ParseResult<Diagram> {
run(class::class_diagram, common::skip_ws_and_comments, input).map(Diagram::Class)
}
pub fn parse_state(input: &str) -> ParseResult<Diagram> {
run(state::state_diagram, common::skip_ws_and_comments, input).map(Diagram::State)
}
pub fn parse_er(input: &str) -> ParseResult<Diagram> {
run(er::er_diagram, common::skip_ws_and_comments, input).map(Diagram::Er)
}
pub fn parse_pie(input: &str) -> ParseResult<Diagram> {
run(pie::pie_diagram, common::skip_ws_and_comments, input).map(Diagram::Pie)
}
pub fn parse_timeline(input: &str) -> ParseResult<Diagram> {
run(
timeline::timeline_diagram,
common::skip_ws_and_comments,
input,
)
.map(Diagram::Timeline)
}
pub fn parse_gitgraph(input: &str) -> ParseResult<Diagram> {
run(
gitgraph::gitgraph_diagram,
common::skip_ws_and_comments,
input,
)
.map(Diagram::GitGraph)
}
}
fn run<'i, O>(
mut parser: impl Parser<&'i str, O, winnow::error::InputError<&'i str>>,
mut trailing: impl Parser<&'i str, (), winnow::error::InputError<&'i str>>,
input: &'i str,
) -> ParseResult<O> {
let mut stream: &str = input;
let result = parser
.parse_next(&mut stream)
.map_err(|e: winnow::error::InputError<&str>| ParseError::Winnow(e.to_string()))?;
let mut rest = stream;
trailing
.parse_next(&mut rest)
.map_err(|e| ParseError::Winnow(e.to_string()))?;
if !rest.is_empty() {
return Err(ParseError::Winnow(format!(
"trailing input? not consumed: {:?}",
&rest[..rest.len().min(40)]
)));
}
Ok(result)
}