cfg 0.10.1

Library for manipulating context-free grammars.
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

#![cfg(all(feature = "cfg-classify", feature = "cfg-sequence"))]

mod support;

use cfg::Cfg;
use cfg::sequence::Separator::*;
use cfg_classify::CfgClassifyExt;
use cfg_sequence::CfgSequenceExt;

#[test]
fn test_sequence() {
    let mut cfg: Cfg = Cfg::new();
    let [start, elem, sep] = cfg.sym();

    cfg.sequence(start)
        .separator(Trailing(sep))
        .inclusive(1, Some(1))
        .rhs(elem);

    cfg.set_roots([start]);

    let mut equivalent: Cfg = Cfg::new();
    let [start, elem, sep, g0] = equivalent.sym();

    equivalent.rule(start).rhs([g0, sep]).rule(g0).rhs([elem]);

    equivalent.set_roots([start]);

    support::assert_eq(&equivalent, &cfg);
    assert!(cfg.usefulness().all_useful());
}

#[test]
fn test_nulling_sequence() {
    let mut cfg: Cfg = Cfg::new();
    let [start, elem] = cfg.sym();

    cfg.sequence(start).inclusive(0, Some(0)).rhs(elem);

    cfg.set_roots([start]);

    let mut equivalent: Cfg = Cfg::new();
    let start = equivalent.next_sym(Some("start".into()));

    equivalent.rule(start).rhs([]);

    support::assert_eq_rules(equivalent.rules(), cfg.rules());
    assert!(cfg.usefulness().all_useful());
}

#[test]
fn test_sequence_1_4() {
    let mut cfg: Cfg = Cfg::new();
    let [start, elem, sep] = cfg.sym();

    cfg.sequence(start)
        .separator(Trailing(sep))
        .inclusive(1, Some(4))
        .rhs(elem);

    cfg.set_roots([start]);

    let mut equiv: Cfg = Cfg::new();
    let [start, elem, sep, g0, g1, g2, g3, g4] = equiv.sym();

    equiv
        .rule(start)
        .rhs([g0, sep]) // start  =>  (elem sep){1,4}
        .rule(g0)
        .rhs([g1]) // g0  =>  g1 | g2 g1  =>  (elem sep){2}? (elem | elem sep elem)
        .rhs([g2, g1])
        .rule(g2)
        .rhs([g3, sep]) // g2  =>  g3 sep  =>  elem sep elem sep
        .rule(g3)
        .rhs([elem, sep, elem]) // g3  =>  elem sep elem
        .rule(g1)
        .rhs([g4]) // g1  =>  g4 | g3  =>  elem | elem sep elem
        .rhs([g3])
        .rule(g4)
        .rhs([elem]); // g4  =>  elem

    support::assert_eq_rules(equiv.rules(), cfg.rules());
    assert!(cfg.usefulness().all_useful());
}

#[test]
fn test_sequence_combinations() {
    for i in 0..50 {
        let mut cfg: Cfg = Cfg::new();
        let [start, elem] = cfg.sym();

        cfg.sequence(start).inclusive(i, Some(99)).rhs(elem);

        cfg.set_roots([start]);

        assert!(cfg.usefulness().all_useful());
    }
}