use winnow::{
Parser,
ascii::{multispace0, multispace1},
combinator::{alt, opt, peek},
error::InputError,
token::{one_of, take_until, take_while},
};
use crate::ast::{Direction, ParticipantKind};
pub fn keyword<'i>(kw: &'static str) -> impl Parser<&'i str, &'i str, InputError<&'i str>> {
move |input: &mut &'i str| {
let lower = kw.to_ascii_lowercase();
if let Some(candidate) = input.get(..lower.len())
&& candidate.to_ascii_lowercase() == lower
{
let after = input[lower.len()..].chars().next();
if after
.is_none_or(|c| c.is_whitespace() || c == ':' || c == '\n' || c == '\r' || c == '{')
{
let matched = &input[..lower.len()];
*input = &input[lower.len()..];
return Ok(matched);
}
}
Err(InputError::at(*input))
}
}
pub fn direction_ci<'i>(input: &mut &'i str) -> PResult<'i, Direction> {
alt((
keyword("TB").map(|_| Direction::TB),
keyword("TD").map(|_| Direction::TD),
keyword("BT").map(|_| Direction::BT),
keyword("RL").map(|_| Direction::RL),
keyword("LR").map(|_| Direction::LR),
))
.parse_next(input)
}
pub fn participant_kind<'i>(input: &mut &'i str) -> PResult<'i, ParticipantKind> {
use ParticipantKind::*;
alt((
keyword("actor").map(|_| Actor),
keyword("boundary").map(|_| Boundary),
keyword("control").map(|_| Control),
keyword("entity").map(|_| Entity),
keyword("database").map(|_| Database),
keyword("collections").map(|_| Collections),
keyword("queue").map(|_| Queue),
))
.parse_next(input)
}
pub fn rest_of_line<'i>(input: &mut &'i str) -> PResult<'i, String> {
take_while(1.., |c: char| c != '\n' && c != '\r')
.map(|s: &str| s.trim().to_string())
.parse_next(input)
}
pub type PResult<'i, O> = Result<O, InputError<&'i str>>;
pub fn ws<'i>(input: &mut &'i str) -> PResult<'i, &'i str> {
multispace0.parse_next(input)
}
pub fn inline_ws<'i>(input: &mut &'i str) -> PResult<'i, &'i str> {
take_while(0.., |c: char| c == ' ' || c == '\t').parse_next(input)
}
pub fn ws1<'i>(input: &mut &'i str) -> PResult<'i, &'i str> {
multispace1.parse_next(input)
}
pub fn inline_ws_and_comments<'i>(input: &mut &'i str) -> PResult<'i, ()> {
loop {
let before = input.len();
inline_ws(input)?;
if input.starts_with("%%") {
let _ = take_while(0.., |c: char| c != '\n' && c != '\r').parse_next(input)?;
}
if input.len() == before {
break;
}
}
Ok(())
}
pub fn line_comment<'i>(input: &mut &'i str) -> PResult<'i, ()> {
let _ = "%%".parse_next(input)?;
let _ = take_until(1.., '\n').parse_next(input)?;
let _ = opt('\n').parse_next(input)?;
Ok(())
}
pub fn skip_ws_and_comments<'i>(input: &mut &'i str) -> PResult<'i, ()> {
loop {
let mut advanced = false;
if ws1(input).is_ok() {
advanced = true;
}
if input.starts_with('\n') || input.starts_with("\r\n") {
if input.starts_with("\r\n") {
*input = &input[2..];
} else {
*input = &input[1..];
}
advanced = true;
}
if line_comment(input).is_ok() {
advanced = true;
}
if !advanced {
break;
}
}
Ok(())
}
pub fn has_input(input: &mut &str) -> bool {
!input.is_empty()
}
pub fn skip_line<'i>(input: &mut &'i str) -> PResult<'i, ()> {
if input.is_empty() {
return Ok(());
}
let before = input.len();
let _ = take_while(0.., |c: char| c != '\n' && c != '\r').parse_next(input)?;
let _ = opt(("\r\n", "\n")).parse_next(input)?;
if input.len() == before {
let _ = take_while(1.., |_c: char| true).parse_next(input)?;
}
Ok(())
}
pub fn attempt<'i, O>(
mut parser: impl Parser<&'i str, O, InputError<&'i str>>,
input: &mut &'i str,
) -> Option<O> {
let start = *input;
match parser.parse_next(input) {
Ok(value) => Some(value),
Err(_) => {
*input = start;
None
}
}
}
pub fn consume_line<'i>(input: &mut &'i str) -> PResult<'i, ()> {
let _ = take_while(0.., |c: char| c != '\n' && c != '\r').parse_next(input)?;
let _ = opt(alt(("\r\n", "\n"))).parse_next(input)?;
Ok(())
}
pub fn peek_end<'i>(input: &mut &'i str) -> PResult<'i, &'i str> {
peek("end").parse_next(input)
}
pub fn identifier<'i>(input: &mut &'i str) -> PResult<'i, String> {
let s = *input;
let mut end = 0usize;
let chars: Vec<(usize, char)> = s.char_indices().collect();
for (i, (b, c)) in chars.iter().enumerate() {
if c.is_alphanumeric() || *c == '_' {
end = b + c.len_utf8();
continue;
}
if *c == '-' {
if let Some((_, next)) = chars.get(i + 1)
&& matches!(next, '-' | '.' | '>')
{
break;
}
end = b + c.len_utf8();
continue;
}
break;
}
let first = s.chars().next();
let valid_start = first.is_some_and(|c| c.is_alphabetic() || c == '_');
if end == 0 || !valid_start {
return Err(InputError::at(*input));
}
*input = &s[end..];
Ok(s[..end].to_string())
}
pub fn quoted_string<'i>(input: &mut &'i str) -> PResult<'i, String> {
let q = one_of(['"', '\'']).parse_next(input)?;
let content = take_until(1.., q).parse_next(input)?;
let _ = one_of([q]).parse_next(input)?;
Ok(content.to_string())
}
pub fn unquoted_text<'i>(input: &mut &'i str) -> PResult<'i, String> {
take_while(1.., |c: char| {
!c.is_whitespace()
&& c != '['
&& c != ']'
&& c != '('
&& c != ')'
&& c != '{'
&& c != '}'
&& c != ';'
&& c != '|'
&& c != '<'
&& c != '>'
&& c != '='
&& c != '-'
&& c != '.'
&& c != '/'
&& c != '\\'
})
.map(|s: &str| s.to_string())
.parse_next(input)
}
pub fn text<'i>(input: &mut &'i str) -> PResult<'i, String> {
alt((quoted_string, unquoted_text)).parse_next(input)
}
pub fn direction<'i>(input: &mut &'i str) -> PResult<'i, crate::ast::Direction> {
use crate::ast::Direction;
alt((
"TB".map(|_| Direction::TB),
"TD".map(|_| Direction::TD),
"BT".map(|_| Direction::BT),
"RL".map(|_| Direction::RL),
"LR".map(|_| Direction::LR),
))
.parse_next(input)
}