Get rid of most of unwrap and run rustfmt on web

Author: onur

src/web/builds.rs

@@ -59,23 +59,18 @@ impl ToJson for BuildsPage {
 
 pub fn build_list_handler(req: &mut Request) -> IronResult<Response> {
 
-    let name = req.extensions.get::<Router>().unwrap().find("name").unwrap();
-    let version = req.extensions.get::<Router>().unwrap().find("version").unwrap();
-    let req_build_id: i32 = req.extensions
-                               .get::<Router>()
-                               .unwrap()
-                               .find("id")
-                               .unwrap_or("0")
-                               .parse()
-                               .unwrap_or(0);
-
-    let conn = req.extensions.get::<Pool>().unwrap();
+    let router = extension!(req, Router);
+    let name = cexpect!(router.find("name"));
+    let version = cexpect!(router.find("version"));
+    let req_build_id: i32 = router.find("id").unwrap_or("0").parse().unwrap_or(0);
+
+    let conn = extension!(req, Pool);
 
     let mut build_list: Vec<Build> = Vec::new();
     let mut build_details = None;
 
     // FIXME: getting builds.output may cause performance issues when release have tons of builds
-    for row in &conn.query("SELECT crates.name, \
+    for row in &ctry!(conn.query("SELECT crates.name, \
                                    releases.version, \
                                    releases.description, \
                                    releases.rustdoc_status, \
@@ -90,8 +85,7 @@ pub fn build_list_handler(req: &mut Request) -> IronResult<Response> {
                             INNER JOIN releases ON releases.id = builds.rid \
                             INNER JOIN crates ON releases.crate_id = crates.id \
                             WHERE crates.name = $1 AND releases.version = $2",
-                           &[&name, &version])
-                    .unwrap() {
+                                 &[&name, &version])) {
 
         let id: i32 = row.get(5);
 

src/web/crate_details.rs

@@ -187,15 +187,19 @@ impl CrateDetails {
         for row in &conn.query("SELECT name, slug
                                 FROM authors
                                 INNER JOIN author_rels ON author_rels.aid = authors.id
-                                WHERE rid = $1", &[&release_id]).unwrap() {
+                                WHERE rid = $1",
+                   &[&release_id])
+            .unwrap() {
             crate_details.authors.push((row.get(0), row.get(1)));
         }
 
         // get owners
         for row in &conn.query("SELECT login, avatar
                                 FROM owners
                                 INNER JOIN owner_rels ON owner_rels.oid = owners.id
-                                WHERE cid = $1", &[&crate_id]).unwrap() {
+                                WHERE cid = $1",
+                   &[&crate_id])
+            .unwrap() {
             crate_details.owners.push((row.get(0), row.get(1)));
         }
 
@@ -206,11 +210,12 @@ impl CrateDetails {
 
 
 pub fn crate_details_handler(req: &mut Request) -> IronResult<Response> {
+    let router = extension!(req, Router);
     // this handler must always called with a crate name
-    let name = req.extensions.get::<Router>().unwrap().find("name").unwrap();
-    let req_version = req.extensions.get::<Router>().unwrap().find("version");
+    let name = cexpect!(router.find("name"));
+    let req_version = router.find("version");
 
-    let conn = req.extensions.get::<Pool>().unwrap();
+    let conn = extension!(req, Pool);
 
     match_version(&conn, &name, req_version)
         .and_then(|version| CrateDetails::new(&conn, &name, &version))

src/web/file.rs

@@ -22,8 +22,8 @@ impl File {
 
         let rows = conn.query("SELECT path, mime, date_added, date_updated, content FROM files \
                                WHERE path = $1",
-                              &[&path])
-                       .unwrap();
+                   &[&path])
+            .unwrap();
 
         if rows.len() == 0 {
             None
@@ -46,7 +46,7 @@ impl File {
 
         let mut response = Response::with((status::Ok, self.content));
         let cache = vec![CacheDirective::Public,
-        CacheDirective::MaxAge(super::STATIC_FILE_CACHE_DURATION as u32)];
+                         CacheDirective::MaxAge(super::STATIC_FILE_CACHE_DURATION as u32)];
         response.headers.set(ContentType(self.mime.parse().unwrap()));
         response.headers.set(CacheControl(cache));
         response.headers.set(LastModified(HttpDate(time::at(self.date_updated))));
@@ -71,7 +71,7 @@ impl Handler for DatabaseFileHandler {
 
         let path = req.url.path.clone().join("/");
 
-        let conn = req.extensions.get::<Pool>().unwrap();
+        let conn = extension!(req, Pool);
         if let Some(file) = File::from_path(&conn, &path) {
             Ok(file.serve())
         } else {

src/web/mod.rs

@@ -1,9 +1,42 @@
 //! Web interface of cratesfyi
 
 
+pub mod page;
+
+/// ctry! (cratesfyitry) is extremely similar to try! and itry!
+/// except it returns an error page response instead of plain Err.
+macro_rules! ctry {
+    ($result:expr) => (match $result {
+        Ok(v) => v,
+        Err(e) => {
+            return super::page::Page::new(format!("{:?}", e)).title("An error has occured")
+                .set_status(::iron::status::BadRequest).to_resp("resp");
+        }
+    })
+}
+
+/// cexpect will check an option and if it's not Some
+/// it will return an error page response
+macro_rules! cexpect {
+    ($option:expr) => (match $option {
+        Some(v) => v,
+        None => {
+            return super::page::Page::new("Resource not found".to_owned())
+                .title("An error has occured")
+                .set_status(::iron::status::BadRequest).to_resp("resp");
+        }
+    })
+}
+
+/// Gets an extension from Request
+macro_rules! extension {
+    ($req:expr, $ext:ty) => (
+        cexpect!($req.extensions.get::<$ext>())
+        )
+}
+
 mod rustdoc;
 mod releases;
-mod page;
 mod crate_details;
 mod source;
 mod pool;
@@ -27,7 +60,6 @@ use rustc_serialize::json::{Json, ToJson};
 use std::collections::BTreeMap;
 
 
-
 /// Duration of static files for staticfile and DatabaseFileHandler (in seconds)
 const STATIC_FILE_CACHE_DURATION: u64 = 60 * 60 * 24 * 30 * 12;   // 12 months
 const STYLE_CSS: &'static str = include_str!(concat!(env!("OUT_DIR"), "/style.css"));
@@ -114,21 +146,21 @@ impl Handler for CratesfyiHandler {
                 // if router fails try to serve files from database first
                 self.database_file_handler.handle(req).or(Err(e))
             })
-            .or_else(|e| {
-                // and then try static handler. if all of them fails, return 404
-                self.static_handler.handle(req).or(Err(e))
-            })
-            .or_else(|e| {
-                debug!("{}", e.description());
-                let err = if let Some(err) = e.error.downcast::<error::Nope>() {
-                    *err
-                } else if e.error.downcast::<NoRoute>().is_some() {
-                    error::Nope::ResourceNotFound
-                } else {
-                    panic!("all cratesfyi errors should be of type Nope");
-                };
-                Self::chain(err).handle(req)
-            })
+        .or_else(|e| {
+            // and then try static handler. if all of them fails, return 404
+            self.static_handler.handle(req).or(Err(e))
+        })
+        .or_else(|e| {
+            debug!("{}", e.description());
+            let err = if let Some(err) = e.error.downcast::<error::Nope>() {
+                *err
+            } else if e.error.downcast::<NoRoute>().is_some() {
+                error::Nope::ResourceNotFound
+            } else {
+                panic!("all cratesfyi errors should be of type Nope");
+            };
+            Self::chain(err).handle(req)
+        })
     }
 }
 
@@ -303,7 +335,7 @@ impl MetaData {
                                 FROM releases
                                 INNER JOIN crates ON crates.id = releases.crate_id
                                 WHERE crates.name = $1 AND releases.version = $2",
-                               &[&name, &version]).unwrap() {
+                                &[&name, &version]).unwrap() {
 
             return Some(MetaData {
                 name: row.get(0),

src/web/releases.rs

@@ -272,7 +272,7 @@ fn get_search_results(conn: &Connection,
 
 
 pub fn home_page(req: &mut Request) -> IronResult<Response> {
-    let conn = req.extensions.get::<Pool>().unwrap();
+    let conn = extension!(req, Pool);
     let packages = get_releases(conn, 1, RELEASES_IN_HOME, Order::ReleaseTime);
     Page::new(packages)
         .set_true("show_search_form")
@@ -283,15 +283,9 @@ pub fn home_page(req: &mut Request) -> IronResult<Response> {
 
 pub fn releases_handler(req: &mut Request) -> IronResult<Response> {
     // page number of releases
-    let page_number: i64 = req.extensions
-        .get::<Router>()
-        .unwrap()
-        .find("page")
-        .unwrap_or("1")
-        .parse()
-        .unwrap_or(1);
-
-    let conn = req.extensions.get::<Pool>().unwrap();
+    let page_number: i64 = extension!(req, Router).find("page").unwrap_or("1").parse().unwrap_or(1);
+
+    let conn = extension!(req, Pool);
     let packages = get_releases(conn, page_number, RELEASES_IN_RELEASES, Order::ReleaseTime);
 
     if packages.is_empty() {
@@ -320,15 +314,9 @@ pub fn releases_handler(req: &mut Request) -> IronResult<Response> {
 // TODO: This function is almost identical to previous one
 pub fn stars_handler(req: &mut Request) -> IronResult<Response> {
     // page number of releases
-    let page_number: i64 = req.extensions
-        .get::<Router>()
-        .unwrap()
-        .find("page")
-        .unwrap_or("1")
-        .parse()
-        .unwrap_or(1);
-
-    let conn = req.extensions.get::<Pool>().unwrap();
+    let page_number: i64 = extension!(req, Router).find("page").unwrap_or("1").parse().unwrap_or(1);
+
+    let conn = extension!(req, Pool);
     let packages = get_releases(conn, page_number, RELEASES_IN_RELEASES, Order::GithubStars);
 
     if packages.is_empty() {
@@ -356,25 +344,20 @@ pub fn stars_handler(req: &mut Request) -> IronResult<Response> {
 
 
 pub fn author_handler(req: &mut Request) -> IronResult<Response> {
+    let router = extension!(req, Router);
     // page number of releases
-    let page_number: i64 = req.extensions
-        .get::<Router>()
-        .unwrap()
-        .find("page")
-        .unwrap_or("1")
-        .parse()
-        .unwrap_or(1);
-
-    let conn = req.extensions.get::<Pool>().unwrap();
-    let author = try!(req.extensions
-        .get::<Router>()
-        .unwrap()
-        .find("author")
+    let page_number: i64 = router.find("page").unwrap_or("1").parse().unwrap_or(1);
+
+    let conn = extension!(req, Pool);
+    let author = ctry!(router.find("author")
         .ok_or(IronError::new(Nope::CrateNotFound, status::NotFound)));
 
     let (author_name, packages) = if author.starts_with("@") {
         let mut author = author.clone().split("@");
-        get_releases_by_owner(conn, page_number, RELEASES_IN_RELEASES, author.nth(1).unwrap())
+        get_releases_by_owner(conn,
+                              page_number,
+                              RELEASES_IN_RELEASES,
+                              cexpect!(author.nth(1)))
     } else {
         get_releases_by_author(conn, page_number, RELEASES_IN_RELEASES, author)
     };
@@ -405,10 +388,10 @@ pub fn author_handler(req: &mut Request) -> IronResult<Response> {
 pub fn search_handler(req: &mut Request) -> IronResult<Response> {
     use params::{Params, Value};
 
-    let params = req.get::<Params>().unwrap();
+    let params = ctry!(req.get::<Params>());
     let query = params.find(&["query"]);
 
-    let conn = req.extensions.get::<Pool>().unwrap();
+    let conn = extension!(req, Pool);
     if let Some(&Value::String(ref query)) = query {
 
         // check if I am feeling lucky button pressed and redirect user to crate page
@@ -421,29 +404,29 @@ pub fn search_handler(req: &mut Request) -> IronResult<Response> {
 
             // redirect to a random crate if query is empty
             if query.is_empty() {
-                let rows =  conn.query("SELECT crates.name, \
+                let rows = ctry!(conn.query("SELECT crates.name, \
                                                releases.version, \
                                                releases.target_name \
                                         FROM crates \
                                         INNER JOIN releases
                                               ON crates.latest_version_id = releases.id \
                                         WHERE github_stars >= 100 AND rustdoc_status = true \
-                                        OFFSET FLOOR(RANDOM() * 280) LIMIT 1", &[]).unwrap();
-                                        //                ~~~~~~^
-                                        // FIXME: This is a fast query but using a constant
-                                        //        There are currently 280 crates with docs and 100+
-                                        //        starts. This should be fine for a while.
+                                        OFFSET FLOOR(RANDOM() * 280) LIMIT 1",
+                                            &[]));
+                //                ~~~~~~^
+                // FIXME: This is a fast query but using a constant
+                //        There are currently 280 crates with docs and 100+
+                //        starts. This should be fine for a while.
                 let name: String = rows.get(0).get(0);
                 let version: String = rows.get(0).get(1);
                 let target_name: String = rows.get(0).get(2);
-                let url = Url::parse(&format!("{}://{}:{}/{}/{}/{}",
-                                              req.url.scheme,
-                                              req.url.host,
-                                              req.url.port,
-                                              name,
-                                              version,
-                                              target_name))
-                    .unwrap();
+                let url = ctry!(Url::parse(&format!("{}://{}:{}/{}/{}/{}",
+                                                    req.url.scheme,
+                                                    req.url.host,
+                                                    req.url.port,
+                                                    name,
+                                                    version,
+                                                    target_name)));
 
                 let mut resp = Response::with((status::Found, Redirect(url)));
                 use iron::headers::{Expires, HttpDate};
@@ -454,13 +437,12 @@ pub fn search_handler(req: &mut Request) -> IronResult<Response> {
 
 
             if let Some(version) = match_version(&conn, &query, None) {
-                let url = Url::parse(&format!("{}://{}:{}/crate/{}/{}",
+                let url = ctry!(Url::parse(&format!("{}://{}:{}/crate/{}/{}",
                                               req.url.scheme,
                                               req.url.host,
                                               req.url.port,
                                               query,
-                                              version)[..])
-                    .unwrap();
+                                              version)[..]));
                 let mut resp = Response::with((status::Found, Redirect(url)));
 
                 use iron::headers::{Expires, HttpDate};
@@ -488,11 +470,10 @@ pub fn search_handler(req: &mut Request) -> IronResult<Response> {
 
 
 pub fn activity_handler(req: &mut Request) -> IronResult<Response> {
-    let conn = req.extensions.get::<Pool>().unwrap();
+    let conn = extension!(req, Pool);
     let release_activity_data: Json =
-        conn.query("SELECT value FROM config WHERE name = 'release_activity'",
-                   &[])
-            .unwrap()
+        ctry!(conn.query("SELECT value FROM config WHERE name = 'release_activity'",
+                         &[]))
             .get(0)
             .get(0);
     Page::new(release_activity_data)