lints

Author: samcwiley

Cargo.toml

@@ -23,3 +23,6 @@ zoe = { version = "0.0.19", default-features = false, features = [
 
 [profile.release]
 strip = true
+
+[lints.clippy]
+pedantic = "warn"

src/main.rs

@@ -1,7 +1,16 @@
-#![allow(unreachable_patterns)]
+#![warn(clippy::pedantic)]
+#![allow(
+    unreachable_patterns,
+    clippy::missing_panics_doc,
+    clippy::missing_errors_doc
+)]
 use crate::processes::{
-    all_sample_hd::*, all_sample_nt_diffs::*, find_chemistry::*, plotter::*,
-    positions_of_interest::*, variants_of_interest::*,
+    all_sample_hd::{HammingArgs, all_sample_hd_process},
+    all_sample_nt_diffs::{NTDiffsArgs, all_sample_nt_diffs_process},
+    find_chemistry::{FindChemArgs, find_chemistry_process},
+    plotter::{PlotterArgs, plotter_process},
+    positions_of_interest::{PositionsArgs, positions_of_interest_process},
+    variants_of_interest::{VariantsArgs, variants_of_interest_process},
 };
 use clap::{Parser, Subcommand};
 use processes::prepare_mira_reports::{ReportsArgs, prepare_mira_reports_process};
