rules 0.0.2

An implementation of Perl 6 regex rules
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

use rules::unicode::regex::PERLS;
use rules::parse::Ast::*;
use rules::parse::Membership::*;
use rules::parse::Op::*;
use rules::range_set;

use super::parse;
use super::new_deque;

#[test]
fn chars() {
    // Set of chars inside `[]`
    let set = vec![Char('a'), Char('b'), Char('c')].into();
    // Deque of ops and sets inside `<>`
    let deque = new_deque(vec![Set(set, Inclusive)]);
    // A single class denoted by `<[]>`
    assert_eq!(vec![Class(deque)], parse(r"< [ abc ] >"));
}
#[test]
fn with_ops() {
    // Set of chars inside `[]`
    let set_a = vec![Char('a')].into();
    let set_b = vec![Char('b')].into();
    // Deque of ops and sets inside `<>`
    let deque = new_deque(vec![Set(set_a, Inclusive),
                               Op(Union),
                               Set(set_b, Inclusive)]);
    // A single class denoted by `<[]>`
    assert_eq!(vec![Class(deque)], parse(r"< [ a ] + [ b ] >"));
}
#[test]
fn pre_op() {
    // Set of chars inside `[]`
    let set = vec![Char('a')].into();
    // Deque of ops and sets inside `<>`. Pre-ops get an `Empty`
    // prepended so binary ops can be applied to them.
    let deque = new_deque(vec![Empty,
                               Op(Difference),
                               Set(set, Inclusive)]);
    // A single class denoted by `<[]>`
    assert_eq!(vec![Class(deque)], parse(r"< - [ a ] >"));
}
#[test]
fn post_op() {
    // Set of chars inside `[]`
    let set = vec![Char('a')].into();
    // Deque of ops and sets inside `<>`. Post-ops get an `Empty`
    // appended so binary ops can be applied to them.
    let deque = new_deque(vec![Set(set, Inclusive),
                               Op(Union),
                               Empty]);
    // A single class denoted by `<[]>`
    assert_eq!(vec![Class(deque)], parse(r"< [ a ] + >"));
}
#[test]
fn ellipsis() {
    // Set of chars inside `[]`
    let set = vec![Range(range_set::Range('a','d'))].into();
    // Deque of ops and sets inside `<>`.
    let deque = new_deque(vec![Set(set, Inclusive)]);
    // A single class denoted by `<[]>`
    assert_eq!(vec![Class(deque)], parse(r"< [ a .. d ] >"));
}
#[test]
fn escape_chars() {
    // Set of chars inside `[]`. `\s` is a set itself inside the set `[]`.
    // Deque of ops and sets inside `<>`.
    let deque1 = new_deque(vec![Set(PERLS.into(), Inclusive)]);
    assert_eq!(vec![Class(deque1)], parse(r"< [ \s ] >"));

    // Deque of ops and sets inside `<>`.
    let deque2 = new_deque(vec![Set(range_set::Set::new(), Exclusive)]);
    // A single class denoted by `<[]>`
    assert_eq!(vec![Class(deque2)], parse(r"< [ \s \S ] >"));
}
#[test]
fn unicode() {
    // Set of chars inside `[]`
    let set = vec![Char('a'), Char('こ')].into();
    // Deque of ops and sets inside `<>`.
    let deque = new_deque(vec![Set(set, Inclusive)]);
    assert_eq!(vec![Class(deque)], parse(r"< [ a こ ] >"));
}
#[test]
fn multiple_char_classes() {
    // Set of chars inside `[]`
    let set_a = vec![Char('a')].into();
    let set_c = vec![Char('c')].into();

    // Deque of ops and sets inside `<>`
    let deque_a = new_deque(vec![Set(set_a, Inclusive)]);
    let deque_c = new_deque(vec![Set(set_c, Inclusive)]);

    // Multiple character classes
    assert_eq!(vec![Class(deque_a),
                    Char('b'),
                    Class(deque_c)], parse(r"<[ a ]> b <[ c ]>"));
}