opensmiles 0.1.3

A SMILES parser following the OpenSMILES specification
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

//! Node-related errors (atoms in the molecular graph).

use thiserror::Error;

use crate::AtomSymbol;

use super::AtomError;

/// Errors that can occur when creating or manipulating a node.
#[derive(Debug, Clone, PartialEq, Error)]
pub enum NodeError {
    /// The specified hydrogen count is invalid.
    #[error("invalid hydrogen count: {0}")]
    InvalidHydrogen(u8),

    /// The hydrogen count was not defined when required.
    #[error("undefined hydrogen count")]
    UndefinedHydrogen,

    #[error("Invalid element {0} cannot be aromatic")]
    InvalidAromaticElement(AtomSymbol),

    /// The specified atom class is invalid.
    #[error("invalid atom class: {0}")]
    InvalidClass(u16),

    /// Aromaticity was not defined when required.
    #[error("undefined aromaticity")]
    UndefinedAromatic,

    /// Bond order is mandatory for organic atoms.
    #[error("bond order is mandatory for organic atoms")]
    BondOrderMandatoryForOrganicAtom,

    /// Error from the underlying atom.
    #[error(transparent)]
    AtomError(#[from] AtomError),
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn error_messages_are_descriptive() {
        assert_eq!(
            NodeError::InvalidHydrogen(10).to_string(),
            "invalid hydrogen count: 10"
        );

        assert_eq!(
            NodeError::UndefinedHydrogen.to_string(),
            "undefined hydrogen count"
        );

        assert_eq!(
            NodeError::InvalidClass(65535).to_string(),
            "invalid atom class: 65535"
        );

        assert_eq!(
            NodeError::UndefinedAromatic.to_string(),
            "undefined aromaticity"
        );

        assert_eq!(
            NodeError::BondOrderMandatoryForOrganicAtom.to_string(),
            "bond order is mandatory for organic atoms"
        );
    }

    #[test]
    fn atom_error_conversion() {
        let atom_err = AtomError::InvalidCharge(20);
        let node_err: NodeError = atom_err.into();

        assert!(matches!(node_err, NodeError::AtomError(_)));
        assert_eq!(
            node_err.to_string(),
            "invalid charge: 20 (must be between -15 and +15)"
        );
    }
}