quack_builder/

parser.rs

use std::convert::TryInto;
use std::str;
use std::{convert::TryFrom, path::PathBuf};

use crate::types::{
    Enumerator, Extend, Extensions, Field, FieldType, FileDescriptor, Frequency, Message, OneOf,
    Proto2Frequency, Proto3Frequency, RpcFunctionDeclaration, RpcService, Syntax,
};

use nom::Parser;
use nom::{
    IResult,
    branch::alt,
    bytes::complete::{tag, take_until},
    character::complete::{
        alpha1, alphanumeric1, anychar, digit1, hex_digit1, multispace1, not_line_ending,
    },
    combinator::{map, map_res, opt, recognize, value, verify},
    multi::{many0, many1, separated_list0, separated_list1},
    sequence::{delimited, pair, preceded, separated_pair, terminated},
};

#[derive(Debug, Clone)]
enum ParsingStageFrequencyToken {
    Optional,
    Repeated,
    Required,
}

#[derive(Debug, Clone)]
#[allow(clippy::large_enum_variant)]
enum MessageEvent {
    Message(Message),
    Enumerator(Enumerator),
    Field(Field),
    ReservedNums(Vec<i32>),
    ReservedNames(Vec<String>),
    OneOf(OneOf),
    Extensions(Extensions),
    Ignore,
}

#[derive(Debug, Clone)]
enum EnumEvent {
    Field((String, i32)),
    Ignore,
}

#[derive(Debug, Clone)]
enum Event {
    Syntax(Syntax),
    Import(PathBuf),
    Package(String),
    Message(Message),
    Enum(Enumerator),
    RpcService(RpcService),
    Extend(Extend),
    Ignore,
}

fn qualifiable_name(input: &str) -> IResult<&str, String> {
    map(
        verify(
            recognize(pair(opt(tag(".")), separated_list1(tag("."), word))),
            |s: &str| !s.ends_with('.') && !s.contains(".."),
        ),
        std::borrow::ToOwned::to_owned,
    )
    .parse(input)
}

fn word_ref(input: &str) -> IResult<&str, &str> {
    recognize(pair(
        alt((
            // I would really rather just take in 1 alphabetic
            // character, but just using `alpha1()` is also technically
            // correct for our use case and is simpler to implement in
            // nom apparently
            alpha1,
            tag("_"),
        )),
        many0(alt((alphanumeric1, tag("_")))),
    ))
    .parse(input)
}

fn word(input: &str) -> IResult<&str, String> {
    map(word_ref, |word| word.to_owned()).parse(input)
}

fn hex_integer(input: &str) -> IResult<&str, i32> {
    preceded(
        tag("0x"),
        map_res(hex_digit1, |s: &str| i32::from_str_radix(s, 16)),
    )
    .parse(input)
}

fn integer(input: &str) -> IResult<&str, i32> {
    map_res(digit1, |s: &str| s.parse()).parse(input)
}

fn comment(input: &str) -> IResult<&str, ()> {
    value((), pair(tag("//"), not_line_ending)).parse(input)
}

fn block_comment(input: &str) -> IResult<&str, ()> {
    value((), (tag("/*"), take_until("*/"), tag("*/"))).parse(input)
}

fn string(input: &str) -> IResult<&str, String> {
    map(
        delimited(tag("\""), take_until("\""), tag("\"")),
        |s: &str| s.to_owned(),
    )
    .parse(input)
}

// word break: multispace or comment
fn br(input: &str) -> IResult<&str, ()> {
    value(
        (),
        many1(alt((value((), multispace1), comment, block_comment))),
    )
    .parse(input)
}

fn syntax(input: &str) -> IResult<&str, Syntax> {
    delimited(
        (tag("syntax"), many0(br), tag("="), many0(br)),
        alt((
            value(Syntax::Proto2, tag("\"proto2\"")),
            value(Syntax::Proto3, tag("\"proto3\"")),
        )),
        pair(many0(br), tag(";")),
    )
    .parse(input)
}

fn import(input: &str) -> IResult<&str, PathBuf> {
    delimited(
        pair(tag("import"), many1(br)),
        map(string, PathBuf::from),
        pair(many0(br), tag(";")),
    )
    .parse(input)
}

