balsa 0.3.2

Reference implementation for the Balsa molecular line notation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use std::{fmt, fmt::Write};

use super::{AtomParity, Charge, Isotope, Symbol, VirtualHydrogen};

#[derive(Debug, PartialEq, Clone, Default)]
pub struct Bracket {
    pub symbol: Symbol,
    pub isotope: Option<Isotope>,
    pub parity: Option<AtomParity>,
    pub hydrogens: Option<VirtualHydrogen>,
    pub charge: Option<Charge>,
}

impl Bracket {
    pub fn hydrogens(&self) -> u8 {
        match &self.hydrogens {
            Some(hydrogens) => hydrogens.into(),
            None => 0,
        }
    }
}

impl fmt::Display for Bracket {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_char('[')?;

        if let Some(isotope) = &self.isotope {
            isotope.fmt(f)?
        }

        self.symbol.fmt(f)?;

        if let Some(parity) = &self.parity {
            parity.fmt(f)?
        }

        if let Some(hydrogens) = &self.hydrogens {
            hydrogens.fmt(f)?
        }

        if let Some(charge) = &self.charge {
            charge.fmt(f)?
        }

        f.write_char(']')
    }
}

#[cfg(test)]
mod hydrogens {
    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn none() {
        let bracket = Bracket {
            ..Default::default()
        };

        assert_eq!(bracket.hydrogens(), 0)
    }

    #[test]
    fn some() {
        let bracket = Bracket {
            hydrogens: Some(VirtualHydrogen::H2),
            ..Default::default()
        };

        assert_eq!(bracket.hydrogens(), 2)
    }
}

#[cfg(test)]
mod to_string {
    use crate::feature::Element;
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn kitchen_sink() {
        let bracket = Bracket {
            symbol: Symbol::Element(Element::C),
            isotope: Some(Isotope::new(13).unwrap()),
            parity: Some(AtomParity::Counterclockwise),
            hydrogens: Some(VirtualHydrogen::H),
            charge: Some(Charge::Plus),
        };

        assert_eq!(bracket.to_string(), "[13C@H+]")
    }
}