clippy

Author: AndreaGuarracino

src/agc_index.rs

@@ -53,7 +53,7 @@ impl AgcIndex {
                 if !agc.open(agc_path, true) {
                     return Err(io::Error::new(
                         io::ErrorKind::InvalidData,
-                        format!("Failed to open AGC file: {}", agc_path),
+                        format!("Failed to open AGC file: {agc_path}"),
                     ));
                 }
 
@@ -78,7 +78,7 @@ impl AgcIndex {
             for (sample, contigs) in sample_contigs {
                 for contig in contigs {
                     // Create a key that combines full contig name and sample name
-                    let key = format!("{}@{}", contig, sample);
+                    let key = format!("{contig}@{sample}");
                     index.sample_contig_to_agc.insert(key.clone(), agc_idx);
 
                     // Also insert just the full contig name if it's unique
@@ -102,7 +102,7 @@ impl AgcIndex {
                     // If short name differs from full name, also create mappings for short name
                     if short_contig != contig {
                         // Create key with short contig name and sample
-                        let short_key = format!("{}@{}", short_contig, sample);
+                        let short_key = format!("{short_contig}@{sample}");
                         index
                             .sample_contig_to_agc
                             .entry(short_key)
@@ -154,7 +154,7 @@ impl AgcIndex {
         let agc_idx = agc_idx.ok_or_else(|| {
             io::Error::new(
                 io::ErrorKind::NotFound,
-                format!("Sequence '{}' not found in any AGC file", seq_name),
+                format!("Sequence '{seq_name}' not found in any AGC file"),
             )
         })?;
 
@@ -164,8 +164,7 @@ impl AgcIndex {
             .get_contig_sequence(&sample, &contig, start, end - 1)
             .map_err(|e| {
                 io::Error::other(format!(
-                    "Failed to fetch sequence '{}@{}:{}:{}': {}",
-                    contig, sample, start, end, e
+                    "Failed to fetch sequence '{contig}@{sample}:{start}:{end}': {e}"
                 ))
             })?;
 
@@ -178,7 +177,7 @@ impl AgcIndex {
         let agc_idx = agc_idx.ok_or_else(|| {
             io::Error::new(
                 io::ErrorKind::NotFound,
-                format!("Sequence '{}' not found in any AGC file", seq_name),
+                format!("Sequence '{seq_name}' not found in any AGC file"),
             )
         })?;
 

src/commands/lace.rs

@@ -54,7 +54,7 @@ pub fn partition_alignments(
         let file = File::open(path).map_err(|e| {
             io::Error::new(
                 io::ErrorKind::NotFound,
-                format!("Could not open starting sequences file {}: {}", path, e),
+                format!("Could not open starting sequences file {path}: {e}"),
             )
         })?;
 
@@ -75,8 +75,7 @@ pub fn partition_alignments(
                     starting_sequences.push((seq_id, 0, seq_length));
                 } else if debug {
                     debug!(
-                        "Sequence {} from starting file not found in index",
-                        trimmed_name
+                        "Sequence {trimmed_name} from starting file not found in index"
                     );
                 }
             }
@@ -316,14 +315,14 @@ pub fn partition_alignments(
                     (total_partitioned_length as f64 / total_sequence_length as f64) * 100.0;
                 // Create formatted percentage strings with conditional scientific notation
                 let current_percentage_str = if current_percentage < 0.0001 {
-                    format!("{:.4e}%", current_percentage)
+                    format!("{current_percentage:.4e}%")
                 } else {
-                    format!("{:.4}%", current_percentage)
+                    format!("{current_percentage:.4}%")
                 };
                 let total_percentage_str = if total_percentage < 0.0001 {
-                    format!("{:.4e}%", total_percentage)
+                    format!("{total_percentage:.4e}%")
                 } else {
-                    format!("{:.4}%", total_percentage)
+                    format!("{total_percentage:.4}%")
                 };
                 //let calc_time = calc_start.elapsed();
 
@@ -372,7 +371,7 @@ pub fn partition_alignments(
                         _ => {
                             return Err(io::Error::new(
                                 io::ErrorKind::InvalidInput,
-                                format!("Unsupported output format: {}", output_format),
+                                format!("Unsupported output format: {output_format}"),
                             ));
                         }
                     }
@@ -392,7 +391,7 @@ pub fn partition_alignments(
                         _ => {
                             return Err(io::Error::new(
                                 io::ErrorKind::InvalidInput,
-                                format!("Unsupported output format: {}", output_format),
+                                format!("Unsupported output format: {output_format}"),
                             ));
                         }
                     }
@@ -452,7 +451,7 @@ pub fn partition_alignments(
             .try_for_each(|partition_idx| -> io::Result<()> {
                 let temp_bed_file = create_output_path(
                     output_folder,
-                    &format!("partition{}.bed.tmp", partition_idx),
+                    &format!("partition{partition_idx}.bed.tmp"),
                 )?;
 
                 // Read intervals from temporary BED file using parse_bed_file
@@ -503,14 +502,13 @@ pub fn partition_alignments(
     let final_percentage = (total_partitioned_length as f64 / total_sequence_length as f64) * 100.0;
     // Create formatted percentage string with conditional scientific notation
     let final_percentage_str = if final_percentage < 0.0001 {
-        format!("{:.4e}%", final_percentage)
+        format!("{final_percentage:.4e}%")
     } else {
-        format!("{:.4}%", final_percentage)
+        format!("{final_percentage:.4}%")
     };
 
     info!(
-        "Partitioned into {} regions: {} bp total written / {} bp total sequence ({})",
-        partition_num, total_partitioned_length, total_sequence_length, final_percentage_str
+        "Partitioned into {partition_num} regions: {total_partitioned_length} bp total written / {total_sequence_length} bp total sequence ({final_percentage_str})"
     );
 
     Ok(())
@@ -588,8 +586,7 @@ fn select_and_window_sequences(
                 let seq_name = impg.seq_index.get_name(seq_id).unwrap();
 
                 debug!(
-                    "Selected sequence {} with most missing sequence ({}bp)",
-                    seq_name, max_total_missing
+                    "Selected sequence {seq_name} with most missing sequence ({max_total_missing}bp)"
                 );
 
                 ranges_to_window.push((seq_id, 0, seq_length));
@@ -1232,7 +1229,7 @@ fn write_partition(
         }
         _ => Err(io::Error::new(
             io::ErrorKind::InvalidInput,
-            format!("Unsupported output format: {}", output_format),
+            format!("Unsupported output format: {output_format}"),
         )),
     }
 }
@@ -1246,8 +1243,8 @@ fn write_partition_bed(
 ) -> io::Result<()> {
     // Create filename with optional suffix
     let filename = match suffix {
-        Some(s) => format!("partition{}.bed{}", partition_num, s),
-        None => format!("partition{}.bed", partition_num),
+        Some(s) => format!("partition{partition_num}.bed{s}"),
+        None => format!("partition{partition_num}.bed"),
     };
 
     // Create full path with output folder
@@ -1265,7 +1262,7 @@ fn write_partition_bed(
             (query_interval.last, query_interval.first)
         };
 
-        writeln!(writer, "{}\t{}\t{}", name, start, end)?;
+        writeln!(writer, "{name}\t{start}\t{end}")?;
     }
 
     writer.flush()?;
@@ -1289,13 +1286,13 @@ fn write_partition_gfa(
     );
 
     // Create output file
-    let filename = format!("partition{}.gfa", partition_num);
+    let filename = format!("partition{partition_num}.gfa");
     let full_path = create_output_path(output_folder, &filename)?;
     let file = File::create(full_path)?;
     let mut writer = BufWriter::new(file);
 
     // Write the GFA output to the file
-    writeln!(writer, "{}", gfa_output)?;
+    writeln!(writer, "{gfa_output}")?;
     writer.flush()?;
     Ok(())
 }
@@ -1317,13 +1314,13 @@ fn write_partition_maf(
     );
 
     // Create output file
-    let filename = format!("partition{}.maf", partition_num);
+    let filename = format!("partition{partition_num}.maf");
     let full_path = create_output_path(output_folder, &filename)?;
     let file = File::create(full_path)?;
     let mut writer = BufWriter::new(file);
 
     // Write the MAF output to the file
-    write!(writer, "{}", maf_output)?;
+    write!(writer, "{maf_output}")?;
     writer.flush()?;
     Ok(())
 }
@@ -1338,7 +1335,7 @@ fn write_partition_fasta(
     reverse_complement: bool,
 ) -> io::Result<()> {
     // Create output file
-    let filename = format!("partition{}.fasta", partition_num);
+    let filename = format!("partition{partition_num}.fasta");
     let full_path = create_output_path(output_folder, &filename)?;
     let file = File::create(full_path)?;
     let mut writer = BufWriter::new(file);
@@ -1369,7 +1366,7 @@ fn write_partition_fasta(
         } else {
             ""
         };
-        writeln!(writer, ">{}:{}-{}{}", query_name, start, end, header_suffix)?;
+        writeln!(writer, ">{query_name}:{start}-{end}{header_suffix}")?;
 
         // Write sequence in lines of 80 characters
         let sequence_str = String::from_utf8_lossy(&sequence);
@@ -1404,7 +1401,7 @@ fn write_single_partition_file(
                         (query_interval.last, query_interval.first)
                     };
 
-                    writeln!(writer, "{}	{}	{}	{}", name, start, end, partition_num)?;
+                    writeln!(writer, "{name}	{start}	{end}	{partition_num}")?;
                 }
             }
 
@@ -1414,8 +1411,7 @@ fn write_single_partition_file(
         _ => Err(io::Error::new(
             io::ErrorKind::InvalidInput,
             format!(
-                "Single-file output not supported for format: {}",
-                output_format
+                "Single-file output not supported for format: {output_format}"
             ),
         )),
     }

src/commands/partition.rs

@@ -131,7 +131,7 @@ pub fn compute_and_output_similarities(
                 // Lock stdout and write both header and results
                 let stdout = stdout_mutex.lock().unwrap();
                 let mut handle = stdout.lock();
-                write!(handle, "{}", similarity_output)?;
+                write!(handle, "{similarity_output}")?;
 
                 Ok(())
             })?;
@@ -194,7 +194,7 @@ fn compute_similarities_for_region(
     delim_pos: u16,
     region: &str,
 ) -> io::Result<String> {
-    debug!("Computing similarities for region {:?}", region);
+    debug!("Computing similarities for region {region:?}");
 
     let (groups, msa_chars) = prepare_groups_and_msa(
         impg,
@@ -330,7 +330,7 @@ fn compute_pca_for_region(
                     n_components: 0,
                 })
             } else {
-                Err(io::Error::other(format!("PCA/MDS failed: {}", e)))
+                Err(io::Error::other(format!("PCA/MDS failed: {e}")))
             }
         }
     }
@@ -393,8 +393,7 @@ fn format_similarity_line(
     emit_distances: bool,
 ) {
     output.push_str(&format!(
-        "{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t",
-        chrom, start, end, name_a, name_b, len_a, len_b, intersection
+        "{chrom}\t{start}\t{end}\t{name_a}\t{name_b}\t{len_a}\t{len_b}\t{intersection}\t"
     ));
 
     if emit_distances {
@@ -417,7 +416,7 @@ fn format_similarity_line(
 }
 
 fn format_value(value: f32) -> String {
-    let formatted = format!("{:.7}", value);
+    let formatted = format!("{value:.7}");
     let trimmed = formatted.trim_end_matches('0');
     if trimmed.ends_with('.') {
         trimmed.trim_end_matches('.').to_string()
@@ -583,8 +582,7 @@ impl PcaResult {
                 let pc_value = self.coordinates[group_idx][pc_idx];
 
                 output.push_str(&format!(
-                    "{}\t{}\t{}\t{}\t{}\t{:.7}\n",
-                    chrom, start, end, group_name, pc_rank, pc_value
+                    "{chrom}\t{start}\t{end}\t{group_name}\t{pc_rank}\t{pc_value:.7}\n"
                 ));
             }
         }
@@ -733,7 +731,7 @@ fn polarize_pca_result_with_guides(
         if guide_indices[i].iter().all(|idx| idx.is_none()) {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
-                format!("Guide sample '{}' not found in any window", guide_name),
+                format!("Guide sample '{guide_name}' not found in any window"),
             ));
         }
     }
@@ -973,7 +971,7 @@ pub fn build_distance_matrix(
             _ => {
                 return Err(io::Error::new(
                     io::ErrorKind::InvalidInput,
-                    format!("Unknown similarity type: {}", similarity_type),
+                    format!("Unknown similarity type: {similarity_type}"),
                 ))
             }
         };

src/commands/similarity.rs

@@ -26,7 +26,7 @@ impl FastaIndex {
             index.fasta_paths.push(fasta_path.clone());
 
             // Read the .fai file to get sequence names
-            let fai_path = format!("{}.fai", fasta_path);
+            let fai_path = format!("{fasta_path}.fai");
 
             // Try to open the .fai file, if it doesn't exist, try to create it
             let fai_content = match std::fs::read_to_string(&fai_path) {
@@ -40,8 +40,7 @@ impl FastaIndex {
                         }
                         Err(e) => {
                             return Err(io::Error::other(format!(
-                                "Failed to create FASTA index for '{}': {}",
-                                fasta_path, e
+                                "Failed to create FASTA index for '{fasta_path}': {e}"
                             )));
                         }
                     }
@@ -80,12 +79,12 @@ impl FastaIndex {
         let fasta_path = self.get_fasta_path(seq_name).ok_or_else(|| {
             io::Error::new(
                 io::ErrorKind::NotFound,
-                format!("Sequence '{}' not found in any FASTA file", seq_name),
+                format!("Sequence '{seq_name}' not found in any FASTA file"),
             )
         })?;
 
         let reader = faidx::Reader::from_path(fasta_path).map_err(|e| {
-            io::Error::other(format!("Failed to open FASTA file '{}': {}", fasta_path, e))
+            io::Error::other(format!("Failed to open FASTA file '{fasta_path}': {e}"))
         })?;
 
         // Fetch sequence and properly handle memory
@@ -102,8 +101,7 @@ impl FastaIndex {
             }
             Err(e) => {
                 return Err(io::Error::other(format!(
-                    "Failed to fetch sequence for {}: {}",
-                    seq_name, e
+                    "Failed to fetch sequence for {seq_name}: {e}"
                 )))
             }
         };
@@ -115,7 +113,7 @@ impl FastaIndex {
         self.sequence_lengths.get(seq_name).copied().ok_or_else(|| {
             io::Error::new(
                 io::ErrorKind::NotFound,
-                format!("Sequence '{}' not found", seq_name),
+                format!("Sequence '{seq_name}' not found"),
             )
         })
     }