ec4rs 1.2.0

EditorConfig For Rust
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

use super::{Glob, Splitter};

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
pub enum Matcher {
    End,
    AnySeq(bool),
    AnyChar,
    Sep,
    Suffix(String),
    // TODO: Grapheme clusters?
    CharClass(super::FlatSet<char>, bool),
    Range(isize, isize),
    Any(super::FlatSet<super::Glob>),
}

fn try_match<'a, 'b>(
    splitter: Splitter<'a>,
    matcher: &'b Matcher,
    state: &mut super::stack::SaveStack<'a, 'b>,
) -> Option<Splitter<'a>> {
    match matcher {
        Matcher::End => splitter.match_end(),
        Matcher::Sep => splitter.match_sep(),
        Matcher::AnyChar => splitter.match_any(false),
        Matcher::AnySeq(sep) => {
            if let Some(splitter) = splitter.clone().match_any(*sep) {
                state.add_rewind(splitter, matcher);
            }
            Some(splitter)
        }
        Matcher::Suffix(s) => splitter.match_suffix(s.as_str()),
        Matcher::CharClass(cs, should_have) => {
            let (splitter, c) = splitter.next_char()?;
            if cs.contains(c) != *should_have {
                return None;
            }
            Some(splitter)
        }
        Matcher::Range(lower, upper) => splitter.match_number(*lower, *upper),
        Matcher::Any(options) => {
            state.add_alts(splitter.clone(), options.as_slice());
            Some(splitter)
        }
    }
}

#[must_use]
pub fn matches<'a>(path: &'a std::path::Path, glob: &Glob) -> Option<Splitter<'a>> {
    let mut splitter = super::Splitter::new(path)?;
    let mut state = super::stack::SaveStack::new(&splitter, glob);
    loop {
        if let Some(matcher) = state.globs().next() {
            if let Some(splitter_new) = try_match(splitter, matcher, &mut state) {
                splitter = splitter_new;
            } else if let Some(splitter_new) = state.restore() {
                splitter = splitter_new;
            } else {
                return None;
            }
        } else {
            return Some(splitter);
        }
    }
}