fix issue that made the buffer contain 00 bytes in files smaller than

BUFFER_SIZE, even though the file didn't have any 00 bytes.
some code refactoring

Author: LaBatata101

src/utils/search.rs

@@ -2,40 +2,94 @@ use std::fs::File;
 use std::io::{BufReader, Read};
 use std::ops::Range;
 
-#[derive(Debug)]
-pub struct Match {
-    index: Range<usize>,
+#[derive(Debug, Clone)]
+pub struct Matches {
+    indexes: Vec<Range<usize>>,
     data: Vec<u8>,
-    offset: usize,
+    offset: Vec<usize>,
+    pattern_len: usize,
+    context_bytes_size: usize,
+    curr_context_bytes_indexes: Option<Range<usize>>,
 }
 
-impl Match {
-    pub fn new(offset: usize, index: Range<usize>, data: Vec<u8>) -> Self {
+impl Matches {
+    pub fn new(pattern_len: usize, context_bytes_size: usize) -> Self {
         Self {
-            index,
-            data,
-            offset,
+            pattern_len,
+            context_bytes_size,
+            indexes: Vec::new(),
+            data: Vec::new(),
+            offset: Vec::new(),
+            curr_context_bytes_indexes: None,
         }
     }
 
-    pub fn offset(&self) -> usize {
-        self.offset
+    pub fn offset(&self) -> &[usize] {
+        &self.offset
     }
 
     /// Get a reference to the match's index.
-    pub fn index(&self) -> Range<usize> {
-        self.index.clone()
+    pub fn indexes(&self) -> &[Range<usize>] {
+        &self.indexes
     }
 
     /// Get a reference to the match's data.
     pub fn data(&self) -> &[u8] {
         &self.data
     }
+
+    fn populate_matches(&mut self, index: usize, pos_in_file: usize, buffer: &[u8]) {
+        // index where we should start collecting bytes for context
+        let offset = index - (index % self.context_bytes_size);
+
+        // search_for_slice only return the index where the match start so we need to
+        // create a range with all indexes from the match
+        let match_indexes = index..index + self.pattern_len;
+
+        // Creates the index range for the context bytes.
+        // context_bytes_size_indexes can contain all the indexes for the match or partially, depends on
+        // context_bytes_size and the pattern size
+        let mut context_bytes_indexes = if offset + self.context_bytes_size <= buffer.len() {
+            offset..offset + self.context_bytes_size
+        } else {
+            offset..buffer.len()
+        };
+
+        // In case context_bytes_size doesn't contain all of the match indexes we
+        // need to extend the end of the range
+        if context_bytes_indexes.end < match_indexes.end {
+            context_bytes_indexes.end += self.context_bytes_size;
+        }
+
+        let context_bytes_indexes = Some(context_bytes_indexes);
+        if context_bytes_indexes != self.curr_context_bytes_indexes { // Check if context_bytes_indexes was already added
+            self.curr_context_bytes_indexes = context_bytes_indexes.clone();
+
+            // The actual bytes for context + the matching bytes
+            // needed for printing the result
+            self.data.extend_from_slice(&buffer[context_bytes_indexes.unwrap()]);
+
+            // The index is relative to the position in the current buffer we are
+            // reading from the file, but we need to store the position relative to the
+            // whole file
+            self.offset.push(index + pos_in_file);
+        }
+
+        // Now we need to know the indexes of the match inside of context_bytes
+        let mut match_indexes = match_indexes.start % self.data.len()
+            ..match_indexes.end % self.data.len();
+
+        if match_indexes.end < match_indexes.start {
+            match_indexes.end = match_indexes.start + self.pattern_len;
+        }
+
+        self.indexes.push(match_indexes);
+    }
 }
 
 pub struct Searcher<'a> {
     pattern: &'a [u8],
-    result: Vec<Vec<Match>>,
+    matches: Matches,
     context_bytes_size: usize,
 }
 
@@ -45,72 +99,45 @@ impl<'a> Searcher<'a> {
     pub fn new(pattern: &'a [u8], context_bytes_size: usize) -> Self {
         Self {
             pattern,
-            result: Vec::new(),
+            matches: Matches::new(pattern.len(), context_bytes_size),
             context_bytes_size,
         }
     }
 
     pub fn search_in_file(&mut self, filepath: &str) -> std::io::Result<()> {
         let file = File::open(filepath)?;
+        let file_size = file.metadata().unwrap().len() as usize;
 
         let mut reader = BufReader::new(file);
-        let mut buffer = [0; Self::BUFFER_SIZE];
         let mut pos_in_file = 0;
 
-        loop {
-            let n = reader.read(&mut buffer).unwrap();
+        if file_size < self.context_bytes_size {
+            self.context_bytes_size = file_size;
+        }
 
-            if n == 0 {
-                break;
-            }
+        if file_size <= Self::BUFFER_SIZE {
+            let mut buffer = Vec::new();
+            reader.read_to_end(&mut buffer)?;
 
             let result = Self::search_slice(&buffer, self.pattern);
+            for index in result {
+                self.matches.populate_matches(index, 0, &buffer);
+            }
+        } else {
+            let mut buffer = [0; Self::BUFFER_SIZE];
+            loop {
+                let n = reader.read(&mut buffer).unwrap();
+
+                if n == 0 {
+                    break;
+                }
 
-            if !result.is_empty() {
-                // Convert the vector of indexes that match the pattern into Match objects
-                let result = result
-                    .iter()
-                    .map(|&index| {
-                        // index where we should start collecting bytes for context
-                        let offset = index - (index % self.context_bytes_size);
-
-                        // search_for_slice only return the index where the match start so we need to
-                        // create a range with all indexes from the match
-                        let match_indexes = index..index + self.pattern.len();
-
-                        // Creates the index range for the context bytes.
-                        // this can contain all the indexes for the match or partially, depends on
-                        // context_bytes_size and the pattern size
-                        let mut context_bytes_indexes = offset..offset + self.context_bytes_size;
-
-                        // In case context_bytes_size doesn't contain all of the match indexes we
-                        // need to extend the end of the range
-                        if context_bytes_indexes.end < match_indexes.end {
-                            context_bytes_indexes.end += self.context_bytes_size;
-                        }
-
-                        // The actual bytes for context + the matching bytes
-                        // only for printing the result
-                        let context_bytes = buffer[context_bytes_indexes].to_vec();
-
-                        // Now we need to know the indexes of the match inside of context_bytes
-                        let mut match_indexes = match_indexes.start % context_bytes.len()
-                            ..match_indexes.end % context_bytes.len();
-
-                        if match_indexes.end == 0 {
-                            match_indexes.end = self.context_bytes_size;
-                        }
-
-                        // The index is relative to the position in the current buffer we are
-                        // reading from the file, but we need to store the position relative to the
-                        // whole file
-                        Match::new(index + pos_in_file, match_indexes, context_bytes)
-                    })
-                    .collect();
-
-                self.result.push(result);
+                let result = Self::search_slice(&buffer, self.pattern);
+                for index in result {
+                    self.matches.populate_matches(index, pos_in_file, &buffer);
+                }
+                pos_in_file += Self::BUFFER_SIZE;
             }
-            pos_in_file += Self::BUFFER_SIZE;
         }
 
         Ok(())
@@ -161,8 +188,8 @@ impl<'a> Searcher<'a> {
     }
 
     /// Get a reference to the searcher's result.
-    pub fn result(&self) -> &[Vec<Match>] {
-        &self.result
+    pub fn result(&self) -> &Matches {
+        &self.matches
     }
 
     /// Return the context bytes size.