Merge rust-lang#1247

1247: Split keyword and category functionality into MVC units r=carols10cents

This PR is based on rust-lang#1155 which is not yet merged to master.  This [comparison](jtgeibel/crates.io@add-mvc-modules...jtgeibel:mvc-keyword-and-category) shows just the changes built on top of that branch.

This PR moves the request handlers for keyword and category functionality to the `controllers` module.  I extracted the common `use` statements into a `controllers::prelude`.

`Encodable*` structs and the rfc3339 tests are moved under `views` and the remaining model structs, impls, and tests are moved under `models`.

Author: bors-voyager[bot]

src/controllers/category.rs

@@ -0,0 +1,89 @@
+use super::prelude::*;
+
+use models::Category;
+use schema::categories;
+use views::{EncodableCategory, EncodableCategoryWithSubcategories};
+
+/// Handles the `GET /categories` route.
+pub fn index(req: &mut Request) -> CargoResult<Response> {
+    let conn = req.db_conn()?;
+    let (offset, limit) = req.pagination(10, 100)?;
+    let query = req.query();
+    let sort = query.get("sort").map_or("alpha", String::as_str);
+
+    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 = Category::count_toplevel(&conn)?;
+
+    #[derive(Serialize)]
+    struct R {
+        categories: Vec<EncodableCategory>,
+        meta: Meta,
+    }
+    #[derive(Serialize)]
+    struct Meta {
+        total: i64,
+    }
+
+    Ok(req.json(&R {
+        categories: categories,
+        meta: Meta { total: total },
+    }))
+}
+
+/// Handles the `GET /categories/:category_id` route.
+pub fn show(req: &mut Request) -> CargoResult<Response> {
+    let slug = &req.params()["category_id"];
+    let conn = req.db_conn()?;
+    let cat = categories::table
+        .filter(categories::slug.eq(::lower(slug)))
+        .first::<Category>(&*conn)?;
+    let subcats = cat.subcategories(&conn)?
+        .into_iter()
+        .map(Category::encodable)
+        .collect();
+
+    let cat = cat.encodable();
+    let cat_with_subcats = EncodableCategoryWithSubcategories {
+        id: cat.id,
+        category: cat.category,
+        slug: cat.slug,
+        description: cat.description,
+        created_at: cat.created_at,
+        crates_cnt: cat.crates_cnt,
+        subcategories: subcats,
+    };
+
+    #[derive(Serialize)]
+    struct R {
+        category: EncodableCategoryWithSubcategories,
+    }
+    Ok(req.json(&R {
+        category: cat_with_subcats,
+    }))
+}
+
+/// Handles the `GET /category_slugs` route.
+pub fn slugs(req: &mut Request) -> CargoResult<Response> {
+    let conn = req.db_conn()?;
+    let slugs = categories::table
+        .select((categories::slug, categories::slug))
+        .order(categories::slug)
+        .load(&*conn)?;
+
+    #[derive(Serialize, Queryable)]
+    struct Slug {
+        id: String,
+        slug: String,
+    }
+
+    #[derive(Serialize)]
+    struct R {
+        category_slugs: Vec<Slug>,
+    }
+    Ok(req.json(&R {
+        category_slugs: slugs,
+    }))
+}

src/controllers/keyword.rs

@@ -0,0 +1,62 @@
+use super::prelude::*;
+
+use controllers::helpers::Paginate;
+use models::Keyword;
+use views::EncodableKeyword;
+
+/// Handles the `GET /keywords` route.
+pub fn index(req: &mut Request) -> CargoResult<Response> {
+    use schema::keywords;
+
+    let conn = req.db_conn()?;
+    let (offset, limit) = req.pagination(10, 100)?;
+    let query = req.query();
+    let sort = query.get("sort").map(|s| &s[..]).unwrap_or("alpha");
+
+    let mut query = keywords::table.into_boxed();
+
+    if sort == "crates" {
+        query = query.order(keywords::crates_cnt.desc());
+    } else {
+        query = query.order(keywords::keyword.asc());
+    }
+
+    let data = query
+        .paginate(limit, offset)
+        .load::<(Keyword, i64)>(&*conn)?;
+    let total = data.get(0).map(|&(_, t)| t).unwrap_or(0);
+    let kws = data.into_iter()
+        .map(|(k, _)| k.encodable())
+        .collect::<Vec<_>>();
+
+    #[derive(Serialize)]
+    struct R {
+        keywords: Vec<EncodableKeyword>,
+        meta: Meta,
+    }
+    #[derive(Serialize)]
+    struct Meta {
+        total: i64,
+    }
+
+    Ok(req.json(&R {
+        keywords: kws,
+        meta: Meta { total: total },
+    }))
+}
+
+/// Handles the `GET /keywords/:keyword_id` route.
+pub fn show(req: &mut Request) -> CargoResult<Response> {
+    let name = &req.params()["keyword_id"];
+    let conn = req.db_conn()?;
+
+    let kw = Keyword::find_by_keyword(&conn, name)?;
+
+    #[derive(Serialize)]
+    struct R {
+        keyword: EncodableKeyword,
+    }
+    Ok(req.json(&R {
+        keyword: kw.encodable(),
+    }))
+}