fn package(input: &str) -> IResult<&str, String> {
    delimited(
        pair(tag("package"), many1(br)),
        qualifiable_name,
        pair(many0(br), tag(";")),
    )
    .parse(input)
}

fn extensions(input: &str) -> IResult<&str, Extensions> {
    map(
        delimited(
            pair(tag("extensions"), many1(br)),
            pair(
                integer,
                preceded(pair(many0(br), pair(tag("to"), many1(br))), take_until(";")),
            ),
            tag(";"),
        ),
        |(from, to)| {
            // TODO: is there a better way to parse "max" or a number?
            let s = to.trim();
            let to = if s == "max" {
                Extensions::max()
            } else {
                s.parse().unwrap()
            };
            Extensions { from, to }
        },
    )
    .parse(input)
}

fn num_range(input: &str) -> IResult<&str, Vec<i32>> {
    map(
        separated_pair(integer, (many1(br), tag("to"), many1(br)), integer),
        |(from_, to)| (from_..=to).collect(),
    )
    .parse(input)
}

fn reserved_nums(input: &str) -> IResult<&str, Vec<i32>> {
    map(
        delimited(
            pair(tag("reserved"), many1(br)),
            separated_list1(
                (many0(br), tag(","), many0(br)),
                alt((num_range, map(integer, |i| vec![i]))),
            ),
            pair(many0(br), tag(";")),
        ),
        |nums| nums.into_iter().flat_map(|v| v.into_iter()).collect(),
    )
    .parse(input)
}

fn reserved_names(input: &str) -> IResult<&str, Vec<String>> {
    delimited(
        pair(tag("reserved"), many1(br)),
        separated_list1((many0(br), tag(","), many0(br)), string),
        pair(many0(br), tag(";")),
    )
    .parse(input)
}

fn key_val(input: &str) -> IResult<&str, (&str, &str)> {
    delimited(
        pair(tag("["), many0(br)),
        separated_pair(
            word_ref,
            delimited(many0(br), tag("="), many0(br)),
            map(take_until("]"), |v: &str| v.trim()),
        ),
        tag("]"),
    )
    .parse(input)
}

fn frequency(input: &str) -> IResult<&str, ParsingStageFrequencyToken> {
    alt((
        value(ParsingStageFrequencyToken::Optional, tag("optional")),
        value(ParsingStageFrequencyToken::Repeated, tag("repeated")),
        value(ParsingStageFrequencyToken::Required, tag("required")),
    ))
    .parse(input)
}

fn field_type(input: &str) -> IResult<&str, FieldType> {
    alt((
        value(FieldType::Int32, tag("int32")),
        value(FieldType::Int64, tag("int64")),
        value(FieldType::Uint32, tag("uint32")),
        value(FieldType::Uint64, tag("uint64")),
        value(FieldType::Sint32, tag("sint32")),
        value(FieldType::Sint64, tag("sint64")),
        value(FieldType::Fixed32, tag("fixed32")),
        value(FieldType::Sfixed32, tag("sfixed32")),
        value(FieldType::Fixed64, tag("fixed64")),
        value(FieldType::Sfixed64, tag("sfixed64")),
        value(FieldType::Bool, tag("bool")),
        value(FieldType::StringCow, tag("string")),
        value(FieldType::BytesCow, tag("bytes")),
        value(FieldType::Float, tag("float")),
        value(FieldType::Double, tag("double")),
        map(map_field, |(k, v)| FieldType::Map(Box::new(k), Box::new(v))),
        map(qualifiable_name, FieldType::MessageOrEnum),
    ))
    .parse(input)
}

fn map_field(input: &str) -> IResult<&str, (FieldType, FieldType)> {
    delimited(
        (tag("map"), many0(br), tag("<"), many0(br)),
        separated_pair(
            field_type,
            delimited(many0(br), tag(","), many0(br)),
            field_type,
        ),
        pair(many0(br), tag(">")),
    )
    .parse(input)
}

