ockam_abac 0.80.0

Attribute based authorization control
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

use crate::expr::Expr;
use core::fmt;
use core::num::{ParseFloatError, ParseIntError};
use core::str::Utf8Error;
use ockam_core::compat::string::{String, ToString};
use ockam_core::errcode::{Kind, Origin};

#[derive(Debug)]
pub enum ParseError {
    Utf8(Utf8Error),
    Int(ParseIntError),
    Float(ParseFloatError),
    Other(String),
    Message(String),
    TypeMismatch(Expr, Expr),
}

#[derive(Debug)]
pub enum EvalError {
    Unbound(String),
    Unknown(String),
    InvalidType(Expr, &'static str),
    TypeMismatch(Expr, Expr),
    Malformed(String),
}

#[derive(Debug)]
pub enum MergeError {
    BindingExists(String),
}

impl ParseError {
    pub fn message<S: Into<String>>(s: S) -> Self {
        ParseError::Message(s.into())
    }
}

impl EvalError {
    pub fn malformed<S: Into<String>>(s: S) -> Self {
        EvalError::Malformed(s.into())
    }

    pub fn is_unbound(&self) -> bool {
        matches!(self, EvalError::Unbound(_))
    }
}

impl From<Utf8Error> for ParseError {
    #[track_caller]
    fn from(e: Utf8Error) -> Self {
        Self::Utf8(e)
    }
}

impl From<ParseIntError> for ParseError {
    #[track_caller]
    fn from(e: ParseIntError) -> Self {
        Self::Int(e)
    }
}

impl From<ParseFloatError> for ParseError {
    #[track_caller]
    fn from(e: ParseFloatError) -> Self {
        Self::Float(e)
    }
}

#[cfg(feature = "std")]
impl From<wast::Error> for ParseError {
    #[track_caller]
    fn from(e: wast::Error) -> Self {
        Self::Other(format!("{e:?}"))
    }
}

impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ParseError::Other(e) => write!(f, "{e}"),
            ParseError::Float(e) => write!(f, "{e}"),
            ParseError::Int(e) => write!(f, "{e}"),
            ParseError::Utf8(e) => write!(f, "{e}"),
            ParseError::Message(m) => f.write_str(m),
            ParseError::TypeMismatch(a, b) => write!(f, "{a} and {b} are not of the same type"),
        }
    }
}

impl fmt::Display for EvalError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            EvalError::Unbound(id) => write!(f, "unbound identifier: {id}"),
            EvalError::Unknown(id) => write!(f, "unknown operator: {id}"),
            EvalError::InvalidType(e, m) => write!(f, "invalid type of expression {e}: {m}"),
            EvalError::Malformed(m) => write!(f, "malformed expression: {m}"),
            EvalError::TypeMismatch(a, b) => write!(f, "{a} and {b} are not of the same type"),
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for ParseError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            ParseError::Float(e) => Some(e),
            ParseError::Int(e) => Some(e),
            ParseError::Utf8(e) => Some(e),
            ParseError::Other(_) => None,
            ParseError::Message(_) => None,
            ParseError::TypeMismatch(..) => None,
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for EvalError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        None
    }
}

impl From<ParseError> for ockam_core::Error {
    #[track_caller]
    fn from(e: ParseError) -> Self {
        ockam_core::Error::new(Origin::Application, Kind::Parse, e.to_string())
    }
}

impl From<EvalError> for ockam_core::Error {
    #[track_caller]
    fn from(e: EvalError) -> Self {
        ockam_core::Error::new(Origin::Application, Kind::Invalid, e.to_string())
    }
}