Lint and format code

barkit-extract/src/fastq.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::result_large_err)]
+
 use std::fs::{File, OpenOptions};
 use std::io::{self, BufRead, BufReader, BufWriter, Read, Write};
 use std::path::Path;

barkit-extract/src/lib.rs

@@ -1,6 +1,6 @@
-pub mod parse;
 pub mod error;
 pub mod fastq;
 pub mod logger;
+pub mod parse;
 pub mod pattern;
 pub mod run;

barkit-extract/src/logger.rs

@@ -4,7 +4,8 @@ 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})";
+static PROGRESS_BAR_TEMPLATE: &str =
+    "{spinner:.green} [{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {per_sec} ({eta})";
 
 pub struct Logger {
     /// Index of the current step
@@ -18,7 +19,7 @@ pub struct Logger {
 
     /// Start time of execution
     execution_start: Instant,
-    
+
     /// Progress bar
     progress_bar: Option<ProgressBar>,
 }
@@ -30,7 +31,7 @@ impl Logger {
     ///
     /// ```
     /// use barkit_extract::logger::Logger;
-    /// 
+    ///
     /// let logger = Logger::new(3, false);
     /// ```
     pub fn new(total: usize, quiet: bool) -> Self {
@@ -39,7 +40,7 @@ impl Logger {
             total,
             quiet,
             execution_start: Instant::now(),
-            progress_bar: None
+            progress_bar: None,
         }
     }
 
@@ -49,12 +50,12 @@ impl Logger {
     ///
     /// ```
     /// 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"
     ///
@@ -65,7 +66,13 @@ impl Logger {
         if self.current < self.total {
             self.current += 1;
             if !self.quiet {
-                println!("{} {}", style(format!("[{}/{}]", self.current, self.total)).bold().dim(), text);
+                println!(
+                    "{} {}",
+                    style(format!("[{}/{}]", self.current, self.total))
+                        .bold()
+                        .dim(),
+                    text
+                );
             }
         } else {
             // Optionally handle the case where `current` exceeds `total`
@@ -104,4 +111,4 @@ impl Logger {
             )
         }
     }
-}
+}

barkit-extract/src/parse.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::result_large_err)]
+
 use crate::pattern::BarcodeRegex;
 use regex::bytes::Captures;
 
@@ -30,8 +32,13 @@ const TRANSLATION_TABLE: [u8; 256] = {
 };
 
 pub struct BarcodeParser {
+    /// Prepared regex pattern to parse barcodes
     barcode_regex: BarcodeRegex,
+
+    /// If `true`, all captured patterns will not be trimmed
     skip_trimming: bool,
+
+    /// If `true`, the barcode pattern will also be matched in the reverse complement sequence.
     rc_barcodes: bool,
 }
 

barkit-extract/src/pattern.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::result_large_err)]
+
 use std::{fmt, mem::size_of};
 
 use fancy_regex::Regex as FancyRegex;
