style: reformat code and add doc tests

barkit-extract/src/error.rs

@@ -16,6 +16,8 @@
     FileRead(#[from] std::io::Error),
     #[error("No match")]
     PatternNotMatched,
+    #[error("Fancy regex error: {0}")]
+    FancyRegex(#[from] fancy_regex::Error),
 }
 
 impl Clone for Error {
@@ -32,6 +34,7 @@
             }
             Error::FileRead(err) => Error::FileRead(err.kind().into()),
             Error::PatternNotMatched => Error::PatternNotMatched,
+            Error::FancyRegex(err) => Error::FancyRegex(err.clone()),
         }
     }
 }

barkit-extract/src/fastq.rs

@@ -44,7 +44,7 @@
         }
     }
 
-    pub fn get_output_compression_type(gz: &bool, bgz: &bool, mgz: &bool, lz4: &bool) -> Self {
+    pub fn select(gz: &bool, bgz: &bool, mgz: &bool, lz4: &bool) -> Self {
         match (gz, bgz, mgz, lz4) {
             (true, false, false, false) => Self::Gzip,
             (false, true, false, false) => Self::Mgzip,
@@ -54,7 +54,7 @@
         }
     }
 
-    fn get_input_compression_type(path: &Path) -> CompressionType {
+    fn detect(path: &Path) -> CompressionType {
         let mut buffer = [0u8; 16];
 
         File::open(path)
@@ -95,7 +95,7 @@
 
     let buffer_size_in_bytes = get_reader_buffer_size(&file, buffer_size_in_megabytes)?;
 
-    let decoder: Box<dyn Read> = match CompressionType::get_input_compression_type(path) {
+    let decoder: Box<dyn Read> = match CompressionType::detect(path) {
         CompressionType::Gzip | CompressionType::Mgzip => Box::new(MultiGzDecoder::new(file)),
         CompressionType::Lz4 => Box::new(Decoder::new(file)?),
         CompressionType::Bgzf => Box::new(

barkit-extract/src/lib.rs

@@ -1,4 +1,4 @@
-pub mod barcode;
+pub mod parse;
 pub mod error;
 pub mod fastq;
 pub mod logger;

barkit-extract/src/logger.rs

@@ -1,25 +1,107 @@
-use console::Emoji;
-use indicatif::{ProgressBar, ProgressStyle};
+use std::time::Instant;
 
-use crate::error::Error;
-use crate::fastq;
+use console::{style, Emoji};
+use indicatif::{HumanDuration, ProgressBar, ProgressStyle};
 
 pub static SPARKLE: Emoji<'_, '_> = Emoji("✨ ", ":-)");
+static PROGRESS_BAR_TEMPLATE: &str = "{spinner:.green} [{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {per_sec} ({eta})";
 
-pub fn create_progress_bar(
-    fastq_file: &str,
-    threads: usize,
-    max_memory: Option<usize>,
-) -> Result<ProgressBar, Error> {
-    let progress_bar_style = ProgressStyle::with_template(
-        "{spinner:.green} [{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {per_sec} ({eta})",
-    ).expect("Failed to parse a progress bar template")
-    .progress_chars("##-");
+pub struct Logger {
+    /// Index of the current step
+    current: usize,
 
-    let read_num = fastq::get_reads_count(fastq_file, threads, max_memory) as u64;
+    /// Total number of steps
+    total: usize,
 
-    let progress_bar = ProgressBar::new(read_num as u64);
-    progress_bar.set_style(progress_bar_style.clone());
+    /// If true, logs will not be displayed
+    quiet: bool,
 
-    Ok(progress_bar)
+    /// Start time of execution
+    execution_start: Instant,
+
+    /// Progress bar
+    progress_bar: Option<ProgressBar>,
 }
+
+impl Logger {
+    /// Creates `Logger` instance with default values.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use barkit_extract::logger::Logger;
+    /// 
+    /// let logger = Logger::new(3, false);
+    /// ```
+    pub fn new(total: usize, quiet: bool) -> Self {
+        Self {
+            current: 0,
+            total,
+            quiet,
+            execution_start: Instant::now(),
+            progress_bar: None
+        }
+    }
+
+    /// Prints logging message for the current step.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use barkit_extract::logger::Logger;
+    /// 
+    /// let mut logger = Logger::new(2, false);
+    /// 
+    /// logger.message("first logging message");
+    /// // Output: "[1/2] first logging message"
+    /// 
+    /// logger.message("second logging message");
+    /// // Output: "[2/2] second logging message"
+    ///
+    /// logger.message("third logging message");
+    /// // Output: "Warning: Current step exceeds total steps."
+    /// ```
+    pub fn message(&mut self, text: &str) {
+        if self.current < self.total {
+            self.current += 1;
+            if !self.quiet {
+                println!("{} {}", style(format!("[{}/{}]", self.current, self.total)).bold().dim(), text);
+            }
+        } else {
+            // Optionally handle the case where `current` exceeds `total`
+            eprintln!("Warning: Current step exceeds total steps.");
+        }
+    }
+
+    /// Increments progress in the progress bar
+    pub fn increment_progress(&self, done_lines: usize) {
+        if let Some(ref pb) = self.progress_bar {
+            pb.inc(done_lines as u64)
+        }
+    }
+
+    /// Sets progress bar instance with specified length
+    pub fn set_progress_bar(&mut self, size: usize) {
+        if !self.quiet {
+            let progress_bar_style = ProgressStyle::with_template(PROGRESS_BAR_TEMPLATE)
+                .expect("Failed to parse a progress bar template")
+                .progress_chars("##-");
+
+            let progress_bar = ProgressBar::new(size as u64);
+            progress_bar.set_style(progress_bar_style);
+
+            self.progress_bar = Some(progress_bar);
+        }
+    }
+
+    /// Prints a final message when all steps are completed
+    pub fn final_message(&self) {
+        if self.progress_bar.is_some() {
+            println!(
+                "{} Done in {}",
+                SPARKLE,
+                HumanDuration(self.execution_start.elapsed())
+            )
+        }
+    }
+}

barkit-extract/src/barcode.rs → barkit-extract/src/parse.rs

@@ -1,8 +1,8 @@
-use crate::pattern;
-use regex::bytes::{Captures, Regex};
+use crate::pattern::BarcodeRegex;
+use regex::bytes::Captures;
 
 use seq_io::fastq::{OwnedRecord, Record, RefRecord};
-use std::{fmt, str};
+use std::str;
 
 use crate::error::Error;
 
@@ -29,76 +29,6 @@
     table
 };
 
-#[derive(Clone)]
-pub enum BarcodeType {
-    Umi,
-    Sample,
-    Cell,
-}
-
-impl fmt::Display for BarcodeType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let barcode_str = match self {
-            BarcodeType::Umi => "UMI",
-            BarcodeType::Sample => "SB",
-            BarcodeType::Cell => "CB",
-        };
-        write!(f, "{}", barcode_str)
-    }
-}
-
-impl BarcodeType {
-    fn get_barcode_type(name: &str) -> Result<Self, Error> {
-        match name {
-            "UMI" => Ok(BarcodeType::Umi),
-            "SB" => Ok(BarcodeType::Sample),
-            "CB" => Ok(BarcodeType::Cell),
-            _ => Err(Error::UnexpectedCaptureGroupName(name.to_owned())),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct BarcodeRegex {
-    regex: Regex,
-    barcode_types: Vec<BarcodeType>,
-}
-
-impl BarcodeRegex {
-    pub fn new(pattern: &str, max_error: usize) -> Result<Self, Error> {
-        let fuzzy_pattern = pattern::get_with_errors(pattern, &max_error);
-        let regex = Regex::new(&fuzzy_pattern)?;
-        let barcode_types = Self::parse_capture_groups(&regex)?;
-        Ok(Self {
-            regex,
-            barcode_types,
-        })
-    }
-
-    pub fn get_captures<'a>(&'a self, read_seq: &'a [u8]) -> Result<Captures, Error> {
-        match self.regex.captures(read_seq) {
-            Some(capture) => Ok(capture),
-            None => Err(Error::PatternNotMatched),
-        }
-    }
-
-    fn parse_capture_groups(regex: &Regex) -> Result<Vec<BarcodeType>, Error> {
-        let mut capture_groups = Vec::<BarcodeType>::new();
-        for capture_group in regex
-            .capture_names()
-            .collect::<Vec<_>>()
-            .into_iter()
-            .flatten()
-        {
-            capture_groups.push(BarcodeType::get_barcode_type(capture_group)?)
-        }
-        if capture_groups.is_empty() {
-            return Err(Error::BarcodeCaptureGroupNotFound(regex.to_string()));
-        }
-        Ok(capture_groups)
-    }
-}
-
 pub struct BarcodeParser {
     barcode_regex: BarcodeRegex,
     skip_trimming: bool,
@@ -161,7 +91,7 @@
         let seq = record.seq().to_vec();
         let qual = record.qual().to_vec();
 
-        for barcode in &self.barcode_regex.barcode_types {
+        for barcode in &self.barcode_regex.get_barcode_types() {
             let barcode_name = barcode.to_string();
             let (barcode_start, barcode_end) =
                 get_barcode_match_positions(&barcode_name, captures)?;
@@ -245,7 +175,7 @@
 mod tests {
     use rstest::rstest;
 
-    use crate::barcode::get_reverse_complement;
+    use crate::parse::get_reverse_complement;
 
     #[rstest]
     #[case(b"", b"")]