ruffus 0.1.2

Fast, minimalist web framework for Rust inspired by Express.js
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

//! HTTP Method type
//!
//! This module defines the HTTP methods supported by Ruffus.

use std::fmt;

/// HTTP request methods.
///
/// Represents the standard HTTP methods used in RESTful APIs.
///
/// # Examples
///
/// ```
/// use ruffus::Method;
///
/// let method = Method::GET;
/// assert_eq!(method.to_string(), "GET");
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Method {
    /// GET method
    GET,
    /// POST method
    POST,
    /// PUT method
    PUT,
    /// DELETE method
    DELETE,
    /// PATCH method
    PATCH,
    /// OPTIONS method
    OPTIONS,
    /// HEAD method
    HEAD,
}

impl Method {
    /// Converts from a hyper/http Method.
    ///
    /// Returns `None` if the method is not supported.
    pub fn from_hyper(method: &http::Method) -> Option<Self> {
        match *method {
            http::Method::GET => Some(Method::GET),
            http::Method::POST => Some(Method::POST),
            http::Method::PUT => Some(Method::PUT),
            http::Method::DELETE => Some(Method::DELETE),
            http::Method::PATCH => Some(Method::PATCH),
            http::Method::OPTIONS => Some(Method::OPTIONS),
            http::Method::HEAD => Some(Method::HEAD),
            _ => None,
        }
    }
}

impl From<http::Method> for Method {
    fn from(method: http::Method) -> Self {
        Method::from_hyper(&method).unwrap_or_else(|| {
            panic!("Unsupported HTTP method: {}", method)
        })
    }
}

impl fmt::Display for Method {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Method::GET => write!(f, "GET"),
            Method::POST => write!(f, "POST"),
            Method::PUT => write!(f, "PUT"),
            Method::DELETE => write!(f, "DELETE"),
            Method::PATCH => write!(f, "PATCH"),
            Method::OPTIONS => write!(f, "OPTIONS"),
            Method::HEAD => write!(f, "HEAD"),
        }
    }
}

impl From<Method> for http::Method {
    fn from(method: Method) -> Self {
        match method {
            Method::GET => http::Method::GET,
            Method::POST => http::Method::POST,
            Method::PUT => http::Method::PUT,
            Method::DELETE => http::Method::DELETE,
            Method::PATCH => http::Method::PATCH,
            Method::OPTIONS => http::Method::OPTIONS,
            Method::HEAD => http::Method::HEAD,
        }
    }
}

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

    #[test]
    fn test_from_hyper_conversion() {
        assert_eq!(Method::from(http::Method::GET), Method::GET);
        assert_eq!(Method::from(http::Method::POST), Method::POST);
        assert_eq!(Method::from(http::Method::PUT), Method::PUT);
        assert_eq!(Method::from(http::Method::DELETE), Method::DELETE);
        assert_eq!(Method::from(http::Method::PATCH), Method::PATCH);
        assert_eq!(Method::from(http::Method::OPTIONS), Method::OPTIONS);
        assert_eq!(Method::from(http::Method::HEAD), Method::HEAD);
    }

    #[test]
    fn test_display() {
        assert_eq!(Method::GET.to_string(), "GET");
        assert_eq!(Method::POST.to_string(), "POST");
        assert_eq!(Method::PUT.to_string(), "PUT");
        assert_eq!(Method::DELETE.to_string(), "DELETE");
        assert_eq!(Method::PATCH.to_string(), "PATCH");
        assert_eq!(Method::OPTIONS.to_string(), "OPTIONS");
        assert_eq!(Method::HEAD.to_string(), "HEAD");
    }

    #[test]
    fn test_equality() {
        assert_eq!(Method::GET, Method::GET);
        assert_ne!(Method::GET, Method::POST);
        assert_eq!(Method::POST, Method::POST);
    }

    #[test]
    fn test_clone() {
        let method = Method::GET;
        let cloned = method.clone();
        assert_eq!(method, cloned);
    }
}