fixed bugs

Author: Noam Lewis

src/main.rs

@@ -250,13 +250,11 @@ impl State {
     }
 
     fn iter_line_prev(&mut self) {
-        self.cursor.y -= 1;
-        self.lines.prev_line();
+        self.cursor.y -= self.lines.prev_line();
     }
 
     fn iter_line_next(&mut self) {
-        self.cursor.y += 1;
-        self.lines.next_line();
+        self.cursor.y += self.lines.next_line();
     }
 
     fn delete_prev_char(&mut self) {
@@ -278,7 +276,7 @@ impl State {
         if self.cursor.x < line.len() as u16 {
             line.remove(self.cursor.x as usize);
         } else {
-            self.lines.next_line();
+            self.iter_line_next();
             let next_line = self.lines.remove();
             let line = self.lines.get_mut();
             line.extend(next_line);
@@ -288,9 +286,9 @@ impl State {
     fn insert_line(&mut self) {
         let line = self.lines.get_mut();
         let new_line = line.split_off(self.cursor.x as usize);
+        self.lines.insert_after(LoadedLine::new(new_line));
         self.iter_line_next();
         self.cursor.x = 0;
-        self.lines.insert(LoadedLine::new(new_line));
     }
 
     fn draw_frame(&mut self, frame: &mut Frame) {
@@ -303,20 +301,20 @@ impl State {
         let window_offset = self.window_offset;
 
         let render_line = |pair: (usize, &LoadedLine)| -> Line<'_> {
-            let content = pair
-                .1
+            let (line_index, loaded_line) = pair;
+
+            let content = loaded_line
                 .chars_iter()
                 .skip(window_offset.x as usize)
                 .collect::<String>();
-            let line_index = pair.0;
             Line::from(vec![
                 Span::styled(
                     format!(
                         "{:>width$}",
-                        (line_index + 1),
+                        (line_index + window_offset.y as usize + 1),
                         width = left_margin_width as usize
                     ),
-                    if cursor.y as usize == line_index {
+                    if (cursor.y - window_offset.y) as usize == line_index {
                         Style::new().white()
                     } else {
                         Style::new().dark_gray()
@@ -327,21 +325,26 @@ impl State {
             ])
         };
 
-        self.status_text = format!(
-            "cursor: {:?}, window_offset {:?}",
-            self.cursor, self.window_offset
-        );
-
         frame.render_widget(
             Text::from_iter(
                 self.lines
-                    .iter_at(-(cursor.y as i64), lines_per_page as usize)
+                    .iter_at(
+                        self.window_offset.y as i64 - cursor.y as i64,
+                        lines_per_page as usize,
+                    )
                     .enumerate()
                     .map(render_line),
             ),
             text_area,
         );
 
+        self.status_text = format!(
+            "cursor: {:?}, window_offset {:?}, line_index: {:?}",
+            self.cursor,
+            self.window_offset,
+            self.lines.get_index()
+        );
+
         frame.render_widget(self.status_text.clone(), status_area);
 
         frame.set_cursor_position(Position::new(

src/virtual_file.rs

@@ -109,25 +109,29 @@ impl VirtualFile {
         };
     }
 
-    pub fn prev_line(&mut self) -> Option<&mut LoadedLine> {
-        if self.line_index == 0 {
-            assert!(self.loaded_chunks.start > 0);
+    pub fn prev_line(&mut self) -> u16 {
+        if self.line_index == 0 && self.loaded_chunks.start > 0 {
             // seek to previous chunk
             self.seek(self.chunk_size * (self.loaded_chunks.start - 1));
         }
-        self.line_index -= 1;
-        return self.chunk_lines.get_mut(self.line_index);
+        // after possible seek, line_index may still be zero if there was nothing to load
+        if self.line_index > 0 {
+            self.line_index -= 1;
+            return 1;
+        }
+        return 0;
     }
 
-    pub fn next_line(&mut self) -> Option<&mut LoadedLine> {
-        let lines_count = self.chunk_lines.len();
-        self.line_index += 1;
-        // "+1" because last line in the chunk may be incomplete
-        if self.line_index + 1 >= lines_count {
-            // seek to next chunk
+    pub fn next_line(&mut self) -> u16 {
+        if self.line_index + 2 >= self.chunk_lines.len() {
+            // fetch more lines, after increasing index it will be the last line which may be incomplete
             self.seek(self.chunk_size * self.loaded_chunks.end);
         }
-        return self.chunk_lines.get_mut(self.line_index);
+        if self.line_index + 1 < self.chunk_lines.len() {
+            self.line_index += 1;
+            return 1;
+        }
+        return 0;
     }
 
     pub fn remove(&mut self) -> LoadedLine {
@@ -145,8 +149,12 @@ impl VirtualFile {
         return removed_line;
     }
 
-    pub fn insert(&mut self, new_line: LoadedLine) {
-        self.chunk_lines.insert(self.line_index, new_line);
+    pub fn get_index(&self) -> usize {
+        self.line_index
+    }
+
+    pub fn insert_after(&mut self, new_line: LoadedLine) {
+        self.chunk_lines.insert(self.line_index + 1, new_line);
     }
 
     pub fn get(&self) -> &LoadedLine {
@@ -170,33 +178,26 @@ impl VirtualFile {
         count: usize,
     ) -> impl Iterator<Item = &LoadedLine> {
         // TODO: This is inefficient and also clobbers the current line_index
-
+        let mut clobber: i32 = 0;
         if offset_from_line_index < 0 {
             // need to iterate lines backwards
             for _ in offset_from_line_index..0 {
-                self.prev_line();
+                clobber -= self.prev_line() as i32;
             }
         } else {
             // need to iterate lines forwards
             for _ in 0..offset_from_line_index {
-                self.next_line();
+                clobber += self.next_line() as i32;
             }
         }
         // line_index is now at the start of the range
+        let start_index = self.line_index;
         // materialize 'count' lines
         for _ in 0..count {
-            self.next_line();
+            clobber += self.next_line() as i32;
         }
-
-        // correct the line_index: go back to beginning of the range
-        for _ in 0..count {
-            self.prev_line();
-        }
-        let start_index = self.line_index;
         // ... and now go back to where line_index was before
-        for _ in 0..offset_from_line_index {
-            self.prev_line();
-        }
+        self.line_index = (self.line_index as i32 - clobber).try_into().unwrap();
 
         self.chunk_lines.iter().skip(start_index)
     }
@@ -265,7 +266,7 @@ mod tests {
         let file = create_test_file("line1\nline2\nline3\n");
         let mut vf = VirtualFile::new(10, file);
         vf.seek(0);
-        vf.insert(LoadedLine::new("new_line".to_string()));
+        vf.insert_after(LoadedLine::new("new_line".to_string()));
         assert_eq!(vf.get().str(), "new_line");
     }