spidior 0.2.1

A tool for handling sed-like substitution tasks where pesky source code semantics are getting in the way.
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 std::error::Error;
/// A buffer for holding text, supporting operations
/// for replacement of text as well as appending
pub struct TextBuffer {
    buf: String,
}

impl TextBuffer {
    /// Creates a new text buffer
    ///
    /// # Returns
    ///
    /// A text buffer...
    pub fn new() -> Self {
        Self { buf: String::new() }
    }
    /// Replaces the text in the buffer starting at `start` and
    /// extending for `length` characters with the text from `replacement`.
    ///
    ///
    /// # Arguments
    ///
    /// * `start` - The index into the buffer we start replacing from
    /// * `length` - The length of the replacement we are performing
    /// * `replacement` - The new text to put in the buffer
    ///
    /// # Returns
    ///
    /// A Result<String, Box<dyn Error>>, where on success, it returns
    /// what was erased. It will Err if you attempt to replace more text
    /// than exists in the buffer.
    pub fn replace(
        &mut self,
        start: usize,
        length: usize,
        replacement: &str,
    ) -> Result<String, Box<dyn Error>> {
        if self.buf.len() < start + length {
            return Err("Replacing more of the string than exists".into());
        }
        let erased = self.buf[start..start + length].to_string();
        self.buf = format!(
            "{}{}{}",
            &self.buf[..start],
            replacement,
            &self.buf[start + length..]
        )
        .to_string();
        Ok(erased)
    }
    /// Gets the text in the buffer starting at `start` and
    /// extending for `length` characters.
    ///
    ///
    /// # Arguments
    ///
    /// * `start` - The index into the buffer we start reading from
    /// * `length` - The length of the read we are performing
    ///
    /// # Returns
    ///
    /// A Result<String, Box<dyn Error>>, where on success, it returns
    /// the desired text. It will Err if you attempt to read more text
    /// than exists in the buffer.
    pub fn get(
        &mut self,
        start: usize,
        length: usize,
    ) -> Result<String, Box<dyn Error>> {
        if self.buf.len() < start + length {
            return Err("Reading more of the string than exists".into());
        }
        Ok(self.buf[start..start + length].to_string())
    }
    /// Appends some text from `s` to the end of the buffer.
    ///
    ///
    /// # Arguments
    ///
    /// * `s` - The text we are appending
    /// exists in the buffer.
    pub fn add(&mut self, s: &str) {
        self.buf += s;
    }
    /// Returns a reference to the contents of the buffer
    ///
    ///
    /// # Returns
    ///
    /// A String reference with the buffer contents
    #[cfg(test)]
    pub fn read(&self) -> &String {
        &self.buf
    }
    /// Consumes the TextBuffer, returning the contents
    ///
    ///
    /// # Returns
    ///
    /// A String with the buffer contents
    pub fn consume(self) -> String {
        self.buf
    }
}

#[test]
fn buffer_add() {
    let mut tb = TextBuffer::new();
    tb.add("hello");
    tb.add(" world!");
    assert_eq!("hello world!", tb.read());
    assert_eq!("hello world!", tb.consume());
}

#[test]
fn buffer_replace() {
    let mut tb = TextBuffer::new();
    tb.add("hello world!");
    tb.replace(1, 3, "ooooo").unwrap();
    assert_eq!("hoooooo world!", tb.read());
    tb.replace(0, 1, "b").unwrap();
    assert_eq!("boooooo world!", tb.read());
    tb.replace(13, 1, "?").unwrap();
    assert_eq!("boooooo world?", tb.read());
}