rep-grep 0.0.8

wgrep/write-grep CLI
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

use crate::edit::Edit;
use crate::replacer::Replacer;
use std::str;

pub(crate) struct Patcher<'a> {
    edits: Vec<Edit>,
    replacer: Option<&'a Replacer>,
}

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("Invalid line number {0}")]
    LineNumber(u32),
    #[error("invalid UTF-8 in replacement: {0}")]
    Utf8(#[from] std::str::Utf8Error),
}

impl<'a> Patcher<'a> {
    pub(crate) fn new(edits: Vec<Edit>, replacer: Option<&'a Replacer>) -> Self {
        Self { edits, replacer }
    }

    pub(crate) fn patch(&self, mut lines: Vec<String>, delete: bool) -> Result<String, Error> {
        if delete {
            let mut indexes: Vec<u32> = self.edits.iter().map(|e| e.line_number).collect();
            indexes.sort_unstable();
            indexes.dedup();
            indexes.reverse();

            // Subtract `1` from the line number because line numbers start from `1` and array
            // indices start from `0`
            for index in indexes {
                if index == 0 || index as usize > lines.len() {
                    return Err(Error::LineNumber(index));
                }
                let index_size = index as usize - 1;
                lines.remove(index_size);
            }
            return Ok(lines.join("\n"));
        }
        for edit in &self.edits {
            if edit.line_number == 0 || edit.line_number as usize > lines.len() {
                return Err(Error::LineNumber(edit.line_number));
            }
            let index = edit.line_number as usize - 1;
            if let Some(replacer) = &self.replacer {
                let replaced = &replacer.replace(edit.text.as_bytes());
                let text = str::from_utf8(replaced)?;
                lines[index] = text.to_string();
            } else {
                lines[index] = edit.text.clone();
            }
        }
        Ok(lines.join("\n"))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    #[test]
    fn patch_bad_number() {
        let patcher = Patcher::new(
            vec![
                Edit {
                    file: PathBuf::from("f"),
                    line_number: 1,
                    text: "foo".to_string(),
                },
                Edit {
                    file: PathBuf::from("f"),
                    line_number: 3,
                    text: "bar".to_string(),
                },
            ],
            None,
        );
        let lines = vec!["a".to_string(), "b".to_string()];
        let result = patcher.patch(lines, false);
        assert!(matches!(result, Err(Error::LineNumber(3))));
    }

    #[test]
    fn patch() {
        let patcher = Patcher::new(
            vec![
                Edit {
                    file: PathBuf::from("f"),
                    line_number: 2,
                    text: "foo".to_string(),
                },
                Edit {
                    file: PathBuf::from("f"),
                    line_number: 3,
                    text: "bar".to_string(),
                },
            ],
            None,
        );
        let lines = vec!["a".to_string(), "b".to_string(), "c".to_string()];
        let result = patcher.patch(lines, false);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "a\nfoo\nbar");
    }
}