rexile 0.5.7

A blazing-fast regex engine with 22x faster compilation and optimized case-insensitive matching
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

use rexile::Pattern;

#[test]
fn test_replace_simple() {
    let pattern = Pattern::new(r"\w+").unwrap();

    // Replace first word
    assert_eq!(pattern.replace("hello world", "goodbye"), "goodbye world");

    // No match
    assert_eq!(pattern.replace("123 456", "xxx"), "xxx 456");
}

#[test]
fn test_replace_with_captures() {
    let pattern = Pattern::new(r"(\w+)=(\d+)").unwrap();

    // Replace first match with captures
    assert_eq!(pattern.replace("a=1 b=2", "$1:[$2]"), "a:[1] b=2");

    // Multiple groups
    assert_eq!(pattern.replace("foo=42 bar=99", "$2=$1"), "42=foo bar=99");
}

#[test]
fn test_replace_no_match() {
    let pattern = Pattern::new(r"\d+").unwrap();

    // No match, return original
    assert_eq!(pattern.replace("no numbers here", "XXX"), "no numbers here");
}

#[test]
fn test_replace_all_simple() {
    let pattern = Pattern::new(r"\d+").unwrap();

    // Replace all digits
    assert_eq!(pattern.replace_all("a1b2c3", "X"), "aXbXcX");
}

#[test]
fn test_replace_all_with_captures() {
    let pattern = Pattern::new(r"(\w+)=(\d+)").unwrap();

    // Replace all with captures
    assert_eq!(
        pattern.replace_all("a=1 b=2 c=3", "$1:[$2]"),
        "a:[1] b:[2] c:[3]"
    );
}

#[test]
fn test_split_simple() {
    let pattern = Pattern::new(r"\s+").unwrap();

    // Split on whitespace
    let parts: Vec<_> = pattern.split("a  b   c").collect();
    assert_eq!(parts, vec!["a", "b", "c"]);
}

#[test]
fn test_split_single_delimiter() {
    let pattern = Pattern::new(r",").unwrap();

    let parts: Vec<_> = pattern.split("apple,banana,cherry").collect();
    assert_eq!(parts, vec!["apple", "banana", "cherry"]);
}

#[test]
fn test_split_no_match() {
    let pattern = Pattern::new(r",").unwrap();

    // No delimiter, return whole string
    let parts: Vec<_> = pattern.split("no delimiters").collect();
    assert_eq!(parts, vec!["no delimiters"]);
}

#[test]
fn test_split_empty_parts() {
    let pattern = Pattern::new(r",").unwrap();

    // Empty parts between delimiters
    let parts: Vec<_> = pattern.split("a,,b").collect();
    assert_eq!(parts, vec!["a", "", "b"]);
}

#[test]
fn test_replace_literal_dollar() {
    let pattern = Pattern::new(r"\w+").unwrap();

    // $ not followed by digit should be literal
    assert_eq!(pattern.replace("hello", "$price"), "$price");
}

#[test]
fn test_replace_all_no_match() {
    let pattern = Pattern::new(r"\d+").unwrap();

    // No match, return original
    assert_eq!(pattern.replace_all("no numbers", "X"), "no numbers");
}