vintage 0.7.0

A multi-threaded FastCGI server
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

use crate::context::{Request, Response};
use std::collections::BTreeMap;
use std::sync::Arc;

pub type RouteParams = BTreeMap<String, String>;
pub type RouterCallback = Arc<dyn Fn(&mut Request, RouteParams) -> Response + Send + Sync>;

#[derive(Default, Clone)]
pub struct Router {
    map: BTreeMap<&'static str, matchit::Router<RouterCallback>>,
}

impl Router {
    pub fn register<C, const N: usize>(
        &mut self,
        method: &'static str,
        paths: [&str; N],
        callback: C,
    ) where
        C: Fn(&mut Request, RouteParams) -> Response,
        C: 'static + Send + Sync,
    {
        let callback = Arc::new(callback);

        for path in paths {
            self.map
                .entry(method)
                .or_default()
                .insert(path, callback.clone())
                .unwrap()
        }
    }

    pub fn respond(&self, req: &mut Request) -> Option<Response> {
        let router = self.map.get(req.method())?;

        let entry = router.at(req.path()).ok()?;

        let mut params = BTreeMap::new();

        for (key, value) in entry.params.iter() {
            params.insert(key.to_string(), value.to_string());
        }

        Some((entry.value)(req, params))
    }
}

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

    fn make_request(method: &str, path: &str) -> Request {
        Request {
            method: method.into(),
            path: path.into(),
            ..Request::default()
        }
    }

    #[test]
    fn non_matching_method() {
        let mut router = Router::default();
        router.register("GET", ["/path"], move |_req, _params| Response::default());

        let mut request = make_request("POST", "/path");
        let response = router.respond(&mut request);

        assert_eq!(response, None);
    }

    #[test]
    fn non_matching_path() {
        let mut router = Router::default();
        router.register("GET", ["/path"], move |_req, _params| Response::default());

        let mut request = make_request("GET", "/rong");
        let response = router.respond(&mut request);

        assert_eq!(response, None);
    }

    #[test]
    fn implementing_trailing_slash() {
        let mut router = Router::default();
        router.register("GET", ["/path/", "/path"], move |_req, _params| {
            Response::default().set_status(100)
        });

        let mut request1 = make_request("GET", "/path");
        let mut request2 = make_request("GET", "/path/");

        let response1 = router.respond(&mut request1).unwrap();
        let response2 = router.respond(&mut request2).unwrap();

        assert_eq!(response1, Response::default().set_status(100));
        assert_eq!(response2, Response::default().set_status(100));
    }

    #[test]
    fn wildcard_matching() {
        let mut router = Router::default();
        router.register("GET", ["/path/{*rest}"], move |_req, params| {
            Response::default().set_body(&params["rest"])
        });

        let mut request = make_request("GET", "/path/a/b/c");
        let response = router.respond(&mut request).unwrap();

        assert_eq!(response, Response::default().set_body("a/b/c"));
    }

    #[test]
    fn segment_matching() {
        let mut router = Router::default();
        router.register("GET", ["/path/{id}/rest"], {
            move |_req, params| Response::default().set_body(&params["id"])
        });

        let mut request = make_request("GET", "/path/2/rest");

        let response = router.respond(&mut request).unwrap();

        assert_eq!(response, Response::default().set_body(String::from("2")));
    }
}