Merge branch 'main' of https://github.com/rusteomics/mzcore

Author: douweschulte

imgt/src/species.rs

@@ -118,23 +118,28 @@ macro_rules! species {
             fn from_str(s: &str) -> Result<Self, Self::Err> {
                 let s = s.trim().to_lowercase();
                 for (name, species) in SPECIES_PARSE_LIST {
-                    if name.to_lowercase() == s {
+                    if name.eq_ignore_ascii_case(&s) {
                         return Ok(*species);
                     }
                 }
 
-                // let options: Vec<String> = SPECIES_PARSE_LIST.iter()
-                //     .map(|option| option.0.to_lowercase())
-                //     .collect();
-                // let options: Vec<&str> = options.iter()
-                //     .map(|option| option.as_str())
-                //     .collect();
+                let mut options: Vec<(usize, Self)> = Vec::with_capacity(5);
+                for (name, species) in SPECIES_PARSE_LIST {
+                    let d = mzcv::text::levenshtein_distance(&name.to_lowercase(), &s);
+                    let index = options.binary_search_by(|a| a.0.cmp(&d)).unwrap_or_else(|i| i);
+                    if index < 5 {
+                        if options.len() == 5 {
+                            options.remove(4);
+                        }
+                        options.insert(index, (d, *species));
+                    }
+                }
 
                 Err(BoxedError::new(BasicKind::Error,
                         "Unknown species name",
                         "The provided name could not be recognised as a species name.",
-                        Context::show(s.as_str())
-                    ).to_owned() // TODO: maybe figure out a way to use mzcv to generate fuzzy matches here
+                        Context::show(s.as_str()).to_owned()
+                    ).suggestions(options.into_iter().map(|(_, s)| s.to_string()))
                 )
             }
         }

mzannotate/src/fragment/mzpaf/write.rs

@@ -202,7 +202,6 @@ impl ToMzPAF for Fragment {
             | FragmentType::Y(_)
             | FragmentType::YComposition(_, _) => {
                 if let Some(formula) = &self.formula {
-                    // TODO: better way of storing?
                     write!(w, "f{{{}}}", formula.hill_notation_core())?;
                     if formula.additional_mass() != 0.0 {
                         write!(w, "{:+}", formula.additional_mass())?;

mzcore/src/space.rs

@@ -118,6 +118,13 @@ impl Add for UsedSpace {
     }
 }
 
+impl Add<()> for UsedSpace {
+    type Output = Self;
+    fn add(self, rhs: ()) -> Self {
+        self
+    }
+}
+
 impl<T: Space> Space for &[T] {
     fn space(&self) -> UsedSpace {
         let mut total = UsedSpace::default();

mzcv/src/lib.rs

@@ -8,7 +8,7 @@ mod hash_buf_reader;
 mod load;
 mod lzw;
 mod obo;
-mod text;
+pub mod text;
 
 pub use curie::*;
 pub use cv_error::*;

mzcv/src/load.rs

@@ -625,16 +625,38 @@ impl<CV: CVSource> CVIndex<CV> {
                             flate2::Compression::fast(),
                         );
                         std::io::copy(&mut encoder, &mut writer)
-
-                        // response
-                        // .copy_to(&mut writer)
-                        // // .map(|_| ())
-                        // .map_err(|e| e.to_string())
-
-                        // Ok(0)
                     }
                     crate::CVCompression::Lzw => {
-                        todo!()
+                        use crate::lzw::ZArchive;
+
+                        let content = ZArchive::new(response.as_ref())
+                            .and_then(|mut a| a.read())
+                            .map_err(|e| {
+                                use crate::lzw::{self, ArchiveError};
+
+                                BoxedError::new(
+                                    CVError::FileCouldNotBeParsed,
+                                    "Could not decompress Lzw compression",
+                                    match e {
+                                        ArchiveError::DecompressionFailed { entry, reason } => {
+                                            format!("{entry} {reason}")
+                                        }
+                                        ArchiveError::InvalidHeader => format!(
+                                            "Invalid header, the first bytes have to be {:x}{:x}",
+                                            lzw::ID[0],
+                                            lzw::ID[1]
+                                        ),
+                                        ArchiveError::IO(io) => io.to_string(),
+                                    },
+                                    Context::none().source(url.to_string()).to_owned(),
+                                )
+                            })?;
+
+                        let mut encoder = flate2::bufread::GzEncoder::new(
+                            BufReader::new(content.as_slice()),
+                            flate2::Compression::fast(),
+                        );
+                        std::io::copy(&mut encoder, &mut writer)
                     }
                 }
                 .map_err(|e| {

mzcv/src/text.rs

@@ -16,7 +16,8 @@ const fn simplify_char(c: char) -> u8 {
     if c.is_ascii() { c as u32 as u8 } else { 0 }
 }
 
-pub(crate) fn levenshtein_distance(word1: &str, word2: &str) -> usize {
+/// Get the Levenshtein distance between two words
+pub fn levenshtein_distance(word1: &str, word2: &str) -> usize {
     let word2_len = word2.chars().count();
     let mut row1 = (0..).take(word2_len + 1).collect::<Vec<_>>();
     let mut row2 = vec![0; word2_len + 1];

mzident/src/common_parser.rs

@@ -91,7 +91,7 @@ macro_rules! format_family {
                 fn space(&self) -> mzcore::space::UsedSpace {
                     ( mzcore::space::UsedSpace::default()
                     $(+ self.$prname.space())*
-                    $(+ self.$poname.space())*)
+                    $(+ {$(#[cfg(feature = $pocfg)])? self.$poname.space()})*)
                     .set_total::<Self>()
                 }
             }
@@ -226,7 +226,7 @@ macro_rules! format_family {
             fn space(&self) -> mzcore::space::UsedSpace {
                 ( mzcore::space::UsedSpace::default()
                 $(+ self.$rname.space())*
-                $(+ self.$oname.space())*)
+                $(+ {$(#[cfg(feature = $ocfg)])? self.$oname.space()})*)
                 .set_total::<Self>()
             }
         }

mzident/src/formats/fasta.rs

@@ -1367,23 +1367,23 @@ impl ProteinMetaData for FastaData {
     }
 
     fn species(&self) -> Option<mzcv::Curie> {
-        todo!()
+        None // TODO: Maybe look at the header to see if this can be filled
     }
 
     fn species_name(&self) -> Option<&str> {
-        todo!()
+        None
     }
 
     fn search_engine(&self) -> &[(super::CVTerm, Option<(f64, super::CVTerm)>)] {
-        todo!()
+        &[]
     }
 
     fn ambiguity_members(&self) -> &[String] {
-        todo!()
+        &[]
     }
 
     fn database(&self) -> Option<(&str, Option<&str>)> {
-        todo!()
+        None
     }
 
     fn modifications(
@@ -1392,23 +1392,23 @@ impl ProteinMetaData for FastaData {
         Vec<(mzcore::prelude::SequencePosition, Option<f64>)>,
         mzcore::sequence::SimpleModification,
     )] {
-        todo!()
+        &[]
     }
 
     fn coverage(&self) -> Option<f64> {
-        todo!()
+        None
     }
 
     fn gene_ontology(&self) -> &[mzcv::Curie] {
-        todo!()
+        &[]
     }
 
     fn reliability(&self) -> Option<super::Reliability> {
-        todo!()
+        None
     }
 
     fn uri(&self) -> Option<&str> {
-        todo!()
+        None
     }
 }