atelier_smithy 0.2.11

Rust native Smithy language format for the AWS Smithy IDL.
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

use atelier_core::error::{Error as CoreError, ErrorKind, Result as CoreResult};
use pest::iterators::Pair;
use pest::RuleType;
use std::fmt::{Debug, Display};

// ------------------------------------------------------------------------------------------------
// Public Types
// ------------------------------------------------------------------------------------------------

#[derive(Debug, Clone)]
pub(crate) struct ParserError {
    fn_name: String,
    rule: Option<String>,
    expecting: Option<String>,
    unreachable: bool,
    context: Option<String>,
}

// ------------------------------------------------------------------------------------------------
// Implementations
// ------------------------------------------------------------------------------------------------

impl From<ParserError> for CoreError {
    fn from(e: ParserError) -> Self {
        ErrorKind::Deserialization(
            "Smithy".to_string(),
            format!(
                "{}{}{}{}",
                e.fn_name,
                match e.rule {
                    None => String::new(),
                    Some(s) => format!(" ({})", s),
                },
                match e.expecting {
                    None => String::new(),
                    Some(s) => format!(" expecting {}", s),
                },
                if e.unreachable {
                    " should have been unreachable".to_string()
                } else {
                    String::new()
                },
            ),
            e.context,
        )
        .into()
    }
}

impl<T> From<ParserError> for CoreResult<T> {
    fn from(e: ParserError) -> Self {
        Err(e.into())
    }
}

impl<T> From<&mut ParserError> for CoreResult<T> {
    fn from(e: &mut ParserError) -> Self {
        Err(e.clone().into())
    }
}

#[allow(dead_code)]
impl ParserError {
    pub(crate) fn new(fn_name: &str) -> Self {
        Self {
            fn_name: fn_name.to_string(),
            rule: None,
            expecting: None,
            unreachable: false,
            context: None,
        }
    }

    pub(crate) fn unreachable(fn_name: &str) -> Self {
        Self {
            fn_name: fn_name.to_string(),
            rule: None,
            expecting: None,
            unreachable: true,
            context: None,
        }
    }

    pub(crate) fn unexpected<T: RuleType>(fn_name: &str, pair: &Pair<'_, T>) -> Self {
        Self {
            fn_name: fn_name.to_string(),
            rule: None,
            expecting: None,
            unreachable: true,
            context: Some(format!("{:?}: {:?}", pair.as_rule(), pair.as_str())),
        }
    }

    pub(crate) fn in_rule(&mut self, rule: &str) -> &mut Self {
        self.rule = Some(rule.to_string());
        self
    }

    pub(crate) fn expecting(&mut self, expecting: &str) -> &mut Self {
        self.expecting = Some(expecting.to_string());
        self
    }

    pub(crate) fn unreachable_rule(&mut self) -> &mut Self {
        self.unreachable = true;
        self
    }

    pub(crate) fn context(&mut self, context: &dyn Display) -> &mut Self {
        self.context = Some(format!("{}", context));
        self
    }

    pub(crate) fn debug_context(&mut self, context: &dyn Debug) -> &mut Self {
        self.context = Some(format!("{:?}", context));
        self
    }
}