nexedit 0.2.2

A vim-like text editor, with simple shortcuts.
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

use scribe::Buffer;
use std::iter::Iterator;

pub const PADDING_WIDTH: usize = 2;

pub struct LineNumbers {
    current_number: usize,
    buffer_line_count_width: usize,
}

impl LineNumbers {
    pub fn new(buffer: &Buffer, offset: Option<usize>) -> LineNumbers {
        LineNumbers {
            current_number: offset.unwrap_or(0),
            buffer_line_count_width: buffer.line_count().to_string().len(),
        }
    }

    pub fn width(&self) -> usize {
        self.buffer_line_count_width + PADDING_WIDTH
    }
}

impl Iterator for LineNumbers {
    type Item = String;

    fn next(&mut self) -> Option<String> {
        self.current_number += 1;
        Some(format!(
            " {:>width$} ",
            self.current_number,
            width = self.buffer_line_count_width
        ))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use scribe::Buffer;

    #[test]
    fn width_considers_buffer_line_count_and_padding() {
        let mut buffer = Buffer::new();
        for _ in 0..101 {
            buffer.insert("\n");
        }
        let line_numbers = LineNumbers::new(&buffer, None);

        assert_eq!(line_numbers.width(), 5);
    }

    #[test]
    fn line_numbers_without_offset_start_at_one() {
        let buffer = Buffer::new();
        let mut line_numbers = LineNumbers::new(&buffer, None);
        let next_number: usize = line_numbers
            .next()
            .unwrap()
            .split_whitespace()
            .last()
            .unwrap()
            .parse()
            .unwrap();
        assert_eq!(next_number, 1);
    }

    #[test]
    fn line_numbers_with_offset_start_at_offset_plus_one() {
        let buffer = Buffer::new();
        let offset = 10;
        let mut line_numbers = LineNumbers::new(&buffer, Some(offset));
        let next_number: usize = line_numbers
            .next()
            .unwrap()
            .split_whitespace()
            .last()
            .unwrap()
            .parse()
            .unwrap();
        assert_eq!(next_number, offset + 1);
    }

    #[test]
    fn line_numbers_increment_by_one() {
        let buffer = Buffer::new();
        let mut line_numbers = LineNumbers::new(&buffer, None);
        line_numbers.next();
        let next_number: usize = line_numbers
            .next()
            .unwrap()
            .split_whitespace()
            .last()
            .unwrap()
            .parse()
            .unwrap();
        assert_eq!(next_number, 2);
    }

    #[test]
    fn line_numbers_are_left_padded_based_on_buffer_line_count_width() {
        let mut buffer = Buffer::new();
        for _ in 0..101 {
            buffer.insert("\n");
        }
        let mut line_numbers = LineNumbers::new(&buffer, None);
        assert_eq!(line_numbers.next().unwrap(), "   1 ");
    }
}