openpql-range-parser 0.1.5

Poker Range Notation Parser
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use super::{LocInfo, Term};

/// Parsed range expression tree.
#[derive(PartialEq, Eq, Debug)]
pub enum Expr {
    /// Exclusion `A!B`.
    Not(Box<Self>, Box<Self>),
    /// Intersection `A:B`.
    And(Box<Self>, Box<Self>),
    /// Union `A,B`.
    Or(Box<Self>, Box<Self>),
    /// Leaf term with its source span.
    Term(Term, LocInfo),
}

impl From<(Term, LocInfo)> for Expr {
    fn from((t, loc): (Term, LocInfo)) -> Self {
        Self::Term(t, loc)
    }
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod tests {
    use super::*;
    use crate::*;

    fn assert_expr(s: &str, expected: Expr) {
        assert_eq!(
            *parse_expr(false, s).unwrap(),
            expected,
            "{s} != {expected:?}"
        );
    }

    fn term_loc(s: &str, a: Loc, b: Loc) -> (Term, LocInfo) {
        (parse_term(s).unwrap(), (a, b))
    }

    fn binop<S, T>(l: S, r: T, f: fn(Box<Expr>, Box<Expr>) -> Expr) -> Expr
    where
        Expr: From<S> + From<T>,
    {
        f(Box::new(Expr::from(l)), Box::new(Expr::from(r)))
    }

    fn not<S, T>(l: S, r: T) -> Expr
    where
        Expr: From<S> + From<T>,
    {
        binop(l, r, Expr::Not)
    }

    fn and<S, T>(l: S, r: T) -> Expr
    where
        Expr: From<S> + From<T>,
    {
        binop(l, r, Expr::And)
    }

    fn or<S, T>(l: S, r: T) -> Expr
    where
        Expr: From<S> + From<T>,
    {
        binop(l, r, Expr::Or)
    }

    #[test]
    fn test_expr_term() {
        assert_expr("AsA", term_loc("AsA", 0, 3).into());
    }

    #[test]
    fn test_expr_and() {
        assert_expr("AsA:ss", and(term_loc("AsA", 0, 3), term_loc("ss", 4, 6)));
    }

    #[test]
    fn test_expr_or() {
        assert_expr("AsA,ss", or(term_loc("AsA", 0, 3), term_loc("ss", 4, 6)));
    }

    #[test]
    fn test_expr_not() {
        assert_expr("AsA!ss", not(term_loc("AsA", 0, 3), term_loc("ss", 4, 6)));
    }

    #[test]
    fn test_expr_precedence() {
        assert_expr(
            "A:B!c,d",
            or(
                and(
                    term_loc("A", 0, 1),
                    not(term_loc("B", 2, 3), term_loc("c", 4, 5)),
                ),
                term_loc("d", 6, 7),
            ),
        );

        assert_expr(
            "A:B!(c,d)",
            and(
                term_loc("A", 0, 1),
                not(
                    term_loc("B", 2, 3),
                    or(term_loc("c", 5, 6), term_loc("d", 7, 8)),
                ),
            ),
        );
    }
}