tuc 1.3.0

When cut doesn't cut it
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::finders::common::DelimiterFinder;
use regex::bytes::Regex;
use std::ops::Range;

pub struct RegexFinder {
    regex: Regex,
    trim_empty: bool,
}

impl RegexFinder {
    pub fn new(regex: Regex) -> Self {
        Self::new_with_trim(regex, false)
    }

    pub fn new_with_trim(regex: Regex, trim_empty: bool) -> Self {
        Self { regex, trim_empty }
    }
}

impl DelimiterFinder for RegexFinder {
    type Iter<'a> = Box<dyn Iterator<Item = Range<usize>> + 'a>;

    #[inline(always)]
    fn find_ranges<'a>(&'a self, line: &'a [u8]) -> Self::Iter<'a> {
        if self.trim_empty {
            let line_len = line.len();
            Box::new(
                self.regex
                    .find_iter(line)
                    .filter(move |m| {
                        !((m.start() == 0 && m.end() == 0)
                            || (m.start() == line_len && m.end() == line_len))
                    })
                    .map(|m| m.start()..m.end()),
            )
        } else {
            Box::new(self.regex.find_iter(line).map(|m| m.start()..m.end()))
        }
    }
}

#[cfg(test)]
mod tests {
    use std::str::FromStr;
    use std::sync::LazyLock;

    use super::*;

    static SMALL_DELIM_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::from_str("[-]").unwrap());
    static BIG_DELIM_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::from_str("-{2}").unwrap());

    #[test]
    fn forward_small_delimiter_empty_line() {
        let finder = RegexFinder::new(SMALL_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"").collect();
        assert_eq!(Vec::<Range<usize>>::new(), result);
    }

    #[test]
    fn forward_small_delimiter_only_delimiter() {
        let finder = RegexFinder::new(SMALL_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"-").collect();
        assert_eq!(vec![0..1], result);
    }

    #[test]
    fn forward_small_delimiter_regular_scenarios() {
        let finder = RegexFinder::new(SMALL_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"a").collect();
        assert_eq!(Vec::<Range<usize>>::new(), result);

        let finder = RegexFinder::new(SMALL_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"a-b").collect();
        assert_eq!(vec![1..2], result);

        let finder = RegexFinder::new(SMALL_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"a-b-c").collect();
        assert_eq!(vec![1..2, 3..4], result);

        let finder = RegexFinder::new(SMALL_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"a-b-c-").collect();
        assert_eq!(vec![1..2, 3..4, 5..6], result);

        let finder = RegexFinder::new(SMALL_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"-a-b-c").collect();
        assert_eq!(vec![0..1, 2..3, 4..5], result);
    }

    #[test]
    fn forward_big_delimiter_empty_line() {
        let finder = RegexFinder::new(BIG_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"").collect();
        assert_eq!(Vec::<Range<usize>>::new(), result);
    }

    #[test]
    fn forward_big_delimiter_only_delimiter() {
        let finder = RegexFinder::new(BIG_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"--").collect();
        assert_eq!(vec![0..2], result);
    }

    #[test]
    fn forward_big_delimiter_regular_scenarios() {
        let finder = RegexFinder::new(BIG_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"a").collect();
        assert_eq!(Vec::<Range<usize>>::new(), result);

        let finder = RegexFinder::new(BIG_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"a--b").collect();
        assert_eq!(vec![1..3], result);

        let finder = RegexFinder::new(BIG_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"a--b--c").collect();
        assert_eq!(vec![1..3, 4..6], result);

        let finder = RegexFinder::new(BIG_DELIM_REGEX.clone());
        let result: Vec<Range<usize>> = finder.find_ranges(b"a--b--c--").collect();
        assert_eq!(vec![1..3, 4..6, 7..9], result);
        let finder = RegexFinder::new(BIG_DELIM_REGEX.clone());

        let result: Vec<Range<usize>> = finder.find_ranges(b"--a--b--c").collect();
        assert_eq!(vec![0..2, 3..5, 6..8], result);
    }
}