fn default_check<'a>(
    syntax: Syntax,
    typ: FieldType,
    key_vals: &[(&'a str, &'a str)],
) -> Result<Option<String>, &'a str> {
    for &(k, v) in key_vals.iter() {
        if k == "default" {
            return match (syntax, typ) {
                (Syntax::Proto2, FieldType::StringCow | FieldType::BytesCow) => {
                    let remove_compulsory_inverted_commas: IResult<&str, &str> = alt((
                        delimited(tag("\""), take_until("\""), tag("\"")),
                        delimited(tag("\'"), take_until("\'"), tag("\'")),
                    ))
                    .parse(v);
                    remove_compulsory_inverted_commas
                        .map(|(_, s)| Some(s.to_owned()))
                        .map_err(|_| "Default value must be wrapped in inverted commas!")
                }
                (Syntax::Proto2, _) => Ok(Some(v.to_owned())),
                (Syntax::Proto3, _) => Ok(Some(v.to_owned())),
            };
        }
    }
    Ok(None)
}

impl TryFrom<(Syntax, FieldType, Option<ParsingStageFrequencyToken>)> for Frequency {
    type Error = &'static str;

    fn try_from(
        value: (Syntax, FieldType, Option<ParsingStageFrequencyToken>)
    ) -> Result<Self, Self::Error> {
        match value {
            (Syntax::Proto2, FieldType::Map(..), _) => {
                Ok(Frequency::Proto2Frequency(Proto2Frequency::Map))
            }
            (Syntax::Proto2, _, Some(ParsingStageFrequencyToken::Required)) => {
                Ok(Frequency::Proto2Frequency(Proto2Frequency::Required))
            }
            (Syntax::Proto2, _, Some(ParsingStageFrequencyToken::Optional)) => {
                Ok(Frequency::Proto2Frequency(Proto2Frequency::Optional))
            }
            (Syntax::Proto2, _, Some(ParsingStageFrequencyToken::Repeated)) => {
                Ok(Frequency::Proto2Frequency(Proto2Frequency::Repeated))
            }
            (Syntax::Proto2, _, None) => Ok(Frequency::Proto2Frequency(Proto2Frequency::Optional)),
            (Syntax::Proto3, FieldType::Map(..), _) => {
                Ok(Frequency::Proto3Frequency(Proto3Frequency::Map))
            }
            (Syntax::Proto3, _, Some(ParsingStageFrequencyToken::Required)) => {
                Ok(Frequency::Proto3Frequency(Proto3Frequency::Optional))
            }
            (Syntax::Proto3, _, Some(ParsingStageFrequencyToken::Optional)) => {
                Ok(Frequency::Proto3Frequency(Proto3Frequency::Optional))
            }
            (Syntax::Proto3, _, Some(ParsingStageFrequencyToken::Repeated)) => {
                Ok(Frequency::Proto3Frequency(Proto3Frequency::Repeated))
            }
            (Syntax::Proto3, _, None) => Ok(Frequency::Proto3Frequency(Proto3Frequency::Default)),
        }
    }
}

fn field_generic<F>(
    syntax: Syntax,
    freq_func: F,
) -> impl FnMut(&str) -> IResult<&str, Field>
where
    F: Fn(
        (Syntax, FieldType, Option<ParsingStageFrequencyToken>),
    ) -> Result<Frequency, &'static str>,
{
    move |input| -> IResult<&str, Field> {
        map_res(
            (
                opt(terminated(frequency, many1(br))),
                terminated(field_type, many1(br)),
                separated_pair(
                    word,
                    delimited(many0(br), tag("="), many0(br)),
                    alt((integer, hex_integer)),
                ),
                delimited(many0(br), many0(key_val), pair(many0(br), tag(";"))),
            ),
            |(freq, typ, (name, number), key_vals)| {
                Ok::<Field, &str>(Field {
                    name,
                    frequency: freq_func((syntax, typ.clone(), freq))?,
                    number,
                    default: default_check(syntax, typ.clone(), &key_vals)?,
                    packed: key_vals.iter().find_map(|&(k, v)| {
                        if k == "packed" {
                            Some(v.parse().expect("Cannot parse Packed value"))
                        } else {
                            None
                        }
                    }),
                    boxed: false,
                    typ,
                    deprecated: key_vals
                        .iter()
                        .find_map(|&(k, v)| {
                            if k == "deprecated" {
                                Some(v.parse().expect("Cannot parse Deprecated value"))
                            } else {
                                None
                            }
                        })
                        .unwrap_or(false),
                })
            },
        )
        .parse(input)
    }
}

