Replace try with ?

Author: Eh2406

src/category.rs

@@ -45,19 +45,19 @@ pub struct EncodableCategoryWithSubcategories {
 impl Category {
     pub fn find_by_category(conn: &GenericConnection, name: &str)
                             -> CargoResult<Category> {
-        let stmt = try!(conn.prepare("SELECT * FROM categories \
-                                      WHERE category = $1"));
-        let rows = try!(stmt.query(&[&name]));
+        let stmt = conn.prepare("SELECT * FROM categories \
+                                      WHERE category = $1")?;
+        let rows = stmt.query(&[&name])?;
         rows.iter().next()
                    .chain_error(|| NotFound)
                    .map(|row| Model::from_row(&row))
     }
 
     pub fn find_by_slug(conn: &GenericConnection, slug: &str)
                             -> CargoResult<Category> {
-        let stmt = try!(conn.prepare("SELECT * FROM categories \
-                                      WHERE slug = LOWER($1)"));
-        let rows = try!(stmt.query(&[&slug]));
+        let stmt = conn.prepare("SELECT * FROM categories \
+                                      WHERE slug = LOWER($1)")?;
+        let rows = stmt.query(&[&slug])?;
         rows.iter().next()
                    .chain_error(|| NotFound)
                    .map(|row| Model::from_row(&row))
@@ -80,7 +80,7 @@ impl Category {
     pub fn update_crate(conn: &GenericConnection,
                         krate: &Crate,
                         categories: &[String]) -> CargoResult<Vec<String>> {
-        let old_categories = try!(krate.categories(conn));
+        let old_categories = krate.categories(conn)?;
         let old_categories_ids: HashSet<_> = old_categories.iter().map(|cat| {
             cat.id
         }).collect();
@@ -112,21 +112,21 @@ impl Category {
                                 .collect();
 
         if !to_rm.is_empty() {
-            try!(conn.execute("DELETE FROM crates_categories \
+            conn.execute("DELETE FROM crates_categories \
                                 WHERE category_id = ANY($1) \
                                   AND crate_id = $2",
-                              &[&to_rm, &krate.id]));
+                         &[&to_rm, &krate.id])?;
         }
 
         if !to_add.is_empty() {
             let insert: Vec<_> = to_add.into_iter().map(|id| {
                 format!("({}, {})", krate.id, id)
             }).collect();
             let insert = insert.join(", ");
-            try!(conn.execute(&format!("INSERT INTO crates_categories \
+            conn.execute(&format!("INSERT INTO crates_categories \
                                         (crate_id, category_id) VALUES {}",
-                                       insert),
-                              &[]));
+                                  insert),
+                         &[])?;
         }
 
         Ok(invalid_categories)
@@ -139,8 +139,8 @@ impl Category {
             WHERE category NOT LIKE '%::%'",
             Model::table_name(None::<Self>
         ));
-        let stmt = try!(conn.prepare(&sql));
-        let rows = try!(stmt.query(&[]));
+        let stmt = conn.prepare(&sql)?;
+        let rows = stmt.query(&[])?;
         Ok(rows.iter().next().unwrap().get("count"))
     }
 
@@ -156,7 +156,7 @@ impl Category {
 
         // Collect all the top-level categories and sum up the crates_cnt of
         // the crates in all subcategories
-        let stmt = try!(conn.prepare(&format!(
+        let stmt = conn.prepare(&format!(
             "SELECT c.id, c.category, c.slug, c.description, c.created_at, \
                 COALESCE (( \
                     SELECT sum(c2.crates_cnt)::int \
@@ -167,10 +167,10 @@ impl Category {
              FROM categories as c \
              WHERE c.category NOT LIKE '%::%' {} \
              LIMIT $1 OFFSET $2",
-             sort_sql
-        )));
+            sort_sql
+        ))?;
 
-        let categories: Vec<_> = try!(stmt.query(&[&limit, &offset]))
+        let categories: Vec<_> = stmt.query(&[&limit, &offset])?
             .iter()
             .map(|row| Model::from_row(&row))
             .collect();
@@ -180,7 +180,7 @@ impl Category {
 
     pub fn subcategories(&self, conn: &GenericConnection)
                                 -> CargoResult<Vec<Category>> {
-        let stmt = try!(conn.prepare("\
+        let stmt = conn.prepare("\
             SELECT c.id, c.category, c.slug, c.description, c.created_at, \
             COALESCE (( \
                 SELECT sum(c2.crates_cnt)::int \
@@ -190,9 +190,9 @@ impl Category {
             ), 0) as crates_cnt \
             FROM categories as c \
             WHERE c.category ILIKE $1 || '::%' \
-            AND c.category NOT ILIKE $1 || '::%::%'"));
+            AND c.category NOT ILIKE $1 || '::%::%'")?;
 
-        let rows = try!(stmt.query(&[&self.category]));
+        let rows = stmt.query(&[&self.category])?;
         Ok(rows.iter().map(|r| Model::from_row(&r)).collect())
     }
 }
@@ -213,16 +213,16 @@ impl Model for Category {
 
 /// Handles the `GET /categories` route.
 pub fn index(req: &mut Request) -> CargoResult<Response> {
-    let conn = try!(req.tx());
-    let (offset, limit) = try!(req.pagination(10, 100));
+    let conn = req.tx()?;
+    let (offset, limit) = req.pagination(10, 100)?;
     let query = req.query();
     let sort = query.get("sort").map_or("alpha", String::as_str);
 
-    let categories = try!(Category::toplevel(conn, sort, limit, offset));
+    let categories = Category::toplevel(conn, sort, limit, offset)?;
     let categories = categories.into_iter().map(Category::encodable).collect();
 
     // Query for the total count of categories
-    let total = try!(Category::count_toplevel(conn));
+    let total = Category::count_toplevel(conn)?;
 
     #[derive(RustcEncodable)]
     struct R { categories: Vec<EncodableCategory>, meta: Meta }
@@ -238,9 +238,9 @@ pub fn index(req: &mut Request) -> CargoResult<Response> {
 /// Handles the `GET /categories/:category_id` route.
 pub fn show(req: &mut Request) -> CargoResult<Response> {
     let slug = &req.params()["category_id"];
-    let conn = try!(req.tx());
-    let cat = try!(Category::find_by_slug(&*conn, &slug));
-    let subcats = try!(cat.subcategories(&*conn)).into_iter().map(|s| {
+    let conn = req.tx()?;
+    let cat = Category::find_by_slug(&*conn, &slug)?;
+    let subcats = cat.subcategories(&*conn)?.into_iter().map(|s| {
         s.encodable()
     }).collect();
     let cat = cat.encodable();
@@ -261,10 +261,10 @@ pub fn show(req: &mut Request) -> CargoResult<Response> {
 
 /// Handles the `GET /category_slugs` route.
 pub fn slugs(req: &mut Request) -> CargoResult<Response> {
-    let conn = try!(req.tx());
-    let stmt = try!(conn.prepare("SELECT slug FROM categories \
-                                  ORDER BY slug"));
-    let rows = try!(stmt.query(&[]));
+    let conn = req.tx()?;
+    let stmt = conn.prepare("SELECT slug FROM categories \
+                                  ORDER BY slug")?;
+    let rows = stmt.query(&[])?;
 
     #[derive(RustcEncodable)]
     struct Slug { id: String, slug: String }

src/dependency.rs

@@ -51,14 +51,14 @@ impl Dependency {
                   -> CargoResult<Dependency> {
         let req = req.to_string();
         let features = features.join(",");
-        let stmt = try!(conn.prepare("INSERT INTO dependencies
+        let stmt = conn.prepare("INSERT INTO dependencies
                                       (version_id, crate_id, req, optional,
                                        default_features, features, target, kind)
                                       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-                                      RETURNING *"));
-        let rows = try!(stmt.query(&[&version_id, &crate_id, &req,
-                                      &optional, &default_features,
-                                      &features, target, &(kind as i32)]));
+                                      RETURNING *")?;
+        let rows = stmt.query(&[&version_id, &crate_id, &req,
+            &optional, &default_features,
+            &features, target, &(kind as i32)])?;
         Ok(Model::from_row(&rows.iter().next().unwrap()))
     }
 

src/keyword.rs

@@ -31,27 +31,27 @@ pub struct EncodableKeyword {
 impl Keyword {
     pub fn find_by_keyword(conn: &GenericConnection, name: &str)
                            -> CargoResult<Option<Keyword>> {
-        let stmt = try!(conn.prepare("SELECT * FROM keywords \
-                                      WHERE keyword = LOWER($1)"));
-        let rows = try!(stmt.query(&[&name]));
+        let stmt = conn.prepare("SELECT * FROM keywords \
+                                      WHERE keyword = LOWER($1)")?;
+        let rows = stmt.query(&[&name])?;
         Ok(rows.iter().next().map(|r| Model::from_row(&r)))
     }
 
     pub fn find_or_insert(conn: &GenericConnection, name: &str)
                           -> CargoResult<Keyword> {
         // TODO: racy (the select then insert is not atomic)
-        let stmt = try!(conn.prepare("SELECT * FROM keywords
-                                      WHERE keyword = LOWER($1)"));
-        for row in try!(stmt.query(&[&name])).iter() {
+        let stmt = conn.prepare("SELECT * FROM keywords
+                                      WHERE keyword = LOWER($1)")?;
+        for row in stmt.query(&[&name])?.iter() {
             return Ok(Model::from_row(&row))
         }
 
-        let stmt = try!(conn.prepare("INSERT INTO keywords (keyword) VALUES (LOWER($1))
-                                      RETURNING *"));
-        let rows = try!(stmt.query(&[&name]));
-        Ok(Model::from_row(&try!(rows.iter().next().chain_error(|| {
+        let stmt = conn.prepare("INSERT INTO keywords (keyword) VALUES (LOWER($1))
+                                      RETURNING *")?;
+        let rows = stmt.query(&[&name])?;
+        Ok(Model::from_row(&rows.iter().next().chain_error(|| {
             internal("no version returned")
-        }))))
+        })?))
     }
 
     pub fn all(conn: &GenericConnection, sort: &str, limit: i64, offset: i64)
@@ -62,11 +62,11 @@ impl Keyword {
            _ => "ORDER BY keyword ASC",
         };
 
-        let stmt = try!(conn.prepare(&format!("SELECT * FROM keywords {}
+        let stmt = conn.prepare(&format!("SELECT * FROM keywords {}
                                                LIMIT $1 OFFSET $2",
-                                               sort_sql)));
+                                         sort_sql))?;
 
-        let keywords: Vec<_> = try!(stmt.query(&[&limit, &offset]))
+        let keywords: Vec<_> = stmt.query(&[&limit, &offset])?
             .iter()
             .map(|row| Model::from_row(&row))
             .collect();
@@ -94,14 +94,14 @@ impl Keyword {
     pub fn update_crate(conn: &GenericConnection,
                         krate: &Crate,
                         keywords: &[String]) -> CargoResult<()> {
-        let old_kws = try!(krate.keywords(conn));
+        let old_kws = krate.keywords(conn)?;
         let old_kws = old_kws.iter().map(|kw| {
             (&kw.keyword[..], kw)
         }).collect::<HashMap<_, _>>();
-        let new_kws = try!(keywords.iter().map(|k| {
-            let kw = try!(Keyword::find_or_insert(conn, &k));
+        let new_kws = keywords.iter().map(|k| {
+            let kw = Keyword::find_or_insert(conn, &k)?;
             Ok((&k[..], kw))
-        }).collect::<CargoResult<HashMap<_, _>>>());
+        }).collect::<CargoResult<HashMap<_, _>>>()?;
 
         let to_rm = old_kws.iter().filter(|&(kw, _)| {
             !new_kws.contains_key(kw)
@@ -111,10 +111,10 @@ impl Keyword {
         }).map(|(_, v)| v.id).collect::<Vec<_>>();
 
         if to_rm.len() > 0 {
-            try!(conn.execute("DELETE FROM crates_keywords
+            conn.execute("DELETE FROM crates_keywords
                                 WHERE keyword_id = ANY($1)
                                   AND crate_id = $2",
-                              &[&to_rm, &krate.id]));
+                         &[&to_rm, &krate.id])?;
         }
 
         if to_add.len() > 0 {
@@ -123,10 +123,10 @@ impl Keyword {
                 let id: i32 = *id;
                 format!("({}, {})", crate_id,  id)
             }).collect::<Vec<_>>().join(", ");
-            try!(conn.execute(&format!("INSERT INTO crates_keywords
+            conn.execute(&format!("INSERT INTO crates_keywords
                                         (crate_id, keyword_id) VALUES {}",
-                                       insert),
-                              &[]));
+                                  insert),
+                         &[])?;
         }
 
         Ok(())
@@ -147,16 +147,16 @@ impl Model for Keyword {
 
 /// Handles the `GET /keywords` route.
 pub fn index(req: &mut Request) -> CargoResult<Response> {
-    let conn = try!(req.tx());
-    let (offset, limit) = try!(req.pagination(10, 100));
+    let conn = req.tx()?;
+    let (offset, limit) = req.pagination(10, 100)?;
     let query = req.query();
     let sort = query.get("sort").map(|s| &s[..]).unwrap_or("alpha");
 
-    let keywords = try!(Keyword::all(conn, sort, limit, offset));
+    let keywords = Keyword::all(conn, sort, limit, offset)?;
     let keywords = keywords.into_iter().map(Keyword::encodable).collect();
 
     // Query for the total count of keywords
-    let total = try!(Keyword::count(conn));
+    let total = Keyword::count(conn)?;
 
     #[derive(RustcEncodable)]
     struct R { keywords: Vec<EncodableKeyword>, meta: Meta }
@@ -172,9 +172,9 @@ pub fn index(req: &mut Request) -> CargoResult<Response> {
 /// Handles the `GET /keywords/:keyword_id` route.
 pub fn show(req: &mut Request) -> CargoResult<Response> {
     let name = &req.params()["keyword_id"];
-    let conn = try!(req.tx());
-    let kw = try!(Keyword::find_by_keyword(&*conn, &name));
-    let kw = try!(kw.chain_error(|| NotFound));
+    let conn = req.tx()?;
+    let kw = Keyword::find_by_keyword(&*conn, &name)?;
+    let kw = kw.chain_error(|| NotFound)?;
 
     #[derive(RustcEncodable)]
     struct R { keyword: EncodableKeyword }