kutil 0.0.6

Kutil utilities collection
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

/// Escape character.
pub const ESCAPE_CHARACTER: char = '\\';

//
// Escape
//

/// Escape utilities.
pub trait Escape {
    /// Replaces escaped patterns with the pattern.
    fn unescape(&self, pattern: &str) -> String;

    /// Find while ignoring escaped patterns.
    fn find_ignore_escaped(&self, pattern: &str) -> Option<usize>;

    /// Split once while ignoring escaped patterns.
    fn split_once_ignore_escaped(&self, pattern: &str) -> Option<(&str, &str)>;
}

impl Escape for str {
    fn unescape(&self, pattern: &str) -> String {
        let escaped_pattern = String::from(ESCAPE_CHARACTER) + pattern;
        self.replace(&escaped_pattern, pattern)
    }

    fn find_ignore_escaped(&self, pattern: &str) -> Option<usize> {
        let pattern_chars: Vec<_> = pattern.chars().collect();
        let pattern_chars_count = pattern_chars.len();

        let mut escaped = false;
        let mut pattern_chars_index = 0;

        for (byte_index, c) in self.char_indices() {
            if c == pattern_chars[pattern_chars_index] {
                pattern_chars_index += 1;
                if pattern_chars_index == pattern_chars_count {
                    if escaped {
                        pattern_chars_index = 0;
                        escaped = false;
                    } else {
                        return Some(byte_index - pattern.len() + 1);
                    }
                }
            } else if c == ESCAPE_CHARACTER {
                escaped = true;
            } else {
                escaped = false;
            }
        }

        None
    }

    fn split_once_ignore_escaped(&self, pattern: &str) -> Option<(&str, &str)> {
        self.find_ignore_escaped(pattern).map(|index| (&self[..index], &self[index + pattern.len()..]))
    }
}