fn message_field(syntax: Syntax) -> impl FnMut(&str) -> IResult<&str, Field> {
    field_generic(syntax, TryInto::try_into)
}

fn oneof_message_field(syntax: Syntax) -> impl FnMut(&str) -> IResult<&str, Field> {
    field_generic(syntax, |(syntax, _, _)| {
        Ok(match syntax {
            Syntax::Proto2 => Frequency::Proto2Frequency(Proto2Frequency::Required),
            Syntax::Proto3 => Frequency::Proto3Frequency(Proto3Frequency::Optional),
        })
    })
}

fn one_of(syntax: Syntax) -> impl FnMut(&str) -> IResult<&str, OneOf> {
    move |input| {
        map(
            pair(
                preceded(pair(tag("oneof"), many1(br)), word),
                delimited(
                    pair(many0(br), tag("{")),
                    many1(delimited(many0(br), oneof_message_field(syntax), many0(br))),
                    tag("}"),
                ),
            ),
            |(name, fields)| OneOf {
                name,
                fields,
                package: "".to_string(),
                module: "".to_string(),
                imported: false,
            },
        )
        .parse(input)
    }
}

fn rpc_function_declaration(input: &str) -> IResult<&str, RpcFunctionDeclaration> {
    map(
        (
            delimited(pair(tag("rpc"), many1(br)), word, many0(br)),
            delimited(pair(tag("("), many0(br)), word, pair(many0(br), tag(")"))),
            delimited(
                (many1(br), tag("returns"), many0(br), tag("("), many0(br)),
                word,
                pair(many0(br), tag(")")),
            ),
            preceded(
                many0(br),
                alt((
                    value(
                        (),
                        delimited(
                            pair(tag("{"), many0(br)),
                            many0(alt((option_ignore, value((), tag(";"))))),
                            pair(many0(br), tag("}")),
                        ),
                    ),
                    value((), tag(";")),
                )),
            ),
        ),
        |(name, arg, ret, _)| RpcFunctionDeclaration { name, arg, ret },
    )
    .parse(input)
}

fn rpc_service(input: &str) -> IResult<&str, RpcService> {
    map(
        pair(
            delimited(pair(tag("service"), many1(br)), word, many0(br)),
            delimited(
                tag("{"),
                many0(delimited(many0(br), rpc_function_declaration, many0(br))),
                tag("}"),
            ),
        ),
        |(service_name, functions)| RpcService {
            service_name,
            functions,
        },
    )
    .parse(input)
}

fn message_event(syntax: Syntax) -> impl FnMut(&str) -> IResult<&str, MessageEvent> {
    move |input| {
        alt((
            map(reserved_nums, MessageEvent::ReservedNums),
            map(reserved_names, MessageEvent::ReservedNames),
            map(message_field(syntax), MessageEvent::Field),
            map(message(syntax), MessageEvent::Message),
            map(enumerator, MessageEvent::Enumerator),
            map(one_of(syntax), MessageEvent::OneOf),
            map(extensions, MessageEvent::Extensions),
            value(MessageEvent::Ignore, option_ignore),
            value(MessageEvent::Ignore, br),
        ))
        .parse(input)
    }
}

fn message(syntax: Syntax) -> impl FnMut(&str) -> IResult<&str, Message> {
    move |input| {
        map(
            terminated(
                pair(
                    delimited(pair(tag("message"), many1(br)), word, many0(br)),
                    delimited(tag("{"), many0(message_event(syntax)), tag("}")),
                ),
                opt(pair(many0(br), tag(";"))),
            ),
            |(name, events)| {
                let mut msg = Message {
                    name,
                    ..Default::default()
                };
                for e in events {
                    match e {
                        MessageEvent::Field(f) => msg.fields.push(f),
                        MessageEvent::ReservedNums(r) => {
                            msg.reserved_nums = Some(r);
                        }
                        MessageEvent::ReservedNames(r) => {
                            msg.reserved_names = Some(r);
                        }
                        MessageEvent::Message(m) => msg.messages.push(m),
                        MessageEvent::Enumerator(e) => msg.enums.push(e),
                        MessageEvent::OneOf(o) => msg.oneofs.push(o),
                        MessageEvent::Extensions(e) => {
                            msg.extensions = Some(e);
                        }
                        MessageEvent::Ignore => (),
                    }
                }
                msg
            },
        )
        .parse(input)
    }
}

