use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Category {
Usage,
Validation,
Config,
Network,
Authentication,
Permission,
Absence,
Conflict,
Timeout,
Server,
Limit,
Interrupted,
ChannelClosed,
}
impl Category {
pub const ALL: [Self; 13] = [
Self::Usage,
Self::Validation,
Self::Config,
Self::Network,
Self::Authentication,
Self::Permission,
Self::Absence,
Self::Conflict,
Self::Timeout,
Self::Server,
Self::Limit,
Self::Interrupted,
Self::ChannelClosed,
];
#[must_use]
pub const fn exit_number(self) -> ExitNumber {
match self {
Self::Usage => ExitNumber::Usage,
Self::Validation => ExitNumber::Validation,
Self::Config => ExitNumber::Config,
Self::Network => ExitNumber::Network,
Self::Authentication => ExitNumber::Authentication,
Self::Permission => ExitNumber::Permission,
Self::Absence => ExitNumber::Absence,
Self::Conflict => ExitNumber::Conflict,
Self::Limit => ExitNumber::Limit,
Self::Server => ExitNumber::Server,
Self::Timeout => ExitNumber::Timeout,
Self::Interrupted => ExitNumber::Interrupted,
Self::ChannelClosed => ExitNumber::BrokenPipe,
}
}
#[must_use]
pub const fn is_retryable(self) -> bool {
matches!(self, Self::Network | Self::Conflict | Self::Timeout)
}
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Usage => "usage",
Self::Validation => "validation",
Self::Config => "config",
Self::Network => "network",
Self::Authentication => "authentication",
Self::Permission => "permission",
Self::Absence => "absence",
Self::Conflict => "conflict",
Self::Timeout => "timeout",
Self::Server => "server",
Self::Limit => "limit",
Self::Interrupted => "interrupted",
Self::ChannelClosed => "channel_closed",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[repr(u8)]
pub enum ExitNumber {
Success = 0,
Usage = 2,
Validation = 3,
Config = 4,
Network = 5,
Authentication = 6,
Permission = 7,
Absence = 8,
Conflict = 9,
Limit = 10,
Server = 11,
Timeout = 124,
Interrupted = 130,
BrokenPipe = 141,
}
impl ExitNumber {
#[must_use]
pub const fn code(self) -> u8 {
self as u8
}
}
impl From<ExitNumber> for std::process::ExitCode {
fn from(value: ExitNumber) -> Self {
Self::from(value.code())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn all_holds_every_category_in_its_declared_place() {
const fn place(category: Category) -> usize {
match category {
Category::Usage => 0,
Category::Validation => 1,
Category::Config => 2,
Category::Network => 3,
Category::Authentication => 4,
Category::Permission => 5,
Category::Absence => 6,
Category::Conflict => 7,
Category::Timeout => 8,
Category::Server => 9,
Category::Limit => 10,
Category::Interrupted => 11,
Category::ChannelClosed => 12,
}
}
for (index, category) in Category::ALL.into_iter().enumerate() {
assert_eq!(
place(category),
index,
"{category:?} is declared at {} and sits at {index} in `ALL`",
place(category)
);
}
}
#[test]
fn categories_map_to_distinct_numbers() {
let mut seen = std::collections::BTreeSet::new();
for category in Category::ALL {
assert!(
seen.insert(category.exit_number().code()),
"duplicate exit number for {category:?}",
);
}
assert_eq!(seen.len(), Category::ALL.len());
}
#[test]
fn exit_numbers_match_the_published_table() {
assert_eq!(ExitNumber::Success.code(), 0);
assert_eq!(ExitNumber::Usage.code(), 2);
assert_eq!(ExitNumber::Validation.code(), 3);
assert_eq!(ExitNumber::Config.code(), 4);
assert_eq!(ExitNumber::Network.code(), 5);
assert_eq!(ExitNumber::Authentication.code(), 6);
assert_eq!(ExitNumber::Permission.code(), 7);
assert_eq!(ExitNumber::Absence.code(), 8);
assert_eq!(ExitNumber::Conflict.code(), 9);
assert_eq!(ExitNumber::Limit.code(), 10);
assert_eq!(ExitNumber::Server.code(), 11);
assert_eq!(ExitNumber::Timeout.code(), 124);
assert_eq!(ExitNumber::Interrupted.code(), 130);
assert_eq!(ExitNumber::BrokenPipe.code(), 141);
}
#[test]
fn only_transient_categories_are_retryable() {
assert!(Category::Network.is_retryable());
assert!(Category::Conflict.is_retryable());
assert!(Category::Timeout.is_retryable());
assert!(!Category::Usage.is_retryable());
assert!(!Category::Validation.is_retryable());
assert!(!Category::Permission.is_retryable());
assert!(!Category::Absence.is_retryable());
}
}