ionic-rs 0.2.1

Streamable binary format for mass-spectrometry data: lossless mzML conversion, random access, WebAssembly support
Documentation
use crate::{
    ion::{
        attr_meta::*,
        decoder::decode::{Metadatum, MetadatumValue},
        utilities::assign_attributes,
    },
    mzml::{
        schema::TagId,
        structs::{Chromatogram, Spectrum},
    },
};

fn parse_accession(tail: AccessionTail) -> String {
    format!("{CV_REF_ATTR}:{:07}", tail.raw())
}

fn find_by_tail(xs: &[Metadatum], tail: AccessionTail) -> Option<&Metadatum> {
    let acc = parse_accession(tail);
    xs.iter()
        .find(|m| m.accession.as_deref() == Some(acc.as_str()))
}

fn assert_has_attr_tail(xs: &[Metadatum], tail: AccessionTail) {
    let acc = parse_accession(tail);
    assert!(
        xs.iter()
            .any(|m| m.accession.as_deref() == Some(acc.as_str())),
        "expected generated meta to contain {acc}"
    );
}

fn assert_missing_attr_tail(xs: &[Metadatum], tail: AccessionTail) {
    let acc = parse_accession(tail);
    assert!(
        xs.iter()
            .all(|m| m.accession.as_deref() != Some(acc.as_str())),
        "expected generated meta to NOT contain {acc}"
    );
}

fn assert_text(xs: &[Metadatum], tail: AccessionTail, s: &str) {
    let m = find_by_tail(xs, tail).unwrap_or_else(|| panic!("missing tail={:?}", tail));
    assert_eq!(m.value, MetadatumValue::Text(s.to_string()));
}

fn assert_num(xs: &[Metadatum], tail: AccessionTail, n: f64) {
    let m = find_by_tail(xs, tail).unwrap_or_else(|| panic!("missing tail={:?}", tail));
    assert_eq!(m.value, MetadatumValue::Number(n));
}

#[test]
fn assign_attrs_spectrum_emits_all_fields() {
    let s = Spectrum {
        id: "scan=1".to_string(),
        index: Some(0),
        default_array_length: Some(340032),
        native_id: Some("controllerType=0 controllerNumber=1 scan=1".to_string()),
        data_processing_ref: Some("dp1".to_string()),
        source_file_ref: Some("sf1".to_string()),
        spot_id: Some("spotA".to_string()),
        ms_level: Some(2),
        ..Default::default()
    };

    let id = 1u32;
    let parent_index = 0u32;

    let out = assign_attributes(&s, TagId::Spectrum, id, parent_index);

    assert_has_attr_tail(&out, ACC_ATTR_ID);
    assert_has_attr_tail(&out, ACC_ATTR_INDEX);
    assert_has_attr_tail(&out, ACC_ATTR_DEFAULT_ARRAY_LENGTH);
    assert_has_attr_tail(&out, ACC_ATTR_NATIVE_ID);
    assert_has_attr_tail(&out, ACC_ATTR_DATA_PROCESSING_REF);
    assert_has_attr_tail(&out, ACC_ATTR_SOURCE_FILE_REF);
    assert_has_attr_tail(&out, ACC_ATTR_SPOT_ID);

    assert_text(&out, ACC_ATTR_ID, "scan=1");
    assert_num(&out, ACC_ATTR_INDEX, 0.0);
    assert_num(&out, ACC_ATTR_DEFAULT_ARRAY_LENGTH, 340032.0);
    assert_text(
        &out,
        ACC_ATTR_NATIVE_ID,
        "controllerType=0 controllerNumber=1 scan=1",
    );
    assert_text(&out, ACC_ATTR_DATA_PROCESSING_REF, "dp1");
    assert_text(&out, ACC_ATTR_SOURCE_FILE_REF, "sf1");
    assert_text(&out, ACC_ATTR_SPOT_ID, "spotA");

    assert_missing_attr_tail(&out, ACC_ATTR_SCAN_NUMBER);
    assert_has_attr_tail(&out, ACC_ATTR_MS_LEVEL);
    assert_num(&out, ACC_ATTR_MS_LEVEL, 2.0);
}

#[test]
fn assign_attrs_emits_only_parse_accessions() {
    let s = Spectrum::default();

    let id = 1u32;
    let parent_index = 0u32;

    let out = assign_attributes(&s, TagId::Spectrum, id, parent_index);
    assert_has_attr_tail(&out, ACC_ATTR_ID);
    assert_text(&out, ACC_ATTR_ID, "");
    assert_missing_attr_tail(&out, ACC_ATTR_INDEX);
    assert_missing_attr_tail(&out, ACC_ATTR_DEFAULT_ARRAY_LENGTH);
    assert_missing_attr_tail(&out, ACC_ATTR_NATIVE_ID);
    assert!(out.iter().all(|m| {
        m.accession
            .as_deref()
            .map(|a| a.starts_with(CV_REF_ATTR))
            .unwrap_or(false)
    }));
}

#[test]
fn assign_attrs_spectrum_id_is_preserved() {
    let s = Spectrum {
        id: "ok".to_string(),
        ..Default::default()
    };

    let id = 1u32;
    let parent_index = 0u32;

    let out = assign_attributes(&s, TagId::Spectrum, id, parent_index);

    assert_has_attr_tail(&out, ACC_ATTR_ID);
    assert_text(&out, ACC_ATTR_ID, "ok");
}

#[test]
fn assign_attrs_chromatogram_emits_schema_attr_only() {
    let c = Chromatogram {
        id: "TIC".to_string(),
        index: Some(0),
        default_array_length: Some(3476),
        native_id: Some("nativeX".to_string()),
        data_processing_ref: Some("dpX".to_string()),
        ..Default::default()
    };

    let id = 7u32;
    let parent_index = 0u32;

    let out = assign_attributes(&c, TagId::Chromatogram, id, parent_index);

    assert_has_attr_tail(&out, ACC_ATTR_ID);
    assert_has_attr_tail(&out, ACC_ATTR_INDEX);
    assert_has_attr_tail(&out, ACC_ATTR_DEFAULT_ARRAY_LENGTH);
    assert_has_attr_tail(&out, ACC_ATTR_NATIVE_ID);
    assert_has_attr_tail(&out, ACC_ATTR_DATA_PROCESSING_REF);

    assert_text(&out, ACC_ATTR_ID, "TIC");
    assert_num(&out, ACC_ATTR_INDEX, 0.0);
    assert_num(&out, ACC_ATTR_DEFAULT_ARRAY_LENGTH, 3476.0);
    assert_text(&out, ACC_ATTR_NATIVE_ID, "nativeX");
    assert_text(&out, ACC_ATTR_DATA_PROCESSING_REF, "dpX");
}