codama_attributes/codama_directives/
error_directive.rs

1use crate::{
2    utils::{FromMeta, SetOnce},
3    Attribute, CodamaAttribute, CodamaDirective,
4};
5use codama_errors::CodamaError;
6use codama_syn_helpers::{extensions::*, Meta};
7
8#[derive(Debug, PartialEq, Default, Clone)]
9pub struct ErrorDirective {
10    pub code: Option<usize>,
11    pub message: Option<String>,
12}
13
14impl ErrorDirective {
15    pub fn is_empty(&self) -> bool {
16        self.code.is_none() && self.message.is_none()
17    }
18}
19
20impl ErrorDirective {
21    pub fn parse(meta: &Meta) -> syn::Result<Self> {
22        let pl = meta.assert_directive("error")?.as_path_list()?;
23        let mut code = SetOnce::<usize>::new("code");
24        let mut message = SetOnce::<String>::new("message");
25        pl.each(|ref meta| match (meta.path_str().as_str(), meta) {
26            ("code", _) => code.set(usize::from_meta(meta)?, meta),
27            ("message", _) => message.set(String::from_meta(meta)?, meta),
28            (_, Meta::Expr(expr)) => {
29                if let Ok(value) = expr.as_unsigned_integer() {
30                    code.set(value, meta)
31                } else if let Ok(value) = expr.as_string() {
32                    message.set(value, meta)
33                } else {
34                    Err(expr.error("expected an integer or a string"))
35                }
36            }
37            _ => Err(meta.error("unrecognized attribute")),
38        })?;
39        let directive = Self {
40            code: code.option(),
41            message: message.option(),
42        };
43        if directive.is_empty() {
44            return Err(pl.error("expected at least one `code` or `message` attribute"));
45        }
46        Ok(directive)
47    }
48}
49
50impl<'a> TryFrom<&'a CodamaAttribute<'a>> for &'a ErrorDirective {
51    type Error = CodamaError;
52
53    fn try_from(attribute: &'a CodamaAttribute) -> Result<Self, Self::Error> {
54        match attribute.directive {
55            CodamaDirective::Error(ref a) => Ok(a),
56            _ => Err(CodamaError::InvalidCodamaDirective {
57                expected: "error".to_string(),
58                actual: attribute.directive.name().to_string(),
59            }),
60        }
61    }
62}
63
64impl<'a> TryFrom<&'a Attribute<'a>> for &'a ErrorDirective {
65    type Error = CodamaError;
66
67    fn try_from(attribute: &'a Attribute) -> Result<Self, Self::Error> {
68        <&CodamaAttribute>::try_from(attribute)?.try_into()
69    }
70}
71
72#[cfg(test)]
73mod tests {
74    use super::*;
75
76    #[test]
77    fn ok() {
78        let meta: Meta = syn::parse_quote! { error(42, "my message") };
79        let directive = ErrorDirective::parse(&meta).unwrap();
80        assert_eq!(
81            directive,
82            ErrorDirective {
83                code: Some(42),
84                message: Some("my message".to_string()),
85            }
86        );
87    }
88
89    #[test]
90    fn ok_with_explicit_labels() {
91        let meta: Meta = syn::parse_quote! { error(code = 42, message = "my message") };
92        let directive = ErrorDirective::parse(&meta).unwrap();
93        assert_eq!(
94            directive,
95            ErrorDirective {
96                code: Some(42),
97                message: Some("my message".to_string()),
98            }
99        );
100    }
101
102    #[test]
103    fn fail_if_nothing_is_provided() {
104        let meta: Meta = syn::parse_quote! { error() };
105        let error = ErrorDirective::parse(&meta).unwrap_err();
106        assert_eq!(
107            error.to_string(),
108            "expected at least one `code` or `message` attribute"
109        );
110    }
111}
codama_attributes/codama_directives/error_directive.rs

codama_attributes/codama_directives/
error_directive.rs
