modules helpppp

Author: Noam Lewis

src/chunks.rs

@@ -0,0 +1,126 @@
+use std::slice::{RSplit, Split};
+
+use crate::LoadedLine;
+
+pub struct Chunk<'a> {
+    file_offset: u64,
+    is_modified: bool,
+    data: &'a [char],
+}
+
+impl Chunk<'_> {
+    pub fn from_disk(file_offset: u64, data: &[char]) -> Chunk {
+        Chunk {
+            file_offset,
+            is_modified: false,
+            data,
+        }
+    }
+
+    pub fn lines_iter(&self) -> ChunkLinesIter {
+        ChunkLinesIter {
+            chunk: self,
+            forward: self.data.split(Box::new(|c: &char| *c == '\n')),
+            back: self.data.rsplit(Box::new(|c: &char| *c == '\n')),
+        }
+    }
+}
+
+pub struct ChunkLinesIter<'a> {
+    chunk: &'a Chunk<'a>,
+    forward: Split<'a, char, Box<dyn FnMut(&char) -> bool>>,
+    back: RSplit<'a, char, Box<dyn FnMut(&char) -> bool>>,
+}
+
+impl<'a> Iterator for ChunkLinesIter<'a> {
+    type Item = LoadedLine;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let line = self.forward.next();
+        return line.map(LoadedLine::new);
+    }
+}
+
+impl<'a> DoubleEndedIterator for ChunkLinesIter<'a> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let line = self.back.next();
+        return line.map(LoadedLine::new);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use chunks::Chunk;
+
+    #[test]
+    fn test_chunk_lines_iter() {
+        let data: Vec<char> = "line1\nline2\nline3\n".chars().collect();
+        let chunk = Chunk::from_disk(0, &data);
+        let mut iter = chunk.lines_iter();
+
+        assert_eq!(
+            iter.next().unwrap().chars_iter().collect::<String>(),
+            "line1"
+        );
+        assert_eq!(
+            iter.next().unwrap().chars_iter().collect::<String>(),
+            "line2"
+        );
+        assert_eq!(
+            iter.next().unwrap().chars_iter().collect::<String>(),
+            "line3"
+        );
+
+        assert_eq!(iter.next().unwrap().chars_iter().collect::<String>(), "");
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_chunk_lines_iter_empty() {
+        let data: Vec<char> = "".chars().collect();
+        let chunk = Chunk::from_disk(0, &data);
+        let mut iter = chunk.lines_iter();
+
+        assert_eq!(iter.next().unwrap().chars_iter().collect::<String>(), "");
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_chunk_lines_iter_no_newline() {
+        let data: Vec<char> = "line1".chars().collect();
+        let chunk = Chunk::from_disk(0, &data);
+        let mut iter = chunk.lines_iter();
+
+        assert_eq!(
+            iter.next().unwrap().chars_iter().collect::<String>(),
+            "line1"
+        );
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_chunk_lines_iter_double_ended() {
+        let data: Vec<char> = "line1\nline2\nline3\n".chars().collect();
+        let chunk = Chunk::from_disk(0, &data);
+        let mut iter = chunk.lines_iter();
+
+        assert_eq!(
+            iter.next_back().unwrap().chars_iter().collect::<String>(),
+            ""
+        );
+        assert_eq!(
+            iter.next_back().unwrap().chars_iter().collect::<String>(),
+            "line3"
+        );
+        assert_eq!(
+            iter.next_back().unwrap().chars_iter().collect::<String>(),
+            "line2"
+        );
+        assert_eq!(
+            iter.next_back().unwrap().chars_iter().collect::<String>(),
+            "line1"
+        );
+        assert!(iter.next_back().is_none());
+    }
+}

src/lines.rs

@@ -0,0 +1,44 @@
+pub struct LoadedLine {
+    chars: Vec<char>,
+}
+
+impl LoadedLine {
+    pub fn empty() -> LoadedLine {
+        LoadedLine { chars: vec![] }
+    }
+    pub fn new(chars: &[char]) -> LoadedLine {
+        LoadedLine {
+            chars: Vec::from(chars),
+        }
+    }
+    pub fn from_vec(chars: Vec<char>) -> LoadedLine {
+        LoadedLine { chars: chars }
+    }
+    pub fn len(&self) -> usize {
+        self.chars.len()
+    }
+    pub fn push(&mut self, c: char) {
+        self.chars.push(c);
+    }
+    pub fn insert(&mut self, index: usize, c: char) {
+        self.chars.insert(index, c);
+    }
+    pub fn remove(&mut self, index: usize) {
+        self.chars.remove(index);
+    }
+    pub fn extend(&mut self, line: LoadedLine) {
+        self.chars.extend(line.chars);
+    }
+    pub fn char_get_mut(&mut self, index: usize) -> Option<&mut char> {
+        self.chars.get_mut(index)
+    }
+    pub fn char_get(&self, index: usize) -> Option<&char> {
+        self.chars.get(index)
+    }
+    pub fn split_off(&mut self, x: usize) -> Vec<char> {
+        self.chars.split_off(x)
+    }
+    pub fn chars_iter(&self) -> std::slice::Iter<'_, char> {
+        self.chars.iter()
+    }
+}

src/main.rs

@@ -6,6 +6,7 @@ use std::{
     iter::FromIterator,
 };
 
+use crate::lines::LoadedLine;
 use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyModifiers};
 use ratatui::{
     layout::{Position, Rect, Size},
@@ -14,184 +15,8 @@ use ratatui::{
     DefaultTerminal, Frame,
 };
 
-mod lines {
-    pub struct LoadedLine {
-        chars: Vec<char>,
-    }
-
-    impl LoadedLine {
-        pub fn empty() -> LoadedLine {
-            LoadedLine { chars: vec![] }
-        }
-        pub fn new(chars: &[char]) -> LoadedLine {
-            LoadedLine {
-                chars: Vec::from(chars),
-            }
-        }
-        pub fn from_vec(chars: Vec<char>) -> LoadedLine {
-            LoadedLine { chars: chars }
-        }
-        pub fn len(&self) -> usize {
-            self.chars.len()
-        }
-        pub fn push(&mut self, c: char) {
-            self.chars.push(c);
-        }
-        pub fn insert(&mut self, index: usize, c: char) {
-            self.chars.insert(index, c);
-        }
-        pub fn remove(&mut self, index: usize) {
-            self.chars.remove(index);
-        }
-        pub fn extend(&mut self, line: LoadedLine) {
-            self.chars.extend(line.chars);
-        }
-        pub fn char_get_mut(&mut self, index: usize) -> Option<&mut char> {
-            self.chars.get_mut(index)
-        }
-        pub fn char_get(&self, index: usize) -> Option<&char> {
-            self.chars.get(index)
-        }
-        pub fn split_off(&mut self, x: usize) -> Vec<char> {
-            self.chars.split_off(x)
-        }
-        pub fn chars_iter(&self) -> std::slice::Iter<'_, char> {
-            self.chars.iter()
-        }
-    }
-}
-
-mod chunks {
-
-    use std::slice::{RSplit, Split};
-
-    use crate::lines::LoadedLine;
-
-    pub struct Chunk<'a> {
-        file_offset: u64,
-        is_modified: bool,
-        data: &'a [char],
-    }
-
-    impl Chunk<'_> {
-        pub fn from_disk(file_offset: u64, data: &[char]) -> Chunk {
-            Chunk {
-                file_offset,
-                is_modified: false,
-                data,
-            }
-        }
-
-        pub fn lines_iter(&self) -> ChunkLinesIter {
-            ChunkLinesIter {
-                chunk: self,
-                forward: self.data.split(Box::new(|c: &char| *c == '\n')),
-                back: self.data.rsplit(Box::new(|c: &char| *c == '\n')),
-            }
-        }
-    }
-
-    pub struct ChunkLinesIter<'a> {
-        chunk: &'a Chunk<'a>,
-        forward: Split<'a, char, Box<dyn FnMut(&char) -> bool>>,
-        back: RSplit<'a, char, Box<dyn FnMut(&char) -> bool>>,
-    }
-
-    impl<'a> Iterator for ChunkLinesIter<'a> {
-        type Item = LoadedLine;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            let line = self.forward.next();
-            return line.map(LoadedLine::new);
-        }
-    }
-
-    impl<'a> DoubleEndedIterator for ChunkLinesIter<'a> {
-        fn next_back(&mut self) -> Option<Self::Item> {
-            let line = self.back.next();
-            return line.map(LoadedLine::new);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use chunks::Chunk;
-
-    #[test]
-    fn test_chunk_lines_iter() {
-        let data: Vec<char> = "line1\nline2\nline3\n".chars().collect();
-        let chunk = Chunk::from_disk(0, &data);
-        let mut iter = chunk.lines_iter();
-
-        assert_eq!(
-            iter.next().unwrap().chars_iter().collect::<String>(),
-            "line1"
-        );
-        assert_eq!(
-            iter.next().unwrap().chars_iter().collect::<String>(),
-            "line2"
-        );
-        assert_eq!(
-            iter.next().unwrap().chars_iter().collect::<String>(),
-            "line3"
-        );
-
-        assert_eq!(iter.next().unwrap().chars_iter().collect::<String>(), "");
-        assert!(iter.next().is_none());
-    }
-
-    #[test]
-    fn test_chunk_lines_iter_empty() {
-        let data: Vec<char> = "".chars().collect();
-        let chunk = Chunk::from_disk(0, &data);
-        let mut iter = chunk.lines_iter();
-
-        assert_eq!(iter.next().unwrap().chars_iter().collect::<String>(), "");
-        assert!(iter.next().is_none());
-    }
-
-    #[test]
-    fn test_chunk_lines_iter_no_newline() {
-        let data: Vec<char> = "line1".chars().collect();
-        let chunk = Chunk::from_disk(0, &data);
-        let mut iter = chunk.lines_iter();
-
-        assert_eq!(
-            iter.next().unwrap().chars_iter().collect::<String>(),
-            "line1"
-        );
-        assert!(iter.next().is_none());
-    }
-
-    #[test]
-    fn test_chunk_lines_iter_double_ended() {
-        let data: Vec<char> = "line1\nline2\nline3\n".chars().collect();
-        let chunk = Chunk::from_disk(0, &data);
-        let mut iter = chunk.lines_iter();
-
-        assert_eq!(
-            iter.next_back().unwrap().chars_iter().collect::<String>(),
-            ""
-        );
-        assert_eq!(
-            iter.next_back().unwrap().chars_iter().collect::<String>(),
-            "line3"
-        );
-        assert_eq!(
-            iter.next_back().unwrap().chars_iter().collect::<String>(),
-            "line2"
-        );
-        assert_eq!(
-            iter.next_back().unwrap().chars_iter().collect::<String>(),
-            "line1"
-        );
-        assert!(iter.next_back().is_none());
-    }
-}
-
-use lines::LoadedLine;
+pub mod chunks;
+pub mod lines;
 
 // TODO
 // How to represent edited content?