csplit 0.1.0

a clone of the unix coreutil csplit
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

use super::Pattern;

/// Chunks corresponding to a matched pattern.
/// That is, yields a string corresponding from the current line
/// to the next match
pub struct Chunks<'a, P>
where
    P: Iterator<Item = Pattern>,
{
    s: &'a str,
    indices: Indices<'a, P>,
}

/// Indices yields the `(start, end)` pairs that mark the
/// lines where a new file should start or end according to the
/// provided patterns. Is not used directly;
struct Indices<'a, P>
where
    P: Iterator<Item = Pattern>,
{
    lines: std::iter::Enumerate<std::str::Lines<'a>>,
    patterns: P,
    pattern: Pattern,
    start: usize,
}

impl<'a, P> Indices<'a, P>
where
    P: Iterator<Item = Pattern>,
{
     fn new<I>(s: &'a str, patterns: I) -> Option<Self>
    where
        I: IntoIterator<IntoIter = P, Item = Pattern>,
    {
        let mut patterns = patterns.into_iter();
        let pattern = match patterns.next() {
            Some(p) => p,
            None => return None,
        };
        Some(Indices {
            lines: s.lines().enumerate(),
            patterns,
            pattern,
            start: 0,
        })
    }
}

impl<'a, P> Chunks<'a, P>
where
    P: Iterator<Item = Pattern>,
{
    pub fn new<I>(s: &'a str, patterns: I) -> Option<Self>
    where
        I: IntoIterator<Item = Pattern, IntoIter = P>,
    {
        let indices = Indices::new(&s, patterns)?;
        Some(Chunks { s, indices })
    }
}

impl<'a, P> Iterator for Chunks<'a, P>
where
    P: Iterator<Item = Pattern>,
{
    type Item = String;

    fn next(&mut self) -> Option<Self::Item> {
        if let Some((start, end)) = self.indices.next() {
            let lines: Vec<&str> = self.s.lines().skip(start).take(end).collect();
            Some(lines.join("\n"))
        } else {
            None
        }
    }
}
impl<'a, P> Iterator for Indices<'a, P>
where
    P: Iterator<Item = Pattern>,
{
    type Item = (usize, usize);

    fn next(&mut self) -> Option<Self::Item> {
        while let Some((i, text)) = self.lines.next() {
            if let Some((end, write)) = self.pattern.find(self.start, i, text) {
                let start = self.start;
                self.start = end;
                self.pattern = match &self.pattern {
                    Pattern::Match { repeat: 0, .. } | Pattern::NLines { repeat: 0, .. } | Pattern::UntilLine(_) => {
                        match self.patterns.next() {
                            Some(p) => p,
                            None => break,
                        }
                    },
                    Pattern::Match {
                        re,
                        repeat,
                        offset,
                        skip,
                    } => Pattern::Match {
                        re: re.clone(),
                        repeat: repeat - 1,
                        offset: *offset,
                        skip: *skip,
                    },
                    Pattern::NLines { n, repeat } => Pattern::NLines {
                        n: *n,
                        repeat: repeat - 1,
                    },
                };
                if write {
                    return Some((start, end));
                } else {
                    return self.next();
                }
            };
        }
        None
    }
}