openpql-pql-parser 0.1.0

A parser implementation for Poker Query Language (PQL)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use super::{Expected, Loc, LocInfo, ParseError, Token};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Error {
    InvalidToken(LocInfo),
    UnrecognizedEof(LocInfo, Expected),
    UnrecognizedToken(LocInfo, Expected),
    ExtraToken(LocInfo),

    UnrecognizedSelector(LocInfo),
    DuplicatedKeyInFrom(LocInfo),
    DuplicatedSelectorName(LocInfo),
    InvalidNumericValue(LocInfo),
}

pub type LalrError<'input> = ParseError<Loc, Token<'input>, Error>;

pub type ResultE<'input, T> = Result<T, LalrError<'input>>;

pub const fn user_err<'input>(error: Error) -> LalrError<'input> {
    ParseError::User { error }
}

impl<'input> From<LalrError<'input>> for Error {
    fn from(err: LalrError<'input>) -> Self {
        match err {
            ParseError::InvalidToken { location: l } => {
                Self::InvalidToken((l, l + 1))
            }

            ParseError::UnrecognizedEof {
                location: l,
                expected: v,
            } => Self::UnrecognizedEof((l, l + 1), v),

            ParseError::UnrecognizedToken {
                token: t,
                expected: v,
            } => Self::UnrecognizedToken((t.0, t.2), v),

            ParseError::ExtraToken { token: t } => Self::ExtraToken((t.0, t.2)),

            ParseError::User { error } => error,
        }
    }
}

impl From<&Error> for LocInfo {
    fn from(e: &Error) -> Self {
        match e {
            Error::InvalidToken(loc)
            | Error::UnrecognizedEof(loc, _)
            | Error::UnrecognizedToken(loc, _)
            | Error::ExtraToken(loc)
            | Error::UnrecognizedSelector(loc)
            | Error::DuplicatedKeyInFrom(loc)
            | Error::DuplicatedSelectorName(loc)
            | Error::InvalidNumericValue(loc) => *loc,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_into_loc() {
        let loc = (1, 2);

        assert_eq!(loc, (&Error::InvalidToken(loc)).into());
        assert_eq!(loc, (&Error::UnrecognizedEof(loc, vec![])).into());
        assert_eq!(loc, (&Error::UnrecognizedToken(loc, vec![])).into());
        assert_eq!(loc, (&Error::ExtraToken(loc)).into());
        assert_eq!(loc, (&Error::UnrecognizedSelector(loc)).into());
        assert_eq!(loc, (&Error::DuplicatedKeyInFrom(loc)).into());
        assert_eq!(loc, (&Error::DuplicatedSelectorName(loc)).into());
        assert_eq!(loc, (&Error::InvalidNumericValue(loc)).into());
    }

    #[test]
    fn test_error() {
        let err = LalrError::ExtraToken {
            token: (0, Token(0, "a"), 1),
        };

        assert_eq!(Error::ExtraToken((0, 1)), err.into());
    }
}