joist 1.0.0

A backend framework for Rust: routing, middleware, JSON, config and plugins, with no third-party dependencies.
Documentation
use std::fmt;

/// An HTTP status code.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct Status(u16);

impl Status {
    pub const OK: Status = Status(200);
    pub const CREATED: Status = Status(201);
    pub const ACCEPTED: Status = Status(202);
    pub const NO_CONTENT: Status = Status(204);
    pub const MOVED_PERMANENTLY: Status = Status(301);
    pub const FOUND: Status = Status(302);
    pub const NOT_MODIFIED: Status = Status(304);
    pub const BAD_REQUEST: Status = Status(400);
    pub const UNAUTHORIZED: Status = Status(401);
    pub const FORBIDDEN: Status = Status(403);
    pub const NOT_FOUND: Status = Status(404);
    pub const METHOD_NOT_ALLOWED: Status = Status(405);
    pub const CONFLICT: Status = Status(409);
    pub const LENGTH_REQUIRED: Status = Status(411);
    pub const PAYLOAD_TOO_LARGE: Status = Status(413);
    pub const UNSUPPORTED_MEDIA_TYPE: Status = Status(415);
    pub const UNPROCESSABLE_ENTITY: Status = Status(422);
    pub const TOO_MANY_REQUESTS: Status = Status(429);
    pub const INTERNAL_SERVER_ERROR: Status = Status(500);
    pub const NOT_IMPLEMENTED: Status = Status(501);
    pub const SERVICE_UNAVAILABLE: Status = Status(503);

    pub const fn new(code: u16) -> Status {
        Status(code)
    }

    pub const fn code(self) -> u16 {
        self.0
    }

    pub const fn is_informational(self) -> bool {
        self.0 >= 100 && self.0 < 200
    }

    pub const fn is_success(self) -> bool {
        self.0 >= 200 && self.0 < 300
    }

    pub const fn is_redirect(self) -> bool {
        self.0 >= 300 && self.0 < 400
    }

    pub const fn is_client_error(self) -> bool {
        self.0 >= 400 && self.0 < 500
    }

    pub const fn is_server_error(self) -> bool {
        self.0 >= 500 && self.0 < 600
    }

    /// Whether a response with this status is defined to have no body. The
    /// server relies on this so it never writes one where the spec forbids it.
    pub const fn body_forbidden(self) -> bool {
        self.is_informational() || self.0 == 204 || self.0 == 304
    }

    pub fn reason(self) -> &'static str {
        match self.0 {
            100 => "Continue",
            101 => "Switching Protocols",
            200 => "OK",
            201 => "Created",
            202 => "Accepted",
            204 => "No Content",
            301 => "Moved Permanently",
            302 => "Found",
            304 => "Not Modified",
            400 => "Bad Request",
            401 => "Unauthorized",
            403 => "Forbidden",
            404 => "Not Found",
            405 => "Method Not Allowed",
            409 => "Conflict",
            411 => "Length Required",
            413 => "Payload Too Large",
            415 => "Unsupported Media Type",
            422 => "Unprocessable Entity",
            429 => "Too Many Requests",
            500 => "Internal Server Error",
            501 => "Not Implemented",
            502 => "Bad Gateway",
            503 => "Service Unavailable",
            504 => "Gateway Timeout",
            _ => "Unknown",
        }
    }
}

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

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

    #[test]
    fn classes() {
        assert!(Status::OK.is_success());
        assert!(Status::NOT_FOUND.is_client_error());
        assert!(Status::INTERNAL_SERVER_ERROR.is_server_error());
        assert!(!Status::OK.is_client_error());
    }

    #[test]
    fn statuses_without_a_body() {
        assert!(Status::NO_CONTENT.body_forbidden());
        assert!(Status::NOT_MODIFIED.body_forbidden());
        assert!(Status::new(100).body_forbidden());
        assert!(!Status::OK.body_forbidden());
    }

    #[test]
    fn display_includes_reason() {
        assert_eq!(Status::NOT_FOUND.to_string(), "404 Not Found");
    }
}