@@ -39,20 +48,21 @@ fn main() {
 
     match args.command {
         Commands::VariantsOfInterest(cmd_args) => {
-            variants_of_interest_process(cmd_args).expect(&format!("{module}::VariantsOfInterest"))
+            variants_of_interest_process(cmd_args)
+                .unwrap_or_else(|_| panic!("{module}::VariantsOfInterest"));
         }
         Commands::PositionsOfInterest(cmd_args) => positions_of_interest_process(cmd_args)
-            .expect(&format!("{module}::PositionsOfInterest")),
+            .unwrap_or_else(|_| panic!("{module}::PositionsOfInterest")),
 
         Commands::FindChemistry(cmd_args) => {
-            find_chemistry_process(cmd_args).unwrap_or_die(&format!("{module}::FindChemistry"))
+            find_chemistry_process(&cmd_args).unwrap_or_die(&format!("{module}::FindChemistry"));
         }
         Commands::Hamming(cmd_args) => {
-            all_sample_hd_process(cmd_args).unwrap_or_die(&format!("{module}::Hamming"));
+            all_sample_hd_process(&cmd_args).unwrap_or_die(&format!("{module}::Hamming"));
         }
-        Commands::NTDiffs(cmd_args) => all_sample_nt_diffs_process(cmd_args),
+        Commands::NTDiffs(cmd_args) => all_sample_nt_diffs_process(&cmd_args),
         Commands::Plotter(cmd_args) => {
-            plotter_process(cmd_args).unwrap_or_else(|_| panic!("{module}::Plotter"))
+            plotter_process(cmd_args).unwrap_or_else(|_| panic!("{module}::Plotter"));
         }
         Commands::PrepareMiraReports(cmd_args) => prepare_mira_reports_process(cmd_args)
             .unwrap_or_else(|_| panic!("{module}::PrepareMiraReports")),

src/processes/all_sample_hd.rs

@@ -31,7 +31,7 @@ struct ValidSeq {
     sequence: Nucleotides,
 }
 
-pub fn all_sample_hd_process(args: HammingArgs) -> Result<(), std::io::Error> {
+pub fn all_sample_hd_process(args: &HammingArgs) -> Result<(), std::io::Error> {
     //let args = APDArgs::parse();
     let delim = args.output_delimiter.unwrap_or(',');
 

src/processes/all_sample_nt_diffs.rs

@@ -31,7 +31,7 @@ struct ValidSeq {
     sequence: Nucleotides,
 }
 
-pub fn all_sample_nt_diffs_process(args: NTDiffsArgs) {
+pub fn all_sample_nt_diffs_process(args: &NTDiffsArgs) {
     //let args = NTDiffsArgs::parse();
     let delim = args.output_delimiter.unwrap_or(',');
 
@@ -80,10 +80,10 @@ pub fn all_sample_nt_diffs_process(args: NTDiffsArgs) {
     )
     .unwrap();
 
-    all_sequences.iter().for_each(|f| {
+    for f in &all_sequences {
         let name_1 = &f.name;
         let seq1 = &f.sequence;
-        all_sequences.iter().for_each(|f| {
+        for f in &all_sequences {
             let name_2 = &f.name;
             let seq2 = &f.sequence;
             for (i, (nt1, nt2)) in seq1.iter().zip(seq2.iter()).enumerate() {
@@ -97,6 +97,6 @@ pub fn all_sample_nt_diffs_process(args: NTDiffsArgs) {
                     .unwrap();
                 }
             }
-        });
-    });
+        }
+    }
 }

src/processes/find_chemistry.rs

@@ -46,26 +46,13 @@ impl FindChemArgs {
     /// Flu experiment.
     fn validate(&self) -> Result<(), String> {
         match self.irma_config {
-            IRMAConfig::Sensitive
+            IRMAConfig::Sensitive | IRMAConfig::Secondary | IRMAConfig::UTR
                 if self.experiment == Experiment::FluIllumina
                     || self.experiment == Experiment::FluONT =>
             {
                 Ok(())
             }
-            IRMAConfig::Secondary
-                if self.experiment == Experiment::FluIllumina
-                    || self.experiment == Experiment::FluONT =>
-            {
-                Ok(())
-            }
-            IRMAConfig::UTR
-                if self.experiment == Experiment::FluIllumina
-                    || self.experiment == Experiment::FluONT =>
-            {
-                Ok(())
-            }
-            IRMAConfig::Custom => Ok(()),
-            IRMAConfig::NoConfig => Ok(()),
+            IRMAConfig::Custom | IRMAConfig::NoConfig => Ok(()),
             _ => Err(format!(
                 "Invalid combination: {:?} cannot be used with {:?}",
                 self.experiment, self.irma_config
@@ -128,15 +115,13 @@ impl ValueEnum for Experiment {
 
 impl Experiment {
     /// Selects the appropriate IRMA Module from the user provided experiment type
-    fn get_module(&self) -> IrmaModule {
+    fn get_module(self) -> IrmaModule {
         match self {
             Self::FluIllumina => IrmaModule::FLU,
-            Self::RSVIllumina => IrmaModule::RSV,
-            Self::SC2WholeGenomeIllumina => IrmaModule::CoV,
+            Self::RSVIllumina | Self::RSVONT => IrmaModule::RSV,
+            Self::SC2WholeGenomeIllumina | Self::SC2WholeGenomeONT => IrmaModule::CoV,
             Self::FluONT => IrmaModule::FLUMinion,
             Self::SC2SpikeOnlyONT => IrmaModule::CoVsGene,
-            Self::SC2WholeGenomeONT => IrmaModule::CoV,
-            Self::RSVONT => IrmaModule::RSV,
         }
     }
 }
@@ -188,7 +173,7 @@ fn get_config_path(args: &FindChemArgs, seq_len: Option<usize>) -> String {
     }
 
     let path_extension = match (args.experiment, seq_len, args.irma_config) {
-        (_, None, _) => return "".to_string(),
+        (_, None, _) => return String::new(),
         (_, _, IRMAConfig::Sensitive) => "/bin/irma_config/FLU-sensitive.sh",
         (_, _, IRMAConfig::Secondary) => "/bin/irma_config/FLU-secondary.sh",
         (_, _, IRMAConfig::UTR) => "/bin/irma_config/FLU-utr.sh",
@@ -309,15 +294,15 @@ fn parse_chemistry_args(args: &FindChemArgs) -> Result<ChemistryOutput, std::io:
     Ok(out)
 }
 
-pub fn find_chemistry_process(args: FindChemArgs) -> Result<(), std::io::Error> {
+pub fn find_chemistry_process(args: &FindChemArgs) -> Result<(), std::io::Error> {
     //let args = CheckChemArgs::parse();
     // handle input validation to ensure valid combinations of
     if let Err(e) = args.validate() {
         eprintln!("Error: {e}");
         std::process::exit(1);
     }
     // parse the arguments into output format
-    let output = parse_chemistry_args(&args)?;
+    let output = parse_chemistry_args(args)?;
     let filename = format!("{}_chemistry.csv", args.sample);
     let headers = "sample_ID,irma_custom,subsample,irma_module";
 

src/processes/plotter.rs

@@ -9,7 +9,7 @@ use std::collections::HashMap;
 use std::error::Error;
 use std::fs::File;
 use std::io::{BufRead, BufReader};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 // Add this function to generate consistent colors for segment names
 fn get_segment_color(segment_name: &str) -> &'static str {
@@ -35,7 +35,7 @@ fn get_segment_color(segment_name: &str) -> &'static str {
         // For any other segments, use a hash of the segment name to pick a color
         let hash = segment_name
             .bytes()
-            .fold(0u32, |acc, b| acc.wrapping_add(b as u32));
+            .fold(0u32, |acc, b| acc.wrapping_add(u32::from(b)));
         match hash % 10 {
             0 => "#3366CC", // blue
             1 => "#DC3912", // red
@@ -105,7 +105,7 @@ pub struct PlotterArgs {
     output: Option<PathBuf>,
 }
 
-fn generate_plot_coverage(input_directory: &PathBuf) -> Result<Plot, Box<dyn Error>> {
+fn generate_plot_coverage(input_directory: &Path) -> Result<Plot, Box<dyn Error>> {
     // Create a Plotly plot
     let mut plot = Plot::new();
 
@@ -193,7 +193,7 @@ fn generate_plot_coverage(input_directory: &PathBuf) -> Result<Plot, Box<dyn Err
     Ok(plot)
 }
 
-fn generate_plot_coverage_seg(input_directory: &PathBuf) -> Result<Plot, Box<dyn Error>> {
+fn generate_plot_coverage_seg(input_directory: &Path) -> Result<Plot, Box<dyn Error>> {
     // Init a Plotly plot
     let mut plot = Plot::new();
 
@@ -470,7 +470,7 @@ fn generate_plot_coverage_seg(input_directory: &PathBuf) -> Result<Plot, Box<dyn
 }
 
 // TO DO: fix colors for Sankey diagram
-fn generate_sankey_plot(input_directory: &PathBuf) -> Result<Plot, Box<dyn Error>> {
+fn generate_sankey_plot(input_directory: &Path) -> Result<Plot, Box<dyn Error>> {
     // Path to READ_COUNTS.txt
     let read_counts_path = input_directory.join("tables").join("READ_COUNTS.txt");
 
@@ -658,7 +658,10 @@ fn generate_sankey_plot(input_directory: &PathBuf) -> Result<Plot, Box<dyn Error
     let mut plot = Plot::new();
 
     // Create Sankey trace
-    let node_labels_refs: Vec<&str> = node_labels.iter().map(|s| s.as_str()).collect();
+    let node_labels_refs: Vec<&str> = node_labels
+        .iter()
+        .map(std::string::String::as_str)
+        .collect();
 
     // Explicitly define x and y positions for each node
     let n = node_labels.len();
@@ -696,7 +699,7 @@ fn generate_sankey_plot(input_directory: &PathBuf) -> Result<Plot, Box<dyn Error
             _ => {
                 // Segment nodes: stack vertically in last column
                 x[i] = 0.7;
-                y[i] = 0.1 + 0.8 * (seg_idx as f64) / ((n - 5).max(1) as f64);
+                y[i] = 0.1 + 0.8 * f64::from(seg_idx) / ((n - 5).max(1) as f64);
                 seg_idx += 1;
             }
         }

src/processes/positions_of_interest.rs

@@ -139,10 +139,9 @@ impl Entry<'_> {
             {
                 // Use match for cleaner handling of `hold_aa_mut` cases
                 self.phenotypic_consequences = match hold_aa_mut.as_str() {
-                    "." => "amino acid information missing".to_string(),
                     "~" => "partial amino acid".to_string(),
                     "-" => "amino acid covered".to_string(),
-                    "X" => "amino acid information missing".to_string(),
+                    "." | "X" => "amino acid information missing".to_string(),
                     aa if aa == muts_entry.aa => muts_entry.description.clone(),
                     _ => String::new(),
                 };
@@ -318,8 +317,8 @@ pub fn positions_of_interest_process(args: PositionsArgs) -> Result<(), Box<dyn
                         .expect("Invalid UTF-8 sequence")
                         .to_string();
                     entry.aa_position = tail_index + 1;
-                    entry.aa_ref = '~' as char;
-                    entry.aa_mut = '~' as char;
+                    entry.aa_ref = '~';
+                    entry.aa_mut = '~';
 
                     if entry.update_entry_from_alignment(
                         &ref_entry.subtype,

src/processes/prepare_mira_reports.rs

@@ -1,5 +1,23 @@
 #![allow(dead_code, unused_imports)]
-use crate::utils::{data_ingest::*, data_processing::*, writing_outputs::*};
+use crate::utils::{
+    data_ingest::{
+        DaisSeqData, allele_data_collection, amended_consensus_data_collection,
+        coverage_data_collection, create_reader, create_vtype_data, dais_insertion_data_collection,
+        dais_ref_seq_data_collection, dias_deletion_data_collection, dias_sequence_data_collection,
+        get_reference_lens, indels_data_collection, read_csv, reads_data_collection,
+    },
+    data_processing::{
+        DaisVarsData, HasSampleId, HasSampleType, ProcessedCoverage, Subtype,
+        collect_analysis_metadata, collect_negatives, collect_sample_id, compute_cvv_dais_variants,
+        compute_dais_variants, create_prelim_irma_summary_df, extract_field, extract_subtype_flu,
+        extract_subtype_sc2, melt_reads_data, process_position_coverage_data,
+        process_wgs_coverage_data, return_seg_data,
+    },
+    writing_outputs::{
+        negative_qc_statement, write_reads_to_parquet, write_ref_data_json,
+        write_structs_to_csv_file, write_structs_to_split_json_file,
+    },
+};
 use clap::Parser;
 use csv::ReaderBuilder;
 use either::Either;

src/utils/writing_outputs.rs

@@ -24,9 +24,9 @@ pub struct ReadQC {
 /// Function to serialize a vector of structs into split-oriented JSON with precision and indexing
 pub fn write_structs_to_split_json_file<T: Serialize>(
     file_path: &str,
-    data: &Vec<T>,
-    columns: &Vec<&str>,
-    struct_values: &Vec<&str>,
+    data: &[T],
+    columns: &[&str],
+    struct_values: &[&str],
 ) -> Result<(), Box<dyn Error>> {
     // Create the "split-oriented" JSON structure
     let split_json = json!({
@@ -58,9 +58,9 @@ pub fn write_structs_to_split_json_file<T: Serialize>(
 /// Write to CSV
 pub fn write_structs_to_csv_file<T: Serialize>(
     file_path: &str,
-    data: &Vec<T>,
-    columns: &Vec<&str>,
-    struct_values: &Vec<&str>,
+    data: &[T],
+    columns: &[&str],
+    struct_values: &[&str],
 ) -> Result<(), Box<dyn Error>> {
     let mut csv_writer = Writer::from_path(file_path)?;
 
@@ -94,8 +94,8 @@ pub fn write_structs_to_csv_file<T: Serialize>(
 pub fn write_ref_data_json(
     file_path: &str,
     ref_lens: &HashMap<String, usize>,
-    segments: &Vec<String>,
-    segset: &Vec<String>,
+    segments: &[String],
+    segset: &[String],
     segcolor: &HashMap<String, &str>,
 ) -> Result<(), Box<dyn Error>> {
     let json_data = json!({
@@ -117,22 +117,22 @@ pub fn write_ref_data_json(
 
 /// Write the reads data to parquet file.
 pub fn write_reads_to_parquet(
-    reads_data: &Vec<ReadsData>,
+    reads_data: &[ReadsData],
     output_file: &str,
 ) -> Result<(), Box<dyn Error>> {
     // Convert values in struct to vector of values
     let sample_ids_vec: Vec<Option<String>> =
-        extract_field(reads_data.clone(), |item| item.sample_id.clone());
-    let record_vec = extract_field(reads_data.clone(), |item| item.record.clone());
-    let reads_vec = extract_field(reads_data.clone(), |item| item.reads);
-    let patterns_vec = extract_string_fields_as_float(reads_data.clone(), |item| &item.patterns);
+        extract_field(reads_data.to_owned(), |item| item.sample_id.clone());
+    let record_vec = extract_field(reads_data.to_owned(), |item| item.record.clone());
+    let reads_vec = extract_field(reads_data.to_owned(), |item| item.reads);
+    let patterns_vec = extract_string_fields_as_float(reads_data.to_owned(), |item| &item.patterns);
     let pairs_and_windows_vec =
-        extract_string_fields_as_float(reads_data.clone(), |item| &item.pairs_and_windows);
-    let stages_vec = extract_string_fields_as_int(reads_data.clone(), |item| {
+        extract_string_fields_as_float(reads_data.to_owned(), |item| &item.pairs_and_windows);
+    let stages_vec = extract_string_fields_as_int(reads_data.to_owned(), |item| {
         item.stage.as_deref().unwrap_or("")
     });
-    let runid_vec = extract_field(reads_data.clone(), |item| item.run_id.clone());
-    let instrument_vec = extract_field(reads_data.clone(), |item| item.instrument.clone());
+    let runid_vec = extract_field(reads_data.to_owned(), |item| item.run_id.clone());
+    let instrument_vec = extract_field(reads_data.to_owned(), |item| item.instrument.clone());
 
     // Convert the vectors into Arrow columns
     let sample_array: ArrayRef = Arc::new(StringArray::from(sample_ids_vec));
@@ -183,8 +183,8 @@ pub fn write_reads_to_parquet(
 
 pub fn negative_qc_statement(
     output_file: &str,
-    reads_data: &Vec<ReadsData>,
-    neg_control_list: &Vec<String>,
+    reads_data: &[ReadsData],
+    neg_control_list: &[String],
 ) -> Result<(), Box<dyn Error>> {
     let filtered_reads_data = filter_struct_by_ids(reads_data, neg_control_list.to_vec());
 
@@ -207,7 +207,7 @@ pub fn negative_qc_statement(
 
                 if total_reads_stage_3 > 0 {
                     let percent_mapping =
-                        (total_reads_stage_3 as f64 / reads_stage_1 as f64 * 100.0).round();
+                        (f64::from(total_reads_stage_3) / f64::from(reads_stage_1) * 100.0).round();
 
                     results.push(ReadQC {
                         sample_id: sample_id.clone(),