@@ -11,15 +13,15 @@ const ADAPTER_PATTERN_REGEX: &str = r"(?<!\[)\b[atgcryswkmbdhvn]+\b(?!\])";
 pub struct BarcodePattern {
     adapter_pattern: FancyRegex,
     barcode_pattern: String,
-    max_error: usize
+    max_error: usize,
 }
 
 impl BarcodePattern {
     pub fn new(pattern: &str, max_error: &usize) -> Result<Self, Error> {
         Ok(Self {
             adapter_pattern: FancyRegex::new(ADAPTER_PATTERN_REGEX)?,
             barcode_pattern: pattern.to_owned(),
-            max_error: *max_error
+            max_error: *max_error,
         })
     }
 
@@ -29,36 +31,36 @@ impl BarcodePattern {
     ///
     /// ```
     /// use barkit_extract::pattern::BarcodePattern;
-    /// 
+    ///
     /// let barcode_pattern = BarcodePattern::new("^atgc(?<UMI>[ATGCN]{12})", &1).unwrap();
-    /// 
+    ///
     /// let sequences_with_errors = barcode_pattern.get_sequence_with_errors("ATGC");
     /// assert_eq!(vec!["ATG.", "AT.C", "A.GC", ".TGC"], sequences_with_errors);
     /// ```
     pub fn get_sequence_with_errors(&self, sequence: &str) -> Vec<String> {
         if self.max_error == 0 {
             return vec![sequence.to_string().to_ascii_uppercase()];
         }
-    
+
         if sequence.is_empty() {
             return Vec::new();
         }
-    
+
         if self.max_error >= sequence.len() {
             return vec![FUZZY_CHARACTER.repeat(sequence.len())];
         }
-    
+
         let num_chars = sequence.chars().count();
         assert!(num_chars <= usize::BITS as usize * 8, "too many characters");
-    
+
         let max_permutation_mask = usize::MAX
             .checked_shr(size_of::<usize>() as u32 * 8 - num_chars as u32)
             .unwrap();
-    
+
         let mut cases = Vec::new();
-    
+
         let upper: Vec<char> = sequence.chars().map(|c| c.to_ascii_uppercase()).collect();
-    
+
         for permutation_mask in 0..=max_permutation_mask {
             if permutation_mask.count_ones() as usize != num_chars - self.max_error {
                 continue;
@@ -73,7 +75,6 @@ impl BarcodePattern {
             }
             cases.push(s);
         }
-
         cases
     }
 
@@ -83,9 +84,9 @@ impl BarcodePattern {
     ///
     /// ```
     /// use barkit_extract::pattern::BarcodePattern;
-    /// 
+    ///
     /// let barcode_pattern = BarcodePattern::new("^atgc(?<UMI>[ATGCN]{12})", &1).unwrap();
-    /// 
+    ///
     /// let pattern_with_pcr_errors = barcode_pattern.get_pattern_with_errors().unwrap();
     /// assert_eq!("^(ATG.|AT.C|A.GC|.TGC)(?<UMI>[ATGCN]{12})", pattern_with_pcr_errors);
     /// ```
@@ -108,8 +109,7 @@ impl BarcodePattern {
     }
 }
 
-
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum BarcodeType {
     /// Moleculare barcode (UMI)
     Umi,
@@ -125,11 +125,11 @@ impl BarcodeType {
     /// Parses type of barcode
     ///
     /// # Example
-    /// 
+    ///
     /// ```
     /// use barkit_extract::pattern::BarcodeType;
     /// use barkit_extract::error::Error::UnexpectedCaptureGroupName;
-    /// 
+    ///
     /// assert_eq!(BarcodeType::Umi, BarcodeType::parse_type("UMI").unwrap());
     /// assert_eq!(BarcodeType::Sample, BarcodeType::parse_type("SB").unwrap());
     /// assert_eq!(BarcodeType::Cell, BarcodeType::parse_type("CB").unwrap());
@@ -146,15 +146,18 @@ impl BarcodeType {
 
 impl fmt::Display for BarcodeType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", match self {
-            BarcodeType::Umi => "UMI",
-            BarcodeType::Sample => "SB",
-            BarcodeType::Cell => "CB",
-        })
+        write!(
+            f,
+            "{}",
+            match self {
+                BarcodeType::Umi => "UMI",
+                BarcodeType::Sample => "SB",
+                BarcodeType::Cell => "CB",
+            }
+        )
     }
 }
 
-
 #[derive(Clone)]
 pub struct BarcodeRegex {
     /// Regex pattern to parse barcode(s) from read sequence
@@ -166,11 +169,11 @@ pub struct BarcodeRegex {
 
 impl BarcodeRegex {
     /// Creates `BarcodeRegex` instance
-    /// 
+    ///
     /// Example
     /// ```
     /// use barkit_extract::pattern::BarcodeRegex;
-    /// 
+    ///
     /// let barcode_regex = BarcodeRegex::new("^atgc(?<UMI>[ATGCN]{6})", 1);
     /// ```
     pub fn new(pattern: &str, max_error: usize) -> Result<Self, Error> {
@@ -184,7 +187,7 @@ impl BarcodeRegex {
         })
     }
 
-    /// Parses capture groups from regex pattern 
+    /// Parses capture groups from regex pattern
     fn parse_capture_groups(regex: &Regex) -> Result<Vec<BarcodeType>, Error> {
         let mut capture_groups = Vec::<BarcodeType>::new();
         for capture_group in regex
@@ -202,13 +205,13 @@ impl BarcodeRegex {
     }
 
     /// Captures barcodes in read sequence
-    /// 
+    ///
     /// Example
     /// ```
     /// use barkit_extract::pattern::BarcodeRegex;
-    /// 
+    ///
     /// let barcode_regex = BarcodeRegex::new("^atgc(?<UMI>[ATGCN]{6})", 1).unwrap();
-    /// 
+    ///
     /// assert_eq!(
     ///     b"NNNNNN",
     ///     barcode_regex
@@ -231,7 +234,6 @@ impl BarcodeRegex {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
@@ -251,10 +253,7 @@ mod tests {
         #[case] max_error: usize,
     ) {
         let barcode_pattern = pattern::BarcodePattern::new("", &max_error).unwrap();
-        assert_eq!(
-            expected,
-            barcode_pattern.get_sequence_with_errors(text)
-        );
+        assert_eq!(expected, barcode_pattern.get_sequence_with_errors(text));
     }
 
     #[rstest]
@@ -272,4 +271,4 @@ mod tests {
         let barcode_pattern = pattern::BarcodePattern::new(pattern, &max_error).unwrap();
         assert_eq!(expected, barcode_pattern.get_pattern_with_errors().unwrap())
     }
-}
+}

barkit-extract/src/run.rs

@@ -1,9 +1,9 @@
 use rayon::prelude::*;
 
-use crate::parse;
-use crate::pattern::BarcodeRegex;
 use crate::fastq::{self, CompressionType};
 use crate::logger;
+use crate::parse;
+use crate::pattern::BarcodeRegex;
 
 #[allow(clippy::too_many_arguments)]
 pub fn run(
@@ -74,7 +74,7 @@ fn process_single_end_fastq(
 ) {
     let mut logger = logger::Logger::new(3, quiet);
     logger.message("Estimating reads count...");
-    
+
     let lines_number = fastq::get_reads_count(&fq, threads, max_memory);
     logger.set_progress_bar(lines_number);
 
@@ -140,7 +140,7 @@ fn process_pair_end_fastq(
 ) {
     let mut logger = logger::Logger::new(3, quiet);
     logger.message("Estimating reads count...");
-    
+
     let lines_number = fastq::get_reads_count(&fq1, threads, max_memory);
     logger.set_progress_bar(lines_number);
 

src/lib.rs

@@ -117,4 +117,4 @@ pub struct AdditionalParamsGroup {
     /// Max error (mismatch) between provided pattern and read sequence
     #[arg(short = 'e', long, default_value = "1")]
     pub max_error: usize,
-}
+}

src/main.rs

@@ -14,10 +14,12 @@ fn main() {
             quiet,
             force,
         } => {
-            let output_compression =
-                barkit_extract::fastq::CompressionType::select(
-                    &compression.gz, &compression.bgz, &compression.mgz, &compression.lz4,
-                );
+            let output_compression = barkit_extract::fastq::CompressionType::select(
+                &compression.gz,
+                &compression.bgz,
+                &compression.mgz,
+                &compression.lz4,
+            );
             barkit_extract::run::run(
                 input_fastqs.fq1.to_string(),
                 input_fastqs.fq2.clone(),