mrubyedge 2.1.2

mruby/edge is yet another mruby that is specialized for running on WASM
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

// File.fnmatch-style assertion patterns, including braces and dot/slash matches.
// Operate on bytes, as mruby's test driver does.
pub fn matches(pattern: &str, value: &str) -> bool {
    match_bytes(pattern.as_bytes(), value.as_bytes())
}

fn match_bytes(p: &[u8], s: &[u8]) -> bool {
    let Some((&first, tail)) = p.split_first() else {
        return s.is_empty();
    };
    match first {
        b'*' => (0..=s.len()).any(|i| match_bytes(tail, &s[i..])),
        b'?' => !s.is_empty() && match_bytes(tail, &s[1..]),
        b'\\' => {
            tail.first() == s.first()
                && !tail.is_empty()
                && !s.is_empty()
                && match_bytes(&tail[1..], &s[1..])
        }
        b'[' => {
            if s.is_empty() {
                return false;
            }
            let mut i = 1;
            let negated = matches!(p.get(i), Some(b'!' | b'^'));
            if negated {
                i += 1;
            }
            let mut found = false;
            while i < p.len() && p[i] != b']' {
                if p[i] == b'\\' {
                    i += 1;
                }
                if i >= p.len() {
                    return false;
                }
                let low = p[i];
                i += 1;
                if p.get(i) == Some(&b'-') && p.get(i + 1).is_some_and(|c| *c != b']') {
                    i += 1;
                    if p[i] == b'\\' {
                        i += 1;
                    }
                    if i >= p.len() {
                        return false;
                    }
                    found |= low <= s[0] && s[0] <= p[i];
                    i += 1;
                } else {
                    found |= low == s[0];
                }
            }
            i < p.len() && found != negated && match_bytes(&p[i + 1..], &s[1..])
        }
        b'{' => {
            let mut depth = 0;
            let mut start = 1;
            let mut alternatives = Vec::new();
            let mut i = 1;
            while i < p.len() {
                match p[i] {
                    b'\\' => i += 1,
                    b'{' => depth += 1,
                    b'}' if depth == 0 => {
                        alternatives.push(&p[start..i]);
                        return alternatives.into_iter().any(|part| {
                            let mut expanded = part.to_vec();
                            expanded.extend_from_slice(&p[i + 1..]);
                            match_bytes(&expanded, s)
                        });
                    }
                    b'}' => depth -= 1,
                    b',' if depth == 0 => {
                        alternatives.push(&p[start..i]);
                        start = i + 1;
                    }
                    _ => {}
                }
                i += 1;
            }
            false
        }
        _ => s.first() == Some(&first) && match_bytes(tail, &s[1..]),
    }
}

#[test]
fn assertion_patterns() {
    for (p, s, expected) in [
        ("*", ".path/to/file", true),
        ("a?c", "abc", true),
        ("a?c", "ac", false),
        ("[a-c]", "b", true),
        ("[^a-c]", "b", false),
        ("[!a-c]", "z", true),
        (r"a\*b", "a*b", true),
        ("{ab,{cd,ef}}?", "efg", true),
        ("{ab,cd}", "abx", false),
        ("[", "x", false),
        ("", "", true),
        ("?", "", false),
    ] {
        assert_eq!(matches(p, s), expected, "{p:?}, {s:?}");
    }
}