rustfmt: Reformatted all the code.

1 files changed, 33 insertions, 44 deletions

diff --git a/src/server.rs b/src/server.rs
index 3a03ea0..58027e9 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,5 +1,5 @@
 use iron;
-use iron::error::{HttpResult};
+use iron::error::HttpResult;
 use iron::headers::ContentType;
 use iron::modifiers::{Header, Redirect};
 use iron::status;
@@ -23,7 +23,7 @@ use auth;
 #[derive(Debug)]
 pub struct Context {
     pub base_url: String,
-    pub conn: Connection
+    pub conn: Connection,
 }
 impl iron::typemap::Key for Context {
     type Value = Context;
@@ -42,7 +42,7 @@ impl iron_sessionstorage::Value for Login {
         self.user
     }
     fn from_raw(v: String) -> Option<Self> {
-        Some(Login{ user: v })
+        Some(Login { user: v })
     }
 }
 
@@ -51,12 +51,17 @@ fn overview(r: &mut Request) -> IronResult<Response> {
 
     let units = unit::get_units("*").unwrap();
 
-    let sections = ["service", "timer", "socket", "target", "slice", "mount",
-                    "path"];
-    let units_by_section = sections.iter().map(|&s| {
-        (s.to_owned(),
-         units.iter().filter(|&u| &u.type_ == s).collect::<Vec<&unit::Unit>>())
-    }).collect::<Vec<_>>();
+    let sections = ["service", "timer", "socket", "target", "slice", "mount", "path"];
+    let units_by_section = sections
+        .iter()
+        .map(|&s| {
+                 (s.to_owned(),
+                  units
+                      .iter()
+                      .filter(|&u| &u.type_ == s)
+                      .collect::<Vec<&unit::Unit>>())
+             })
+        .collect::<Vec<_>>();
 
     // let res = Ok(Response::with((status::Ok,
     //                              Header(ContentType::html()),
@@ -75,39 +80,29 @@ fn overview(r: &mut Request) -> IronResult<Response> {
 }
 
 fn journal(r: &mut Request) -> IronResult<Response> {
-    let unit = iexpect!(r.extensions
-                        .get::<Router>()
-                        .unwrap()
-                        .find("unit"), status::BadRequest);
+    let unit = iexpect!(r.extensions.get::<Router>().unwrap().find("unit"),
+                        status::BadRequest);
     let re = Regex::new(r"[-_\w\d]*").unwrap();
     if !re.is_match(unit) {
-        return Ok(Response::with(
-            (status::BadRequest,
-             format!("Unit ({}) does not match {}",
-                     unit, re))));
+        return Ok(Response::with((status::BadRequest,
+                                  format!("Unit ({}) does not match {}", unit, re))));
     }
-    Ok(Response::with((status::Ok,
-                       itry!(journal::get_log(unit, 100)))))
+    Ok(Response::with((status::Ok, itry!(journal::get_log(unit, 100)))))
 }
 
 fn unit_status(r: &mut Request) -> IronResult<Response> {
-    let unit_name = iexpect!(r.extensions
-                             .get::<Router>()
-                             .unwrap()
-                             .find("unit"), status::BadRequest).to_string();
+    let unit_name = iexpect!(r.extensions.get::<Router>().unwrap().find("unit"),
+                             status::BadRequest)
+            .to_string();
     let re = Regex::new(r"[-_\w\d]*").unwrap();
     if !re.is_match(&unit_name) {
-        return Ok(Response::with(
-            (status::BadRequest,
-             format!("Unit ({}) does not match {}",
-                     unit_name, re))));
+        return Ok(Response::with((status::BadRequest,
+                                  format!("Unit ({}) does not match {}", unit_name, re))));
     }
     let ref unit = itry!(unit::get_units(&unit_name))[0];
     let log = itry!(journal::get_log(&unit_name, 15));
     let renderer = make_renderer(r)?;
-    Ok(Response::with((status::Ok,
-                       Header(ContentType::html()),
-                       renderer.unit_status(&unit, &log))))
+    Ok(Response::with((status::Ok, Header(ContentType::html()), renderer.unit_status(&unit, &log))))
 }
 
 fn get_logged_in_user(r: &mut Request) -> IronResult<Option<Login>> {
@@ -116,7 +111,7 @@ fn get_logged_in_user(r: &mut Request) -> IronResult<Option<Login>> {
     // so we set the username to empty on logout.
     if let &Some(Login { ref user }) = &login {
         if user.is_empty() {
-            return Ok(None)
+            return Ok(None);
         }
     }
     Ok(login)
@@ -125,9 +120,7 @@ fn get_logged_in_user(r: &mut Request) -> IronResult<Option<Login>> {
 fn login(r: &mut Request) -> IronResult<Response> {
     let renderer = make_renderer(r)?;
     let is_retry = r.method == iron::method::Method::Post;
-    Ok(Response::with((status::Ok,
-                       Header(ContentType::html()),
-                       renderer.login_page(is_retry))))
+    Ok(Response::with((status::Ok, Header(ContentType::html()), renderer.login_page(is_retry))))
 }
 
 fn authenticate(r: &mut Request) -> IronResult<Response> {
@@ -135,11 +128,11 @@ fn authenticate(r: &mut Request) -> IronResult<Response> {
         let map = r.get_ref::<Params>().unwrap();
         let user = match map.get("username") {
             Some(&Value::String(ref v)) => v,
-            _ => panic!("no username in params: {:?}", map)
+            _ => panic!("no username in params: {:?}", map),
         };
         let password = match map.get("password") {
             Some(&Value::String(ref v)) => v,
-            _ => panic!("no password in params: {:?}", map)
+            _ => panic!("no password in params: {:?}", map),
         };
         (user.to_string(), password.to_string())
     };
@@ -151,12 +144,11 @@ fn authenticate(r: &mut Request) -> IronResult<Response> {
     };
 
     if let Some(true) = hash.map(|h| auth::validate(&password, &h)) {
-        let login = Login{ user: user.to_string() };  // TODO Make a validated login type
+        let login = Login { user: user.to_string() }; // TODO Make a validated login type
         info!("User logged in: {:?}", login);
         r.session().set(login)?;
         let url = Url::parse("http://localhost:8080/").unwrap();
-        Ok(Response::with((status::Found,
-                           Redirect(url))))
+        Ok(Response::with((status::Found, Redirect(url))))
     } else {
         login(r)
     }
@@ -165,15 +157,12 @@ fn authenticate(r: &mut Request) -> IronResult<Response> {
 fn logout(r: &mut Request) -> IronResult<Response> {
     r.session().set::<Login>(Default::default());
     let url = Url::parse("http://localhost:8080/").unwrap();
-    Ok(Response::with((status::Found,
-                       Redirect(url))))
+    Ok(Response::with((status::Found, Redirect(url))))
 }
 
 fn make_renderer(r: &mut Request) -> IronResult<render::Renderer> {
     let user = get_logged_in_user(r)?.map(|u| u.user);
-    Ok(render::Renderer {
-        user: user
-    })
+    Ok(render::Renderer { user: user })
 }
 
 pub fn serve(context: Context, port: u16) -> HttpResult<Listening> {