rusteal-core 0.6.0

Safe Rust runtime for rusteal (object refs, lifecycle, dynamic calls)
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

use std::fmt;

use rusteal_ffi::RustealErrorCode;

#[derive(Debug)]
pub enum RustealError {
    ObjectDestroyed,
    InvalidCast,
    PropertyNotFound(String),
    FunctionNotFound(String),
    TypeMismatch,
    NullArgument,
    IndexOutOfRange,
    InvalidOperation(String),
    Internal(String),
    BufferTooSmall,
}

impl fmt::Display for RustealError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            RustealError::ObjectDestroyed => write!(f, "object has been destroyed"),
            RustealError::InvalidCast => write!(f, "invalid cast"),
            RustealError::PropertyNotFound(name) => write!(f, "property not found: {name}"),
            RustealError::FunctionNotFound(name) => write!(f, "function not found: {name}"),
            RustealError::TypeMismatch => write!(f, "type mismatch"),
            RustealError::NullArgument => write!(f, "null argument"),
            RustealError::IndexOutOfRange => write!(f, "index out of range"),
            RustealError::InvalidOperation(msg) => write!(f, "invalid operation: {msg}"),
            RustealError::Internal(msg) => write!(f, "internal error: {msg}"),
            RustealError::BufferTooSmall => write!(f, "buffer too small"),
        }
    }
}

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

pub type RustealResult<T> = Result<T, RustealError>;

pub fn check_ffi(code: RustealErrorCode) -> RustealResult<()> {
    match code {
        RustealErrorCode::Ok => Ok(()),
        other => Err(RustealError::from(other)),
    }
}

pub fn check_ffi_ctx(code: RustealErrorCode, context: &str) -> RustealResult<()> {
    match code {
        RustealErrorCode::Ok => Ok(()),
        RustealErrorCode::PropertyNotFound => Err(RustealError::PropertyNotFound(context.into())),
        RustealErrorCode::FunctionNotFound => Err(RustealError::FunctionNotFound(context.into())),
        RustealErrorCode::InvalidOperation => Err(RustealError::InvalidOperation(context.into())),
        other => Err(RustealError::from(other)),
    }
}

#[inline(always)]
pub fn ffi_infallible(code: RustealErrorCode) {
    debug_assert_eq!(
        code,
        RustealErrorCode::Ok,
        "FFI call returned {code:?} after pre-validation"
    );
}

#[inline(always)]
pub fn ffi_infallible_ctx(code: RustealErrorCode, ctx: &str) {
    debug_assert_eq!(
        code,
        RustealErrorCode::Ok,
        "FFI '{ctx}' returned {code:?} after pre-validation"
    );
}

impl From<RustealErrorCode> for RustealError {
    #[allow(clippy::match_same_arms)]
    fn from(code: RustealErrorCode) -> Self {
        match code {
            RustealErrorCode::Ok => RustealError::Internal("unexpected Ok error code".into()),
            RustealErrorCode::ObjectDestroyed => RustealError::ObjectDestroyed,
            RustealErrorCode::InvalidCast => RustealError::InvalidCast,
            RustealErrorCode::PropertyNotFound => RustealError::PropertyNotFound(String::new()),
            RustealErrorCode::FunctionNotFound => RustealError::FunctionNotFound(String::new()),
            RustealErrorCode::TypeMismatch => RustealError::TypeMismatch,
            RustealErrorCode::NullArgument => RustealError::NullArgument,
            RustealErrorCode::IndexOutOfRange => RustealError::IndexOutOfRange,
            RustealErrorCode::InvalidOperation => RustealError::InvalidOperation(String::new()),
            RustealErrorCode::InternalError => RustealError::Internal(String::new()),
            RustealErrorCode::BufferTooSmall => RustealError::BufferTooSmall,
        }
    }
}

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

    #[test]
    fn check_ffi_ok_returns_ok() {
        assert!(check_ffi(RustealErrorCode::Ok).is_ok());
    }

    #[test]
    fn check_ffi_errors_map_correctly() {
        let cases = [
            (RustealErrorCode::ObjectDestroyed, "ObjectDestroyed"),
            (RustealErrorCode::InvalidCast, "InvalidCast"),
            (RustealErrorCode::PropertyNotFound, "PropertyNotFound"),
            (RustealErrorCode::FunctionNotFound, "FunctionNotFound"),
            (RustealErrorCode::TypeMismatch, "TypeMismatch"),
            (RustealErrorCode::NullArgument, "NullArgument"),
            (RustealErrorCode::IndexOutOfRange, "IndexOutOfRange"),
            (RustealErrorCode::InvalidOperation, "InvalidOperation"),
            (RustealErrorCode::InternalError, "Internal"),
        ];

        for (code, expected_variant) in cases {
            let err = check_ffi(code).unwrap_err();
            let debug = format!("{err:?}");

            assert!(
                debug.starts_with(expected_variant),
                "expected {expected_variant}, got {debug}"
            );
        }
    }

    #[test]
    fn display_formats_are_human_readable() {
        let err = RustealError::PropertyNotFound("Health".into());
        assert_eq!(err.to_string(), "property not found: Health");
    }
}