wdl-core 0.2.0

Common functionality for the `wdl` family of crates
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Codes for validation failures and lint warnings.

use std::num::NonZeroUsize;

use crate::Version;

mod kind;

pub use kind::Kind;
use serde::Deserialize;
use serde::Serialize;

/// An error related to a [`Code`].
#[derive(Debug)]
pub enum Error {
    /// Attempted to make a code with an invalid index.
    InvalidIndex(usize),
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::InvalidIndex(index) => write!(f, "invalid index: {index}"),
        }
    }
}

impl std::error::Error for Error {}

/// A [`Result`](std::result::Result) with an [`Error`].
type Result<T> = std::result::Result<T, Error>;

/// A code.
#[derive(Clone, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
pub struct Code {
    /// The kind of code.
    kind: Kind,

    /// The grammar for this code.
    grammar: Version,

    /// The index for this code.
    index: NonZeroUsize,
}

impl Code {
    /// Attempts to create a new [`Code`].
    ///
    /// # Examples
    ///
    /// ```
    /// use wdl_core::concern::code::Kind;
    /// use wdl_core::concern::Code;
    /// use wdl_core::Version;
    ///
    /// let code = Code::try_new(Kind::Warning, Version::V1, 1)?;
    /// assert_eq!(code.kind(), &Kind::Warning);
    /// assert_eq!(code.grammar(), &Version::V1);
    /// assert_eq!(code.index().get(), 1);
    ///
    /// # Ok::<(), Box<dyn std::error::Error>>(())
    /// ```
    pub fn try_new(kind: Kind, grammar: Version, index: usize) -> Result<Self> {
        let index = NonZeroUsize::try_from(index).map_err(|_| Error::InvalidIndex(index))?;

        Ok(Self {
            kind,
            grammar,
            index,
        })
    }

    /// Gets the [`Kind`] of concern for this [`Code`] by reference.
    ///
    /// # Examples
    ///
    /// ```
    /// use wdl_core::concern::code::Kind;
    /// use wdl_core::concern::Code;
    /// use wdl_core::Version;
    ///
    /// let code = Code::try_new(Kind::Warning, Version::V1, 1)?;
    /// assert_eq!(code.kind(), &Kind::Warning);
    ///
    /// # Ok::<(), Box<dyn std::error::Error>>(())
    /// ```
    pub fn kind(&self) -> &Kind {
        &self.kind
    }

    /// Gets the grammar [`Version`] for this [`Code`] by reference.
    ///
    /// # Examples
    ///
    /// ```
    /// use wdl_core::concern::code::Kind;
    /// use wdl_core::concern::Code;
    /// use wdl_core::Version;
    ///
    /// let code = Code::try_new(Kind::Warning, Version::V1, 1)?;
    /// assert_eq!(code.grammar(), &Version::V1);
    ///
    /// # Ok::<(), Box<dyn std::error::Error>>(())
    /// ```
    pub fn grammar(&self) -> &Version {
        &self.grammar
    }

    /// Gets the index of this [`Code`] by reference.
    ///
    /// # Examples
    ///
    /// ```
    /// use wdl_core::concern::code::Kind;
    /// use wdl_core::concern::Code;
    /// use wdl_core::Version;
    ///
    /// let code = Code::try_new(Kind::Warning, Version::V1, 1)?;
    /// assert_eq!(code.index().get(), 1);
    ///
    /// # Ok::<(), Box<dyn std::error::Error>>(())
    /// ```
    pub fn index(&self) -> NonZeroUsize {
        self.index
    }
}

impl std::fmt::Display for Code {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}::{}{:03}",
            self.grammar.short_name(),
            self.kind.prefix(),
            self.index
        )
    }
}

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

    #[test]
    fn zero_index() {
        let err = Code::try_new(Kind::Error, Version::V1, 0).unwrap_err();
        assert!(matches!(err, Error::InvalidIndex(0)));
    }

    #[test]
    fn display() {
        let identity = Code::try_new(Kind::Error, Version::V1, 1).unwrap();
        assert_eq!(identity.to_string(), String::from("v1::E001"));

        let identity = Code::try_new(Kind::Warning, Version::V1, 1).unwrap();
        assert_eq!(identity.to_string(), String::from("v1::W001"));
    }
}