regast 0.1.0

Regular expressions with first-class syntax and parse trees
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

use regast::{Backend, PtKind, Regast, Span};

#[test]
fn finds_leftmost_longest_match_with_absolute_spans() {
    let tree = Regast::new("(a|ab)")
        .unwrap()
        .find_parse("zababa")
        .unwrap()
        .unwrap();
    assert_eq!(tree.flatten(), "ab");
    assert_eq!(tree.match_span(), Span::new(1, 3));
    assert_eq!(tree.group_all(1)[0].span, Span::new(1, 3));
    assert!(matches!(
        tree.walk()
            .find(|node| matches!(node.kind, PtKind::AltTaken { .. }))
            .unwrap()
            .kind,
        PtKind::AltTaken { arm: 1 }
    ));
}

#[test]
fn anchors_use_full_input_boundaries_during_search() {
    assert!(
        Regast::new("^ab")
            .unwrap()
            .find_parse("zab")
            .unwrap()
            .is_none()
    );

    let start = Regast::new("^ab")
        .unwrap()
        .find_parse("abz")
        .unwrap()
        .unwrap();
    assert_eq!(start.match_span(), Span::new(0, 2));

    let end = Regast::new("ab$")
        .unwrap()
        .find_parse("zab")
        .unwrap()
        .unwrap();
    assert_eq!(end.match_span(), Span::new(1, 3));

    let empty_end = Regast::new("$").unwrap().find_parse("é").unwrap().unwrap();
    assert_eq!(empty_end.match_span(), Span::new(2, 2));
}

#[test]
fn alternate_backends_preserve_search_and_parse_semantics() {
    for backend in [Backend::Antimirov, Backend::TaggedNfa] {
        let regex = Regast::builder("^a|ab+$").backend(backend).build().unwrap();
        assert!(regex.is_match("a"));
        assert!(!regex.is_match("zab"));
        let tree = regex.find_parse("zabbb").unwrap().unwrap();
        assert_eq!(tree.flatten(), "abbb");
        assert_eq!(tree.match_span(), Span::new(1, 5));

        let anchored = Regast::builder("^([ab]+)$")
            .backend(backend)
            .build()
            .unwrap()
            .parse("abba")
            .unwrap();
        assert_eq!(anchored.flatten(), "abba");
        assert_eq!(anchored.group_all(1)[0].span, Span::new(0, 4));
    }
}