use std::collections::HashMap; use itertools::Itertools; pub struct PestRuleSettings { pub visible: bool, pub replace: Option, } impl Default for PestRuleSettings { fn default() -> Self { PestRuleSettings { visible: true, replace: None } } } pub fn abnf_to_pest(data: &Vec, rule_settings: &HashMap) -> std::io::Result { use abnf::abnf::*; use pretty::{Doc, BoxDoc}; fn format_rule(x: Rule, rule_settings: &HashMap) -> Doc> { let rulename = format_rulename(x.name); let default = Default::default(); let setting = rule_settings.get(&rulename).unwrap_or(&default); let visible = if setting.visible { "" } else { "_" }; let contents = match setting.replace { None => format_alternation(x.elements), Some(ref x) => Doc::text(x.clone()), }; Doc::nil() .append(Doc::text(rulename)) .append(Doc::text(" = ")) .append(Doc::text(visible)) .append(Doc::text("{")) .append(Doc::space().append(contents).nest(2)) .append(Doc::space()) .append(Doc::text("}")) .group() } fn format_rulename(x: String) -> String { let x = x.replace("-", "_"); if x == "if" || x == "else" || x == "as" || x == "let" || x == "in" || x == "fn" { x + "_" } else { x } } fn format_alternation(x: Alternation) -> Doc<'static, BoxDoc<'static, ()>> { Doc::intersperse( x.concatenations.into_iter().map(|x| format_concatenation(x).nest(2).group()), Doc::space().append(Doc::text("| ")) ) } fn format_concatenation(x: Concatenation) -> Doc<'static, BoxDoc<'static, ()>> { Doc::intersperse( x.repetitions.into_iter().map(format_repetition), Doc::space().append(Doc::text("~ ")) ) } fn format_repetition(x: Repetition) -> Doc<'static, BoxDoc<'static, ()>> { format_element(x.element) .append(x.repeat.map(format_repeat).map(Doc::text).unwrap_or(Doc::nil())) } fn format_repeat(x: Repeat) -> String { match (x.min.unwrap_or(0), x.max) { (0, None) => "*".into(), (1, None) => "+".into(), (0, Some(1)) => "?".into(), (min, None) => format!("{{{},}}", min), (min, Some(max)) if min == max => format!("{{{}}}", min), (min, Some(max)) => format!("{{{},{}}}", min, max), } } fn format_element(x: Element) -> Doc<'static, BoxDoc<'static, ()>> { use abnf::abnf::Element::*; match x { Rulename(s) => Doc::text(format_rulename(s)), Group(g) => Doc::text("(") .append(format_alternation(g.alternation).nest(4).group()) .append(Doc::text(")")), Option(o) => Doc::text("(") .append(format_alternation(o.alternation).nest(4).group()) .append(Doc::text(")?")), CharVal(s) => Doc::text(format!("^\"{}\"", s.replace("\"", "\\\"").replace("\\", "\\\\"))), NumVal(r) => Doc::text(format_range(r)), ProseVal(_) => unimplemented!(), } } fn format_range(x: Range) -> String { use abnf::abnf::Range::*; match x { Range(x, y) => format!("'{}'..'{}'", format_char(x), format_char(y)), OneOf(v) => format!("\"{}\"", v.into_iter().map(format_char).join("")), } } fn format_char(x: u64) -> String { if x <= (u8::max_value() as u64) { let x: u8 = x as u8; if x.is_ascii_graphic() { let x: char = x as char; if x != '"' && x != '\'' && x != '\\' { return x.to_string(); } } } format!("\\u{{{:02X}}}", x) } let make_err = |e| std::io::Error::new(std::io::ErrorKind::Other, format!("{}", e)); let rules = rulelist_comp(&data).map_err(make_err)?.1; let formatted_rules = rules.into_iter().map(|x| format_rule(x, rule_settings)); let doc: Doc<_> = Doc::intersperse(formatted_rules, Doc::newline()); Ok(format!("{}", doc.pretty(80))) }