Add logics for compressing fasta file

Author: marshallku

src/lib.rs

@@ -105,3 +105,86 @@ pub fn decompress_sequence(compressed: &[u8], sequence_length: usize) -> io::Res
 
     Ok(sequence)
 }
+
+/// A struct that represents a FASTA file compressor.
+pub struct FASTACompressor;
+
+/// Compressor methods for the FASTA file format.
+impl FASTACompressor {
+    pub fn new() -> Self {
+        FASTACompressor
+    }
+
+    /// Compresses a FASTA file content into a vector of bytes.
+    pub fn compress(&self, content: &str) -> Vec<u8> {
+        let mut lines = content.lines();
+        let header = lines.next().unwrap_or("").to_string();
+        let sequence: String = lines.map(|line| line.trim()).collect();
+
+        let sequence_length = sequence.len() as u32;
+        let compressed_data = compress_sequence(&sequence);
+
+        let mut output = Vec::new();
+
+        // Write header length (4 bytes)
+        output.extend_from_slice(&(header.len() as u32).to_le_bytes());
+
+        // Write header
+        output.extend_from_slice(header.as_bytes());
+
+        // Write sequence length (4 bytes)
+        output.extend_from_slice(&sequence_length.to_le_bytes());
+
+        // Write compressed data length (4 bytes)
+        output.extend_from_slice(&(compressed_data.len() as u32).to_le_bytes());
+
+        // Write compressed data
+        output.extend_from_slice(&compressed_data);
+
+        output
+    }
+
+    /// Decompresses a vector of bytes into a FASTA file content.
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
+    pub fn decompress(&self, data: &[u8]) -> Result<String, String> {
+        if data.len() < 12 {
+            return Err("File is too short".to_string());
+        }
+
+        let header_len = u32::from_le_bytes(data[0..4].try_into().unwrap()) as usize;
+
+        if data.len() < 12 + header_len {
+            return Err("File is too short for header".to_string());
+        }
+
+        let header =
+            String::from_utf8(data[4..4 + header_len].to_vec()).map_err(|e| e.to_string())?;
+
+        let sequence_length =
+            u32::from_le_bytes(data[4 + header_len..8 + header_len].try_into().unwrap()) as usize;
+
+        let compressed_len =
+            u32::from_le_bytes(data[8 + header_len..12 + header_len].try_into().unwrap()) as usize;
+
+        if data.len() < 12 + header_len + compressed_len {
+            return Err("File is too short for compressed data".to_string());
+        }
+
+        let compressed_data = &data[12 + header_len..12 + header_len + compressed_len];
+        let decompressed =
+            decompress_sequence(compressed_data, sequence_length).unwrap_or_default();
+
+        let mut result = String::with_capacity(
+            header.len() + decompressed.len() + (decompressed.len() / 60) * 2,
+        );
+        result.push_str(&header);
+        result.push('\n');
+
+        for chunk in decompressed.as_bytes().chunks(60) {
+            result.extend(chunk.iter().map(|&b| b as char));
+            result.push('\n');
+        }
+
+        Ok(result)
+    }
+}

tests/compression.rs

@@ -2,6 +2,10 @@ use base_sequence_compression::{compress_sequence, decompress_sequence};
 
 #[cfg(test)]
 mod tests {
+    use std::path::Path;
+
+    use base_sequence_compression::FASTACompressor;
+
     use super::*;
 
     #[test]
@@ -105,4 +109,28 @@ mod tests {
 
         assert_eq!("ACGT", decompressed);
     }
+
+    #[test]
+    fn test_fasta_file() {
+        let compressor = FASTACompressor::new();
+        let input_path = Path::new("tests/input/test.fasta");
+
+        let content = std::fs::read_to_string(input_path).unwrap();
+        let compressed = compressor.compress(&content);
+        let decompressed = compressor.decompress(&compressed).unwrap();
+
+        assert_eq!(content, decompressed);
+    }
+
+    #[test]
+    fn test_large_fasta_file() {
+        let compressor = FASTACompressor::new();
+        let input_path = Path::new("tests/input/large.fasta");
+
+        let content = std::fs::read_to_string(input_path).unwrap();
+        let compressed = compressor.compress(&content);
+        let decompressed = compressor.decompress(&compressed).unwrap();
+
+        assert_eq!(content, decompressed);
+    }
 }