fn enum_field(input: &str) -> IResult<&str, (String, i32)> {
    terminated(
        separated_pair(
            word,
            (many0(br), tag("="), many0(br)),
            alt((hex_integer, integer)),
        ),
        pair(
            many0(alt((
                br,
                // TODO: add proper deprecation later. We ignore deprecated enum
                // fields for now
                value(
                    (),
                    (
                        tag("["),
                        many0(multispace1),
                        tag("deprecated"),
                        many0(multispace1),
                        tag("="),
                        many0(multispace1),
                        word,
                        many0(multispace1),
                        tag("]"),
                    ),
                ),
            ))),
            tag(";"),
        ),
    )
    .parse(input)
}

fn enum_event(input: &str) -> IResult<&str, EnumEvent> {
    alt((
        map(enum_field, EnumEvent::Field),
        value(EnumEvent::Ignore, option_ignore),
        value(EnumEvent::Ignore, br),
    ))
    .parse(input)
}

fn enumerator(input: &str) -> IResult<&str, Enumerator> {
    map_res(
        terminated(
            pair(
                delimited(pair(tag("enum"), many1(br)), word, many0(br)),
                delimited(tag("{"), many0(enum_event), tag("}")),
            ),
            opt(pair(many0(br), tag(";"))),
        ),
        |(name, events)| {
            let mut enumerator = Enumerator {
                name,
                ..Default::default()
            };
            for event in events {
                if let EnumEvent::Field(f) = event {
                    enumerator.fields.push(f);
                }
            }
            Ok::<Enumerator, &str>(enumerator)
        },
    )
    .parse(input)
}

fn option_ignore(input: &str) -> IResult<&str, ()> {
    value(
        (),
        delimited(pair(tag("option"), many1(br)), take_until(";"), tag(";")),
    )
    .parse(input)
}

fn extend(syntax: Syntax) -> impl FnMut(&str) -> IResult<&str, Extend> {
    move |input| {
        map(
            terminated(
                pair(
                    delimited(pair(tag("extend"), many1(br)), qualifiable_name, many0(br)),
                    delimited(
                        tag("{"),
                        many1(delimited(many0(br), message_field(syntax), many0(br))),
                        tag("}"),
                    ),
                ),
                opt(pair(many0(br), tag(";"))),
            ),
            |(name, fields)| Extend { name, fields },
        )
        .parse(input)
    }
}

fn scan_syntax(input: &str) -> IResult<&str, Syntax> {
    map_res(separated_list0(many0(anychar), syntax), |v| {
        Ok::<Syntax, &str>(if v.is_empty() { Syntax::Proto2 } else { v[0] })
    })
    .parse(input)
}

pub fn file_descriptor<'a>(
    input: &'a str
) -> IResult<&'a str, FileDescriptor, nom::error::Error<String>> {
    let got_syntax = scan_syntax(input).unwrap().1;

    let parser =
        move |input: &'a str| -> IResult<&'a str, FileDescriptor, nom::error::Error<&str>> {
            map(
                many0(alt((
                    map(syntax, Event::Syntax),
                    map(import, Event::Import),
                    map(package, Event::Package),
                    map(message(got_syntax), Event::Message),
                    map(enumerator, Event::Enum),
                    map(rpc_service, Event::RpcService),
                    map(extend(got_syntax), Event::Extend),
                    value(Event::Ignore, option_ignore),
                    value(Event::Ignore, br),
                ))),
                |events| {
                    let mut desc = FileDescriptor::default();
                    for event in events {
                        match event {
                            Event::Syntax(s) => {
                                desc.syntax = s;
                            }
                            Event::Import(i) => desc.import_paths.push(i),
                            Event::Package(p) => {
                                desc.package = p;
                            }
                            Event::Message(m) => desc.messages.push(m),
                            Event::Enum(e) => desc.enums.push(e),
                            Event::RpcService(r) => desc.rpc_services.push(r),
                            Event::Extend(e) => desc.message_extends.push(e),
                            Event::Ignore => (),
                        }
                    }
                    desc
                },
            )
            .parse(input)
        };

    parser(input).map_err(|e: nom::Err<nom::error::Error<&str>>| e.to_owned())
}