Update to noodles 0.96.0

GFF strings are now byte strings, and the BAM encoder no longer allows
invalid characters in record data string values.

Author: zaeleus

Cargo.lock

@@ -20,8 +20,8 @@ flate2 = "1.0.14"
 git-testament = "0.2.0"
 indexmap = "2.7.1"
 mimalloc = "0.1.43"
-noodles = { version = "0.95.0", features = ["bam", "bgzf", "core", "gff", "sam"] }
-noodles-bgzf = { version = "0.37.0", features = ["libdeflate"] }
+noodles = { version = "0.96.0", features = ["bam", "bgzf", "core", "gff", "sam"] }
+noodles-bgzf = { version = "0.38.0", features = ["libdeflate"] }
 rustc-hash = "2.1.1"
 thiserror = "2.0.11"
 tracing = "0.1.25"

Cargo.toml

@@ -5,6 +5,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use bstr::BString;
 use thiserror::Error;
 use tracing::info;
 
@@ -79,7 +80,7 @@ where
     Ok(())
 }
 
-fn read_counts<P>(src: P) -> Result<Vec<(String, u32)>, NormalizeError>
+fn read_counts<P>(src: P) -> Result<Vec<(BString, u32)>, NormalizeError>
 where
     P: AsRef<Path>,
 {
@@ -91,8 +92,8 @@ where
 }
 
 fn calculate_feature_lengths(
-    features: &HashMap<String, Vec<Feature>>,
-    names: &[String],
+    features: &HashMap<BString, Vec<Feature>>,
+    names: &[BString],
 ) -> io::Result<Vec<u32>> {
     normalization::calculate_feature_lengths(features, names)
         .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?
@@ -101,7 +102,7 @@ fn calculate_feature_lengths(
         .collect()
 }
 
-fn write_normalized_counts<W>(writer: &mut W, names: &[String], values: &[f64]) -> io::Result<()>
+fn write_normalized_counts<W>(writer: &mut W, names: &[BString], values: &[f64]) -> io::Result<()>
 where
     W: Write,
 {
@@ -121,10 +122,10 @@ mod tests {
     #[test]
     fn test_write_normalized_counts() -> io::Result<()> {
         let names = [
-            String::from("AADAT"),
-            String::from("CLN3"),
-            String::from("NEO1"),
-            String::from("PAK4"),
+            BString::from("AADAT"),
+            BString::from("CLN3"),
+            BString::from("NEO1"),
+            BString::from("PAK4"),
         ];
 
         let values = [30.2, 3.7, 0.0, 14.5];

src/commands/normalize.rs

@@ -5,6 +5,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use bstr::{BString, ByteSlice};
 use noodles::{bam, bgzf};
 use thiserror::Error;
 use tracing::{info, warn};
@@ -60,7 +61,7 @@ where
             .map(Box::new)
             .map_err(|e| QuantifyError::OpenFile(e, src.into()))?
     } else {
-        bgzf::reader::Builder
+        bgzf::io::reader::Builder
             .build_from_path(src)
             .map(Box::new)
             .map_err(|e| QuantifyError::OpenFile(e, src.into()))?
@@ -160,14 +161,14 @@ fn strand_specification_from_option_or(
 
 const DELIMITER: char = '\t';
 
-fn write_counts<W>(writer: &mut W, feature_names: &[&String], counts: &Counts) -> io::Result<()>
+fn write_counts<W>(writer: &mut W, feature_names: &[&BString], counts: &Counts) -> io::Result<()>
 where
     W: Write,
 {
     const MISSING: u64 = 0;
 
     for name in feature_names {
-        let count = counts.get(name.as_str()).copied().unwrap_or(MISSING);
+        let count = counts.get(name.as_bstr()).copied().unwrap_or(MISSING);
         writeln!(writer, "{name}{DELIMITER}{count}")?;
     }
 
@@ -189,6 +190,8 @@ where
 
 #[cfg(test)]
 mod tests {
+    use bstr::BStr;
+
     use super::*;
 
     #[test]
@@ -228,15 +231,19 @@ mod tests {
 
     #[test]
     fn test_write_counts() -> io::Result<()> {
-        let counts = [("AADAT", 302), ("CLN3", 37), ("PAK4", 145)]
-            .into_iter()
-            .collect();
+        let counts = [
+            (BStr::new("AADAT"), 302),
+            (BStr::new("CLN3"), 37),
+            (BStr::new("PAK4"), 145),
+        ]
+        .into_iter()
+        .collect();
 
         let names = [
-            &String::from("AADAT"),
-            &String::from("CLN3"),
-            &String::from("NEO1"),
-            &String::from("PAK4"),
+            &BString::from("AADAT"),
+            &BString::from("CLN3"),
+            &BString::from("NEO1"),
+            &BString::from("PAK4"),
         ];
 
         let mut buf = Vec::new();

src/commands/quantify.rs

@@ -8,6 +8,7 @@ use std::{
     thread,
 };
 
+use bstr::BStr;
 use noodles::{bam, core::Position};
 
 use self::context::Event;
@@ -247,7 +248,7 @@ fn count_record<'f>(
     strand_specification: StrandSpecification,
     is_reverse_complemented: bool,
     record: &bam::Record,
-    intersections: &mut HashSet<&'f str>,
+    intersections: &mut HashSet<&'f BStr>,
 ) -> io::Result<Option<Event<'f>>> {
     let reference_sequence_id = record
         .reference_sequence_id()
@@ -280,7 +281,7 @@ fn count_record<'f>(
 }
 
 fn intersect<'f>(
-    intersections: &mut HashSet<&'f str>,
+    intersections: &mut HashSet<&'f BStr>,
     interval_tree: &IntervalTree<Position, Entry<'f>>,
     intervals: MatchIntervals,
     strand_specification: StrandSpecification,
@@ -304,7 +305,7 @@ fn intersect<'f>(
     Ok(())
 }
 
-fn resolve_intersections<'f>(intersections: &HashSet<&'f str>) -> Event<'f> {
+fn resolve_intersections<'f>(intersections: &HashSet<&'f BStr>) -> Event<'f> {
     if intersections.is_empty() {
         Event::Miss
     } else if intersections.len() == 1 {

src/count.rs

@@ -1,10 +1,12 @@
 mod event;
 
-pub use self::event::Event;
+use bstr::BStr;
 
 use std::collections::HashMap;
 
-pub type Counts<'f> = HashMap<&'f str, u64>;
+pub use self::event::Event;
+
+pub type Counts<'f> = HashMap<&'f BStr, u64>;
 
 #[derive(Default)]
 pub struct Context<'f> {
@@ -54,7 +56,7 @@ mod tests {
     fn test_add() {
         let mut ctx_a = Context::default();
 
-        ctx_a.counts.insert("AADAT", 2);
+        ctx_a.counts.insert(BStr::new("AADAT"), 2);
         ctx_a.miss = 3;
         ctx_a.ambiguous = 5;
         ctx_a.low_quality = 8;
@@ -63,8 +65,8 @@ mod tests {
 
         let mut ctx_b = Context::default();
 
-        ctx_b.counts.insert("AADAT", 2);
-        ctx_b.counts.insert("CLN3", 3);
+        ctx_b.counts.insert(BStr::new("AADAT"), 2);
+        ctx_b.counts.insert(BStr::new("CLN3"), 3);
         ctx_b.miss = 5;
         ctx_b.ambiguous = 8;
         ctx_b.low_quality = 13;
@@ -74,8 +76,8 @@ mod tests {
         ctx_a.add(&ctx_b);
 
         assert_eq!(ctx_a.counts.len(), 2);
-        assert_eq!(ctx_a.counts["AADAT"], 4);
-        assert_eq!(ctx_a.counts["CLN3"], 3);
+        assert_eq!(ctx_a.counts[BStr::new("AADAT")], 4);
+        assert_eq!(ctx_a.counts[BStr::new("CLN3")], 3);
 
         assert_eq!(ctx_a.miss, 8);
         assert_eq!(ctx_a.ambiguous, 13);
@@ -87,15 +89,15 @@ mod tests {
     #[test]
     fn test_add_event() {
         let mut ctx = Context::default();
-        ctx.add_event(Event::Hit("AADAT"));
+        ctx.add_event(Event::Hit(BStr::new("AADAT")));
         ctx.add_event(Event::Miss);
         ctx.add_event(Event::Ambiguous);
         ctx.add_event(Event::LowQuality);
         ctx.add_event(Event::Unmapped);
         ctx.add_event(Event::Nonunique);
 
         assert_eq!(ctx.counts.len(), 1);
-        assert_eq!(ctx.counts["AADAT"], 1);
+        assert_eq!(ctx.counts[BStr::new("AADAT")], 1);
 
         assert_eq!(ctx.miss, 1);
         assert_eq!(ctx.ambiguous, 1);

src/count/context.rs

@@ -1,6 +1,8 @@
+use bstr::BStr;
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Event<'f> {
-    Hit(&'f str),
+    Hit(&'f BStr),
     Miss,
     Ambiguous,
     LowQuality,

src/count/context/event.rs

@@ -3,6 +3,7 @@ use std::{
     num,
 };
 
+use bstr::BString;
 use thiserror::Error;
 
 static HTSEQ_COUNT_META_PREFIX: &str = "__";
@@ -17,7 +18,7 @@ pub enum ReadCountsError {
     Io(#[from] io::Error),
 }
 
-pub fn read<R>(reader: &mut R) -> Result<Vec<(String, u32)>, ReadCountsError>
+pub fn read<R>(reader: &mut R) -> Result<Vec<(BString, u32)>, ReadCountsError>
 where
     R: BufRead,
 {
@@ -116,9 +117,9 @@ __alignment_not_unique\t0
         let actual = read(&mut reader)?;
 
         let expected = [
-            (String::from("AADAT"), 302),
-            (String::from("CLN3"), 37),
-            (String::from("PAK4"), 145),
+            (BString::from("AADAT"), 302),
+            (BString::from("CLN3"), 37),
+            (BString::from("PAK4"), 145),
         ];
 
         assert_eq!(actual, expected);