src/controllers/mod.rs

@@ -1,3 +1,15 @@
-// TODO: All endpoints would be moved to submodules here
+// TODO: Finish moving api endpoints to submodules here
+
+mod prelude {
+    pub use diesel::prelude::*;
+
+    pub use conduit::{Request, Response};
+    pub use conduit_router::RequestParams;
+    pub use db::RequestTransaction;
+    pub use util::{CargoResult, RequestUtils};
+}
 
 pub mod helpers;
+
+pub mod category;
+pub mod keyword;

src/lib.rs

@@ -65,7 +65,6 @@ use util::{R404, C, R};
 pub mod app;
 pub mod badge;
 pub mod boot;
-pub mod category;
 pub mod config;
 pub mod crate_owner_invitation;
 pub mod db;
@@ -75,7 +74,6 @@ pub mod download;
 pub mod git;
 pub mod github;
 pub mod http;
-pub mod keyword;
 pub mod krate;
 pub mod owner;
 pub mod render;
@@ -186,11 +184,11 @@ pub fn middleware(app: Arc<App>) -> MiddlewareBuilder {
         "/crates/:crate_id/reverse_dependencies",
         C(krate::metadata::reverse_dependencies),
     );
-    api_router.get("/keywords", C(keyword::index));
-    api_router.get("/keywords/:keyword_id", C(keyword::show));
-    api_router.get("/categories", C(category::index));
-    api_router.get("/categories/:category_id", C(category::show));
-    api_router.get("/category_slugs", C(category::slugs));
+    api_router.get("/keywords", C(controllers::keyword::index));
+    api_router.get("/keywords/:keyword_id", C(controllers::keyword::show));
+    api_router.get("/categories", C(controllers::category::index));
+    api_router.get("/categories/:category_id", C(controllers::category::show));
+    api_router.get("/category_slugs", C(controllers::category::slugs));
     api_router.get("/users/:user_id", C(user::show));
     api_router.put("/users/:user_id", C(user::update_user));
     api_router.get("/users/:user_id/stats", C(user::stats));

src/category.rs renamed to src/models/category.rs

@@ -1,13 +1,9 @@
 use chrono::NaiveDateTime;
-use conduit::{Request, Response};
-use conduit_router::RequestParams;
 use diesel::*;
 
-use db::RequestTransaction;
-use util::{CargoResult, RequestUtils};
-
 use models::Crate;
 use schema::*;
+use views::EncodableCategory;
 
 #[derive(Clone, Identifiable, Queryable, QueryableByName, Debug)]
 #[table_name = "categories"]
