Skip to main content

vvv_core/text/
line_index.rs

1use super::Position;
2
3/// Maps byte offsets to [`Position`]s. Built once per file, queried many times.
4#[derive(Debug, Clone)]
5pub struct LineIndex {
6    /// Byte offset at which each line starts. Always begins with `0`.
7    line_starts: Vec<usize>,
8}
9
10impl LineIndex {
11    pub fn new(text: &str) -> Self {
12        let line_starts = std::iter::once(0)
13            .chain(text.match_indices('\n').map(|(i, _)| i + 1))
14            .collect();
15        Self { line_starts }
16    }
17
18    /// Zero-based line containing `offset`.
19    pub fn line_of(&self, offset: usize) -> usize {
20        self.line_starts
21            .partition_point(|&start| start <= offset)
22            .saturating_sub(1)
23    }
24
25    /// Byte offset where `line` starts.
26    pub fn line_start(&self, line: usize) -> Option<usize> {
27        self.line_starts.get(line).copied()
28    }
29
30    /// The text of `line` without its line terminator.
31    pub fn line_text<'t>(&self, text: &'t str, line: usize) -> Option<&'t str> {
32        let start = self.line_start(line)?;
33        let end = self.line_start(line + 1).unwrap_or(text.len());
34        Some(text[start..end].trim_end_matches(['\n', '\r']))
35    }
36
37    /// The byte offset of `position` in `text`; `None` past the end of the
38    /// file. Columns count characters, as [`Self::position`] produces them.
39    pub fn offset(&self, text: &str, position: Position) -> Option<usize> {
40        let line_start = *self.line_starts.get(position.line as usize)?;
41        let line = &text[line_start..];
42        let line = line.split('\n').next().unwrap_or(line);
43        let column = line
44            .char_indices()
45            .nth(position.column as usize)
46            .map(|(i, _)| i)
47            .or_else(|| (line.chars().count() == position.column as usize).then_some(line.len()))?;
48        Some(line_start + column)
49    }
50
51    /// Resolve `offset` against `text` (the same text this index was built from).
52    pub fn position(&self, text: &str, offset: usize) -> Position {
53        let offset = offset.min(text.len());
54        let line = self.line_of(offset);
55        let line_start = self.line_starts[line];
56        let column = text[line_start..offset].chars().count();
57        Position::new(line as u32, column as u32)
58    }
59}
60
61#[cfg(test)]
62mod tests {
63    use super::*;
64
65    #[test]
66    fn positions_count_chars_not_bytes() {
67        let text = "héllo\nwörld";
68        let index = LineIndex::new(text);
69        assert_eq!(index.position(text, 0), Position::new(0, 0));
70        assert_eq!(index.position(text, text.len()), Position::new(1, 5));
71        let w = text.find('w').unwrap();
72        assert_eq!(index.position(text, w + 3), Position::new(1, 2));
73    }
74
75    #[test]
76    fn line_text_strips_terminators() {
77        let text = "a\r\nbb\nccc";
78        let index = LineIndex::new(text);
79        assert_eq!(index.line_text(text, 0), Some("a"));
80        assert_eq!(index.line_text(text, 1), Some("bb"));
81        assert_eq!(index.line_text(text, 2), Some("ccc"));
82        assert_eq!(index.line_text(text, 3), None);
83    }
84
85    #[test]
86    fn offset_at_newline_belongs_to_the_line_it_ends() {
87        let text = "a\nb";
88        let index = LineIndex::new(text);
89        assert_eq!(index.position(text, 1), Position::new(0, 1));
90        assert_eq!(index.position(text, 2), Position::new(1, 0));
91    }
92}