tackt 0.1.2

HTTP router
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

/// Build Router from several routes.
///
/// This is just a shortcut for constructing something like this.
///
/// ```
/// # use tackt::Error;
/// # use tackt::Router;
/// # use tackt::routes;
/// #
/// # struct Param;
/// # impl<T> tackt::Param<T> for Param {
/// #     fn from_request(req: &T) -> Result<Self, Error> {
/// #         Ok(Param)
/// #     }
/// # }
/// # async fn route1(req: String, param: Param) -> Result<String, Error> { Ok(req) }
/// # async fn route2(req: String, param: Param) -> Result<String, Error> { Ok(req) }
/// # async fn route3(req: String, param: Param) -> Result<String, Error> { Ok(req) }
/// let router = Router::new(route1)
///     .route(route2)
///     .route(route3);
///
/// let router = routes![route3, route2, route1];
/// ```
///
/// **NOTE** the route(s) is assigned backward.
#[macro_export]
macro_rules! routes {
    ($route:expr $(,)?) => {
        $crate::Router::new($route)
    };

    ($route:expr, $($rest:expr),+ $(,)?) => {
        $crate::routes!($($rest),+).route($route)
    }
}

/// Generate an empty struct that implements [`Param`][crate::param::Param].
#[cfg(test)]
macro_rules! param {
    ($Type:ident, $method:ident, $path:expr) => {
        struct $Type;

        impl<T> $crate::param::Param<::http::request::Request<T>> for $Type {
            #[inline]
            fn from_request(
                req: &::http::request::Request<T>,
            ) -> Result<Self, $crate::error::Error> {
                if req.method() != &::http::Method::$method {
                    return Err($crate::error::Error::Method);
                }

                if req.uri().path() != $path {
                    return Err($crate::error::Error::Path);
                }

                Ok($Type)
            }
        }
    };
    ($Type:ident, $method:ident) => {
        struct $Type;

        impl<T> $crate::param::Param<::http::request::Request<T>> for $Type {
            #[inline]
            fn from_request(
                req: &::http::request::Request<T>,
            ) -> Result<Self, $crate::error::Error> {
                if req.uri().path() != $path {
                    return Err($crate::error::Error::Path);
                }

                Ok($Type)
            }
        }
    };
    ($Type:ident, $path:expr) => {
        struct $Type;

        impl<T> $crate::param::Param<::http::request::Request<T>> for $Type {
            #[inline]
            fn from_request(
                req: &::http::request::Request<T>,
            ) -> Result<Self, $crate::error::Error> {
                if req.uri().path() != $path {
                    return Err($crate::error::Error::Path);
                }

                Ok($Type)
            }
        }
    };
}

#[cfg(test)]
pub(crate) use param;