chore: unify cigar stringification

Author: flying-sheep

src/align/read_align.rs

@@ -323,7 +323,6 @@ pub fn align_read(
                 } else {
                     "unknown"
                 };
-                let cigar_str: String = t.cigar.iter().map(|op| format!("{}", op)).collect();
                 eprintln!(
                     "  transcript[{}]: chr={}:{}-{} ({}) score={} mm={} junctions={} cigar={}",
                     ti,
@@ -334,7 +333,7 @@ pub fn align_read(
                     t.score,
                     t.n_mismatch,
                     t.n_junction,
-                    cigar_str
+                    t.cigar_string()
                 );
             }
         }
@@ -633,7 +632,6 @@ pub fn align_read(
             } else {
                 "unknown"
             };
-            let cigar_str: String = t.cigar.iter().map(|op| format!("{}", op)).collect();
             eprintln!(
                 "  FINAL[{}]: chr={}:{}-{} ({}) score={} mm={} junctions={} cigar={}",
                 i,
@@ -644,7 +642,7 @@ pub fn align_read(
                 t.score,
                 t.n_mismatch,
                 t.n_junction,
-                cigar_str
+                t.cigar_string()
             );
         }
     }

src/align/transcript.rs

@@ -1,5 +1,5 @@
 /// Transcript data structures for storing alignment results
-use std::fmt;
+use std::fmt::Write as _;
 
 /// A complete alignment of a read to the genome
 #[derive(Debug, Clone)]
@@ -134,16 +134,18 @@ impl CigarOp {
     }
 }
 
-impl fmt::Display for CigarOp {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}{}", self.len(), self.op_char())
-    }
+/// Convert CIGAR operations to CIGAR string
+pub(crate) fn cigar_to_string(cigar: &[CigarOp]) -> String {
+    cigar.iter().fold(String::new(), |mut c, op| {
+        let _ = write!(c, "{}{}", op.len(), op.op_char()); // infallible
+        c
+    })
 }
 
 impl Transcript {
     /// Format CIGAR string
     pub fn cigar_string(&self) -> String {
-        self.cigar.iter().map(|op| op.to_string()).collect()
+        cigar_to_string(&self.cigar)
     }
 
     /// Calculate number of matched bases (for filtering)
@@ -201,12 +203,16 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_cigar_op_display() {
-        assert_eq!(CigarOp::Match(50).to_string(), "50M");
-        assert_eq!(CigarOp::Ins(3).to_string(), "3I");
-        assert_eq!(CigarOp::Del(2).to_string(), "2D");
-        assert_eq!(CigarOp::RefSkip(1000).to_string(), "1000N");
-        assert_eq!(CigarOp::SoftClip(5).to_string(), "5S");
+    fn test_cigar_to_string() {
+        let cigar = vec![
+            CigarOp::Match(50),
+            CigarOp::Ins(2),
+            CigarOp::Del(3),
+            CigarOp::RefSkip(1000),
+            CigarOp::SoftClip(5),
+        ];
+
+        assert_eq!(cigar_to_string(&cigar), "50M2I3D1000N5S");
     }
 
     #[test]

src/chimeric/output.rs

@@ -78,8 +78,8 @@ impl ChimericJunctionWriter {
         let acceptor_start = alignment.acceptor.genome_start + 1;
 
         // Convert CIGAR to string
-        let donor_cigar = cigar_to_string(&alignment.donor.cigar);
-        let acceptor_cigar = cigar_to_string(&alignment.acceptor.cigar);
+        let donor_cigar = alignment.donor.cigar_string();
+        let acceptor_cigar = alignment.acceptor.cigar_string();
 
         // Write line
         writeln!(
@@ -162,7 +162,7 @@ fn format_sa_entry(
     let chr_start = chr_starts[seg.chr_idx];
     let pos = seg.genome_start - chr_start + 1; // 1-based per-chr
     let strand = if seg.is_reverse { '-' } else { '+' };
-    let cigar = cigar_to_string(&seg.cigar);
+    let cigar = seg.cigar_string();
     format!(
         "{},{},{},{},{},{};",
         chr, pos, strand, cigar, mapq, seg.n_mismatch
@@ -233,26 +233,6 @@ fn build_segment_record(
     Ok(record)
 }
 
-/// Convert CIGAR operations to CIGAR string
-fn cigar_to_string(cigar: &[crate::align::transcript::CigarOp]) -> String {
-    use crate::align::transcript::CigarOp;
-
-    let mut result = String::new();
-    for op in cigar {
-        match op {
-            CigarOp::Match(len) => result.push_str(&format!("{}M", len)),
-            CigarOp::Equal(len) => result.push_str(&format!("{}=", len)),
-            CigarOp::Diff(len) => result.push_str(&format!("{}X", len)),
-            CigarOp::Ins(len) => result.push_str(&format!("{}I", len)),
-            CigarOp::Del(len) => result.push_str(&format!("{}D", len)),
-            CigarOp::RefSkip(len) => result.push_str(&format!("{}N", len)),
-            CigarOp::SoftClip(len) => result.push_str(&format!("{}S", len)),
-            CigarOp::HardClip(len) => result.push_str(&format!("{}H", len)),
-        }
-    }
-    result
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -261,19 +241,6 @@ mod tests {
     use std::io::Read;
     use tempfile::tempdir;
 
-    #[test]
-    fn test_cigar_to_string() {
-        let cigar = vec![
-            CigarOp::Match(50),
-            CigarOp::Ins(2),
-            CigarOp::Del(3),
-            CigarOp::RefSkip(1000),
-            CigarOp::SoftClip(5),
-        ];
-
-        assert_eq!(cigar_to_string(&cigar), "50M2I3D1000N5S");
-    }
-
     #[test]
     fn test_chimeric_junction_writer_creation() {
         let dir = tempdir().unwrap();

src/chimeric/segment.rs

@@ -1,6 +1,6 @@
 // ChimericSegment and ChimericAlignment data structures
 
-use crate::align::transcript::CigarOp;
+use crate::align::transcript::{CigarOp, cigar_to_string};
 
 /// A single segment of a chimeric alignment
 #[derive(Debug, Clone)]
@@ -31,6 +31,11 @@ impl ChimericSegment {
     pub fn meets_min_length(&self, min_len: u32) -> bool {
         self.read_length() >= min_len as usize
     }
+
+    /// Format CIGAR string
+    pub fn cigar_string(&self) -> String {
+        cigar_to_string(&self.cigar)
+    }
 }
 
 /// A chimeric alignment consisting of two segments

src/io/sam.rs

@@ -149,10 +149,10 @@ impl SamWriter {
                     .name()
                     .map(|n| String::from_utf8_lossy(n.as_ref()).to_string())
                     .unwrap_or_default();
-                let cigar_str: String = cigar_ops
-                    .iter()
-                    .map(|op| format!("{}{:?}", op.len(), op.kind()))
-                    .collect::<String>();
+                let cigar_str = cigar_ops.iter().fold(String::new(), |mut c, op| {
+                    let _ = write!(c, "{}{:?}", op.len(), op.kind()); // infallible
+                    c
+                });
                 panic!(
                     "[SAM-MISMATCH] read={} cigar_query_len={} seq_len={} flags={:?} cigar={}",
                     name,

src/lib.rs

@@ -7,8 +7,6 @@
     clippy::cast_precision_loss,
     clippy::cast_sign_loss,
     clippy::doc_markdown,
-    clippy::format_collect,
-    clippy::format_push_string,
     clippy::items_after_statements,
     clippy::match_same_arms,
     clippy::missing_errors_doc,