pinar 0.1.0

Library to write node native modules with N-API
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

use crate::status::Status;
use failure::{Fail, Backtrace};

#[derive(Debug)]
pub struct Error {
    cause: Box<JsError>,
    backtrace: Option<Backtrace>
}

impl Error {
    pub fn as_js_error(&self) -> &JsError {
        self.cause.as_ref()
    }

    pub fn backtrace(&self) -> &Backtrace {
        match self.cause.backtrace() {
            Some(bt) => bt,
            _ => self.backtrace.as_ref().unwrap()
        }
    }

    pub fn downcast_ref<T: Fail>(&self) -> Option<&T> {
        Fail::downcast_ref(self.cause.as_fail())
    }

    pub fn is_type<T: Fail>(&self) -> bool {
        self.downcast_ref::<T>().is_some()
    }
}

#[derive(Fail, Debug)]
#[fail(display = "Null pointer on external data")]
pub struct JsExternalError;

#[derive(Fail, Debug)]
pub enum JsClassError {
    #[fail(display = "Fail to extract external value from class. Please report on pinar repo.")]
    ExternalClassData,
    #[fail(display = "Wrong handler class. Please report on pinar repo.")]
    WrongHandler,
    #[fail(display = "A class method has been called with the wrong class. Check your JS !")]
    WrongClass,
    #[fail(display = "Wrong 'this' value. Did you call the constructor with 'new' ? (ex: 'let a = new {}()')", _0)]
    ThisConstructor(&'static str),
    #[fail(display = "Wrong 'this' value on a method call of the class {}", _0)]
    ThisMethod(&'static str),
    #[fail(display = "Fail to unwrap the class. Please report on pinar repo.")]
    Unwrap,
}

#[derive(Fail, Debug)]
pub enum JsFunctionError {
    #[fail(display = "Multiple overload of the function {} failed.", _0)]
    ArgumentsOverload(String),
//    #[fail(display = "{{ function {} }}: {}.", _0, _1)]
//    Arguments(String, String),
    #[fail(display = "Fail to dispatch the function, please report on pinar repo.")]
    WrongFunctionData,
}

#[derive(Fail, Debug, Clone)]
pub enum ArgumentsError {
    #[fail(display = "{}th argument is missing", _0)]
    Missing(usize),
    #[fail(display = "Wrong type, expected a {} on the {}th argument", _0, _1)]
    WrongType(String, usize),
    #[fail(display = "Deserialization error: {}", _0)]
    Deserialization(String)
}

impl ArgumentsError {
    pub fn wrong_type(s: &str, n: usize) -> Error {
        ArgumentsError::WrongType(s.to_owned(), n).into()
    }

    pub fn missing(n: usize) -> Error {
        ArgumentsError::Missing(n).into()
    }
}

impl<T: JsError> From<T> for Error {
    fn from(error: T) -> Error {
        Error {
            backtrace: match error.backtrace() {
                None => Some(Backtrace::new()),
                _ => None
            },
            cause: Box::new(error)
        }
    }
}

pub trait JsError: Fail + JsErrorAsFail {
    fn get_msg(&self) -> String {
        format!("{}", self)
    }
    fn get_code(&self) -> Option<String> {
        None
    }
}

pub trait JsErrorAsFail {
    fn as_fail(&self) -> &Fail;
}

impl<T: JsError> JsErrorAsFail for T {
    fn as_fail(&self) -> &Fail {
        self
    }
}

impl JsError for Status {
    fn get_code(&self) -> Option<String> {
        Some("N-API".to_owned())
    }
}

impl JsError for ArgumentsError {
    fn get_code(&self) -> Option<String> {
        Some("PINAR".to_owned())
    }
}

impl JsError for JsExternalError {
    fn get_code(&self) -> Option<String> {
        Some("PINAR".to_owned())
    }
}

impl JsError for JsClassError {
    fn get_code(&self) -> Option<String> {
        Some("PINAR".to_owned())
    }
}

impl JsError for JsFunctionError {
    fn get_code(&self) -> Option<String> {
        Some("PINAR".to_owned())
    }
}

impl JsError for std::io::Error {
    fn get_code(&self) -> Option<String> {
        Some("IO".to_owned())
    }
}