Skip to content

Commit 182b5c6

Browse files
jtgeibeljtgeibel
committed
cargo fmt
1 parent 272a803 commit 182b5c6

File tree

1 file changed

+81
-47
lines changed

1 file changed

+81
-47
lines changed

‎src/lib.rs

Lines changed: 81 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -2,16 +2,18 @@ extern crate conduit;
22

33
use std::error::Error;
44

5-
use conduit::{Request, Response, Handler};
5+
use conduit::{Handler, Request, Response};
66

77
pub trait Middleware: Send + Sync + 'static {
8-
fn before(&self, _: &mut dyn Request) -> Result<(), Box<dyn Error+Send>> {
8+
fn before(&self, _: &mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
99
Ok(())
1010
}
1111

12-
fn after(&self, _: &mut dyn Request, res: Result<Response, Box<dyn Error+Send>>)
13-
-> Result<Response, Box<dyn Error+Send>>
14-
{
12+
fn after(
13+
&self,
14+
_: &mut dyn Request,
15+
res: Result<Response, Box<dyn Error + Send>>,
16+
) -> Result<Response, Box<dyn Error + Send>> {
1517
res
1618
}
1719
}
@@ -22,19 +24,20 @@ pub trait AroundMiddleware: Handler {
2224

2325
pub struct MiddlewareBuilder {
2426
middlewares: Vec<Box<dyn Middleware>>,
25-
handler: Option<Box<dyn Handler>>
27+
handler: Option<Box<dyn Handler>>,
2628
}
2729

2830
impl MiddlewareBuilder {
2931
pub fn new<H: Handler>(handler: H) -> MiddlewareBuilder {
3032
MiddlewareBuilder {
31-
middlewares: vec!(),
32-
handler: Some(Box::new(handler) as Box<dyn Handler>)
33+
middlewares: vec![],
34+
handler: Some(Box::new(handler) as Box<dyn Handler>),
3335
}
3436
}
3537

3638
pub fn add<M: Middleware>(&mut self, middleware: M) {
37-
self.middlewares.push(Box::new(middleware) as Box<dyn Middleware>);
39+
self.middlewares
40+
.push(Box::new(middleware) as Box<dyn Middleware>);
3841
}
3942

4043
pub fn around<M: AroundMiddleware>(&mut self, mut middleware: M) {
@@ -45,7 +48,7 @@ impl MiddlewareBuilder {
4548
}
4649

4750
impl Handler for MiddlewareBuilder {
48-
fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error+Send>> {
51+
fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
4952
let mut error = None;
5053

5154
for (i, middleware) in self.middlewares.iter().enumerate() {
@@ -62,7 +65,7 @@ impl Handler for MiddlewareBuilder {
6265
Some((err, i)) => {
6366
let middlewares = &self.middlewares[..i];
6467
run_afters(middlewares, req, Err(err))
65-
},
68+
}
6669
None => {
6770
let res = { self.handler.as_ref().unwrap().call(req) };
6871
let middlewares = &self.middlewares;
@@ -73,60 +76,87 @@ impl Handler for MiddlewareBuilder {
7376
}
7477
}
7578

76-
fn run_afters(middleware: &[Box<dyn Middleware>],
77-
req: &mut dyn Request,
78-
res: Result<Response, Box<dyn Error+Send>>)
79-
-> Result<Response, Box<dyn Error+Send>>
80-
{
81-
middleware.iter().rev().fold(res, |res, m| m.after(req, res))
79+
fn run_afters(
80+
middleware: &[Box<dyn Middleware>],
81+
req: &mut dyn Request,
82+
res: Result<Response, Box<dyn Error + Send>>,
83+
) -> Result<Response, Box<dyn Error + Send>> {
84+
middleware
85+
.iter()
86+
.rev()
87+
.fold(res, |res, m| m.after(req, res))
8288
}
8389

8490
#[cfg(test)]
8591
mod tests {
8692
extern crate semver;
8793

88-
use {MiddlewareBuilder, Middleware, AroundMiddleware};
94+
use {AroundMiddleware, Middleware, MiddlewareBuilder};
8995

9096
use std::any::Any;
9197
use std::collections::HashMap;
9298
use std::error::Error;
93-
use std::io::{self, Cursor};
9499
use std::io::prelude::*;
100+
use std::io::{self, Cursor};
95101
use std::net::SocketAddr;
96102

97103
use conduit;
98-
use conduit::{Request, Response, Host, Headers, Method, Scheme, Extensions};
104+
use conduit::{Extensions, Headers, Host, Method, Request, Response, Scheme};
99105
use conduit::{Handler, TypeMap};
100106

101107
struct RequestSentinel {
102108
path: String,
103109
extensions: TypeMap,
104-
method: Method
110+
method: Method,
105111
}
106112

107113
impl RequestSentinel {
108114
fn new(method: Method, path: &'static str) -> RequestSentinel {
109115
RequestSentinel {
110116
path: path.to_string(),
111117
extensions: TypeMap::new(),
112-
method: method
118+
method: method,
113119
}
114120
}
115121
}
116122

117123
impl conduit::Request for RequestSentinel {
118-
fn http_version(&self) -> semver::Version { unimplemented!() }
119-
fn conduit_version(&self) -> semver::Version { unimplemented!() }
120-
fn method(&self) -> Method { self.method.clone() }
121-
fn scheme(&self) -> Scheme { unimplemented!() }
122-
fn host<'a>(&'a self) -> Host<'a> { unimplemented!() }
123-
fn virtual_root<'a>(&'a self) -> Option<&'a str> { unimplemented!() }
124-
fn path<'a>(&'a self) -> &'a str { &self.path }
125-
fn query_string<'a>(&'a self) -> Option<&'a str> { unimplemented!() }
126-
fn remote_addr(&self) -> SocketAddr { unimplemented!() }
127-
fn content_length(&self) -> Option<u64> { unimplemented!() }
128-
fn headers<'a>(&'a self) -> &'a dyn Headers { unimplemented!() }
129-
fn body<'a>(&'a mut self) -> &'a mut dyn Read { unimplemented!() }
124+
fn http_version(&self) -> semver::Version {
125+
unimplemented!()
126+
}
127+
fn conduit_version(&self) -> semver::Version {
128+
unimplemented!()
129+
}
130+
fn method(&self) -> Method {
131+
self.method.clone()
132+
}
133+
fn scheme(&self) -> Scheme {
134+
unimplemented!()
135+
}
136+
fn host<'a>(&'a self) -> Host<'a> {
137+
unimplemented!()
138+
}
139+
fn virtual_root<'a>(&'a self) -> Option<&'a str> {
140+
unimplemented!()
141+
}
142+
fn path<'a>(&'a self) -> &'a str {
143+
&self.path
144+
}
145+
fn query_string<'a>(&'a self) -> Option<&'a str> {
146+
unimplemented!()
147+
}
148+
fn remote_addr(&self) -> SocketAddr {
149+
unimplemented!()
150+
}
151+
fn content_length(&self) -> Option<u64> {
152+
unimplemented!()
153+
}
154+
fn headers<'a>(&'a self) -> &'a dyn Headers {
155+
unimplemented!()
156+
}
157+
fn body<'a>(&'a mut self) -> &'a mut dyn Read {
158+
unimplemented!()
159+
}
130160
fn extensions<'a>(&'a self) -> &'a Extensions {
131161
&self.extensions
132162
}
@@ -138,7 +168,7 @@ mod tests {
138168
struct MyMiddleware;
139169

140170
impl Middleware for MyMiddleware {
141-
fn before<'a>(&self, req: &'a mut dyn Request) -> Result<(), Box<dyn Error+Send>> {
171+
fn before<'a>(&self, req: &'a mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
142172
req.mut_extensions().insert("hello".to_string());
143173
Ok(())
144174
}
@@ -147,15 +177,17 @@ mod tests {
147177
struct ErrorRecovery;
148178

149179
impl Middleware for ErrorRecovery {
150-
fn after(&self, _: &mut dyn Request, res: Result<Response, Box<dyn Error+Send>>)
151-
-> Result<Response, Box<dyn Error+Send>>
152-
{
180+
fn after(
181+
&self,
182+
_: &mut dyn Request,
183+
res: Result<Response, Box<dyn Error + Send>>,
184+
) -> Result<Response, Box<dyn Error + Send>> {
153185
res.or_else(|e| {
154186
let e = e.to_string();
155187
Ok(Response {
156188
status: (500, "Internal Server Error"),
157189
headers: HashMap::new(),
158-
body: Box::new(Cursor::new(e.into_bytes()))
190+
body: Box::new(Cursor::new(e.into_bytes())),
159191
})
160192
})
161193
}
@@ -164,27 +196,29 @@ mod tests {
164196
struct ProducesError;
165197

166198
impl Middleware for ProducesError {
167-
fn before(&self, _: &mut dyn Request) -> Result<(), Box<dyn Error+Send>> {
199+
fn before(&self, _: &mut dyn Request) -> Result<(), Box<dyn Error + Send>> {
168200
Err(Box::new(io::Error::new(io::ErrorKind::Other, "")))
169201
}
170202
}
171203

172204
struct NotReached;
173205

174206
impl Middleware for NotReached {
175-
fn after(&self, _: &mut dyn Request, _: Result<Response, Box<dyn Error+Send>>)
176-
-> Result<Response, Box<dyn Error+Send>>
177-
{
207+
fn after(
208+
&self,
209+
_: &mut dyn Request,
210+
_: Result<Response, Box<dyn Error + Send>>,
211+
) -> Result<Response, Box<dyn Error + Send>> {
178212
Ok(Response {
179213
status: (200, "OK"),
180214
headers: HashMap::new(),
181-
body: Box::new(Cursor::new(vec!()))
215+
body: Box::new(Cursor::new(vec![])),
182216
})
183217
}
184218
}
185219

186220
struct MyAroundMiddleware {
187-
handler: Option<Box<dyn Handler>>
221+
handler: Option<Box<dyn Handler>>,
188222
}
189223

190224
impl MyAroundMiddleware {
@@ -202,7 +236,7 @@ mod tests {
202236
}
203237

204238
impl Handler for MyAroundMiddleware {
205-
fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error+Send>> {
239+
fn call(&self, req: &mut dyn Request) -> Result<Response, Box<dyn Error + Send>> {
206240
req.mut_extensions().insert("hello".to_string());
207241
self.handler.as_ref().unwrap().call(req)
208242
}
@@ -216,7 +250,7 @@ mod tests {
216250
Response {
217251
status: (200, "OK"),
218252
headers: HashMap::new(),
219-
body: Box::new(Cursor::new(string.into_bytes()))
253+
body: Box::new(Cursor::new(string.into_bytes())),
220254
}
221255
}
222256

0 commit comments

Comments
 (0)