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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
use hyper::method::Method;
use middleware::Middleware;
use router::Matcher;
pub trait HttpRouter<D> {
/// Registers a handler to be used for a specified method.
/// A handler can be anything implementing the `RequestHandler` trait.
///
/// # Examples
///
/// ```{rust}
/// #[macro_use] extern crate nickel;
/// extern crate hyper;
/// extern crate regex;
///
/// use nickel::{Nickel, HttpRouter};
/// use hyper::method::Method::{Get, Post, Put, Delete};
/// use regex::Regex;
///
/// fn main() {
/// let mut server = Nickel::new();
///
/// server.add_route(Get, "/foo", middleware! { "Get request! "});
/// server.add_route(Post, "/foo", middleware! { |request|
/// format!("Method is: {}", request.origin.method)
/// });
/// server.add_route(Put, "/foo", middleware! { |request|
/// format!("Method is: {}", request.origin.method)
/// });
/// server.add_route(Delete, "/foo", middleware! { |request|
/// format!("Method is: {}", request.origin.method)
/// });
///
/// // Regex path
/// let regex = Regex::new("/(foo|bar)").unwrap();
/// server.add_route(Get, regex, middleware! { "Regex Get request! "});
/// }
/// ```
fn add_route<M: Into<Matcher>, H: Middleware<D>>(&mut self, Method, M, H) -> &mut Self;
/// Registers a handler to be used for a specific GET request.
/// Handlers are assigned to paths and paths are allowed to contain
/// variables and wildcards.
///
/// A handler added through this API will be attached to the default router.
/// Consider creating the router middleware manually for advanced functionality.
///
/// # Examples
///
/// ```{rust}
/// #[macro_use] extern crate nickel;
/// use nickel::{Nickel, HttpRouter};
///
/// fn main() {
/// let mut server = Nickel::new();
///
/// // without variables or wildcards
/// server.get("/user", middleware! { "This matches /user" });
///
/// // with variables
/// server.get("/user/:userid", middleware! { |request|
/// format!("This is user: {}", request.param("userid").unwrap())
/// });
///
/// // with simple wildcard
/// server.get("/user/*/:userid", middleware! {
/// "This matches /user/list/4711 but not /user/extended/list/4711"
/// });
///
/// // with double wildcard
/// server.get("/user/**/:userid", middleware! {
/// "This matches /user/list/4711 and also /user/extended/list/4711"
/// });
///
/// // with chained routes
/// server
/// .get("/foo", middleware! {
/// "foo"
/// })
/// .get("/bar", middleware! {
/// "bar"
/// })
/// .get("/baz", middleware! {
/// "baz"
/// })
/// .get("/quux", middleware! {
/// "quux"
/// });
/// }
/// ```
///
/// # router! macro example
///
/// ```{rust}
/// #[macro_use] extern crate nickel;
/// use nickel::Nickel;
///
/// fn main() {
/// let router = router! {
/// // without variables or wildcards
/// get "/user" => |_, response| {
/// "This matches /user";
/// }
/// // with variables
/// get "/user/:userid" => |request, response| {
/// format!("This is user: {}", request.param("userid").unwrap())
/// }
/// // with simple wildcard
/// get "/user/*/:userid" => |_, response| {
/// ["This matches /user/list/4711",
/// "NOT /user/extended/list/4711"];
/// }
/// // with double wildcard
/// get "/user/**/:userid" => |_, response| {
/// ["This matches /user/list/4711",
/// "AND /user/extended/list/4711"];
/// }
/// };
///
/// let mut server = Nickel::new();
/// server.utilize(router);
/// }
/// ```
fn get<M: Into<Matcher>, H: Middleware<D>>(&mut self, matcher: M, handler: H) -> &mut Self {
self.add_route(Method::Get, matcher, handler)
}
/// Registers a handler to be used for a specific POST request.
///
/// Take a look at `get(...)` for a more detailed description.
fn post<M: Into<Matcher>, H: Middleware<D>>(&mut self, matcher: M, handler: H) -> &mut Self {
self.add_route(Method::Post, matcher, handler)
}
/// Registers a handler to be used for a specific PUT request.
///
/// Take a look at `get(...)` for a more detailed description.
fn put<M: Into<Matcher>, H: Middleware<D>>(&mut self, matcher: M, handler: H) -> &mut Self {
self.add_route(Method::Put, matcher, handler)
}
/// Registers a handler to be used for a specific DELETE request.
///
/// Take a look at `get(...)` for a more detailed description.
fn delete<M: Into<Matcher>, H: Middleware<D>>(&mut self, matcher: M, handler: H) -> &mut Self {
self.add_route(Method::Delete, matcher, handler)
}
/// Registers a handler to be used for a specific OPTIONS request.
///
/// Take a look at `get(...)` for a more detailed description.
fn options<M: Into<Matcher>, H: Middleware<D>>(&mut self, matcher: M, handler: H) -> &mut Self {
self.add_route(Method::Options, matcher, handler)
}
/// Registers a handler to be used for a specific PATCH request.
///
/// Take a look at `get(...)` for a more detailed description.
fn patch<M: Into<Matcher>, H: Middleware<D>>(&mut self, matcher: M, handler: H) -> &mut Self {
self.add_route(Method::Patch, matcher, handler)
}
}