ripht-php-sapi 0.1.0-rc.9

Ripht PHP SAPI - A PHP SAPI written in Rust to expose safe and convenient APIs to encourage additional Rust tooling development for PHP
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

/// PHP error severity levels (maps to syslog priorities).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SyslogLevel {
    Emergency = 0,
    Alert = 1,
    Critical = 2,
    Error = 3,
    Warning = 4,
    Notice = 5,
    Info = 6,
    Debug = 7,
}

impl SyslogLevel {
    pub fn from_raw(level: i32) -> Self {
        match level {
            0 => Self::Emergency,
            1 => Self::Alert,
            2 => Self::Critical,
            3 => Self::Error,
            4 => Self::Warning,
            5 => Self::Notice,
            6 => Self::Info,
            7 => Self::Debug,
            _ if level < 0 => Self::Emergency,
            _ => Self::Debug,
        }
    }

    pub fn is_error_or_worse(&self) -> bool {
        matches!(
            self,
            Self::Emergency | Self::Alert | Self::Critical | Self::Error
        )
    }

    pub fn is_warning_or_worse(&self) -> bool {
        self.is_error_or_worse() || matches!(self, Self::Warning)
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Emergency => "emerg",
            Self::Alert => "alert",
            Self::Critical => "crit",
            Self::Error => "err",
            Self::Warning => "warning",
            Self::Notice => "notice",
            Self::Info => "info",
            Self::Debug => "debug",
        }
    }
}

impl std::fmt::Display for SyslogLevel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl From<i32> for SyslogLevel {
    fn from(level: i32) -> Self {
        Self::from_raw(level)
    }
}

impl From<SyslogLevel> for i32 {
    fn from(level: SyslogLevel) -> Self {
        level as i32
    }
}

/// A PHP error, warning, or notice captured during execution.
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct ExecutionMessage {
    pub message: String,
    pub level: SyslogLevel,
}

impl ExecutionMessage {
    pub fn new(level: SyslogLevel, message: impl Into<String>) -> Self {
        Self {
            message: message.into(),
            level,
        }
    }

    pub fn from_syslog(syslog_level: i32, message: impl Into<String>) -> Self {
        Self::new(SyslogLevel::from_raw(syslog_level), message)
    }

    pub fn is_error(&self) -> bool {
        self.level.is_error_or_worse()
    }

    pub fn is_warning(&self) -> bool {
        matches!(self.level, SyslogLevel::Warning)
    }

    pub fn is_warning_or_worse(&self) -> bool {
        self.level
            .is_warning_or_worse()
    }
}

impl std::fmt::Display for ExecutionMessage {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "[{}] {}", self.level, self.message)
    }
}