@@ -30,27 +26,6 @@ pub struct CrateCategory {
     category_id: i32,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct EncodableCategory {
-    pub id: String,
-    pub category: String,
-    pub slug: String,
-    pub description: String,
-    #[serde(with = "::util::rfc3339")] pub created_at: NaiveDateTime,
-    pub crates_cnt: i32,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct EncodableCategoryWithSubcategories {
-    pub id: String,
-    pub category: String,
-    pub slug: String,
-    pub description: String,
-    #[serde(with = "::util::rfc3339")] pub created_at: NaiveDateTime,
-    pub crates_cnt: i32,
-    pub subcategories: Vec<EncodableCategory>,
-}
-
 impl Category {
     pub fn encodable(self) -> EncodableCategory {
         let Category {
@@ -180,97 +155,11 @@ impl<'a> NewCategory<'a> {
     }
 }
 
-/// Handles the `GET /categories` route.
-pub fn index(req: &mut Request) -> CargoResult<Response> {
-    let conn = req.db_conn()?;
-    let (offset, limit) = req.pagination(10, 100)?;
-    let query = req.query();
-    let sort = query.get("sort").map_or("alpha", String::as_str);
-
-    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 = Category::count_toplevel(&conn)?;
-
-    #[derive(Serialize)]
-    struct R {
-        categories: Vec<EncodableCategory>,
-        meta: Meta,
-    }
-    #[derive(Serialize)]
-    struct Meta {
-        total: i64,
-    }
-
-    Ok(req.json(&R {
-        categories: categories,
-        meta: Meta { total: total },
-    }))
-}
-
-/// Handles the `GET /categories/:category_id` route.
-pub fn show(req: &mut Request) -> CargoResult<Response> {
-    let slug = &req.params()["category_id"];
-    let conn = req.db_conn()?;
-    let cat = categories::table
-        .filter(categories::slug.eq(::lower(slug)))
-        .first::<Category>(&*conn)?;
-    let subcats = cat.subcategories(&conn)?
-        .into_iter()
-        .map(Category::encodable)
-        .collect();
-
-    let cat = cat.encodable();
-    let cat_with_subcats = EncodableCategoryWithSubcategories {
-        id: cat.id,
-        category: cat.category,
-        slug: cat.slug,
-        description: cat.description,
-        created_at: cat.created_at,
-        crates_cnt: cat.crates_cnt,
-        subcategories: subcats,
-    };
-
-    #[derive(Serialize)]
-    struct R {
-        category: EncodableCategoryWithSubcategories,
-    }
-    Ok(req.json(&R {
-        category: cat_with_subcats,
-    }))
-}
-
-/// Handles the `GET /category_slugs` route.
-pub fn slugs(req: &mut Request) -> CargoResult<Response> {
-    let conn = req.db_conn()?;
-    let slugs = categories::table
-        .select((categories::slug, categories::slug))
-        .order(categories::slug)
-        .load(&*conn)?;
-
-    #[derive(Serialize, Queryable)]
-    struct Slug {
-        id: String,
-        slug: String,
-    }
-
-    #[derive(Serialize)]
-    struct R {
-        category_slugs: Vec<Slug>,
-    }
-    Ok(req.json(&R {
-        category_slugs: slugs,
-    }))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use chrono::NaiveDate;
     use diesel::connection::SimpleConnection;
     use dotenv::dotenv;
-    use serde_json;
     use std::env;
 
     fn pg_connection() -> PgConnection {
@@ -401,42 +290,4 @@ mod tests {
         let expected = vec![("Cat 3".to_string(), 6), ("Cat 1".to_string(), 3)];
         assert_eq!(expected, categories);
     }
-
-    #[test]
-    fn category_dates_serializes_to_rfc3339() {
-        let cat = EncodableCategory {
-            id: "".to_string(),
-            category: "".to_string(),
-            slug: "".to_string(),
-            description: "".to_string(),
-            crates_cnt: 1,
-            created_at: NaiveDate::from_ymd(2017, 1, 6).and_hms(14, 23, 11),
-        };
-        let json = serde_json::to_string(&cat).unwrap();
-        assert!(
-            json.as_str()
-                .find(r#""created_at":"2017-01-06T14:23:11+00:00""#)
-                .is_some()
-        );
-    }
-
-    #[test]
-    fn category_with_sub_dates_serializes_to_rfc3339() {
-        let cat = EncodableCategoryWithSubcategories {
-            id: "".to_string(),
-            category: "".to_string(),
-            slug: "".to_string(),
-            description: "".to_string(),
-            crates_cnt: 1,
-            created_at: NaiveDate::from_ymd(2017, 1, 6).and_hms(14, 23, 11),
-            subcategories: vec![],
-        };
-        let json = serde_json::to_string(&cat).unwrap();
-        assert!(
-            json.as_str()
-                .find(r#""created_at":"2017-01-06T14:23:11+00:00""#)
-                .is_some()
-        );
-    }
-
 }