Show subcategories on a category's page

Author: carols10cents

app/models/category.js

@@ -6,5 +6,7 @@ export default DS.Model.extend({
     created_at: DS.attr('date'),
     crates_cnt: DS.attr('number'),
 
+    subcategories: DS.attr(),
+
     crates: DS.hasMany('crate', { async: true })
 });

app/templates/category/index.hbs

@@ -5,6 +5,25 @@
     <h1>{{ category.category }} Crates</h1>
 </div>
 
+{{#if category.subcategories }}
+  <div id='subcategories'>
+      <h2>Subcategories</h2>
+      <div class='white-rows'>
+          {{#each category.subcategories as |subcategory| }}
+              <div class='row'>
+                  <div class='info'>
+                      {{link-to subcategory.category "category" subcategory.slug}}
+                      <span class='vers small'>
+                          {{ format-num subcategory.crates_cnt }}
+                          crates
+                      </span>
+                  </div>
+              </div>
+          {{/each}}
+      </div>
+  </div>
+{{/if}}
+
 <div id='results'>
     <div class='nav'>
         <span class='amt small'>

src/category.rs

@@ -29,6 +29,16 @@ pub struct EncodableCategory {
     pub crates_cnt: i32,
 }
 
+#[derive(RustcEncodable, RustcDecodable)]
+pub struct EncodableCategoryWithSubcategories {
+    pub id: String,
+    pub category: String,
+    pub slug: String,
+    pub created_at: String,
+    pub crates_cnt: i32,
+    pub subcategories: Vec<EncodableCategory>,
+}
+
 impl Category {
     pub fn find_by_category(conn: &GenericConnection, name: &str)
                             -> CargoResult<Category> {
@@ -127,6 +137,14 @@ impl Category {
         let rows = try!(stmt.query(&[]));
         Ok(rows.iter().next().unwrap().get("count"))
     }
+
+    pub fn subcategories(&self, conn: &GenericConnection)
+                                -> CargoResult<Vec<Category>> {
+        let stmt = try!(conn.prepare("SELECT * FROM categories \
+                                      WHERE category ILIKE $1 || '::%'"));
+        let rows = try!(stmt.query(&[&self.category]));
+        Ok(rows.iter().map(|r| Model::from_row(&r)).collect())
+    }
 }
 
 impl Model for Category {
@@ -153,10 +171,20 @@ pub fn index(req: &mut Request) -> CargoResult<Response> {
         _ => "ORDER BY category ASC",
     };
 
-    // Collect all the top-level categories
+    // Collect all the top-level categories and sum up the crates_cnt of
+    // the crates in all subcategories
     let stmt = try!(conn.prepare(&format!(
-        "SELECT * FROM categories \
-         WHERE category NOT LIKE '%::%' {} \
+        "SELECT c.id, c.category, c.slug, c.created_at, \
+                counts.sum::int as crates_cnt \
+         FROM categories as c \
+         LEFT JOIN ( \
+             SELECT split_part(categories.category, '::', 1), \
+                    sum(categories.crates_cnt) \
+             FROM categories \
+             GROUP BY split_part(categories.category, '::', 1) \
+         ) as counts \
+         ON c.category = counts.split_part \
+         WHERE c.category NOT LIKE '%::%' {} \
          LIMIT $1 OFFSET $2",
          sort_sql
     )));
@@ -188,8 +216,20 @@ 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| {
+        s.encodable()
+    }).collect();
+    let cat = cat.encodable();
+    let cat_with_subcats = EncodableCategoryWithSubcategories {
+        id: cat.id,
+        category: cat.category,
+        slug: cat.slug,
+        created_at: cat.created_at,
+        crates_cnt: cat.crates_cnt,
+        subcategories: subcats,
+    };
 
     #[derive(RustcEncodable)]
-    struct R { category: EncodableCategory }
-    Ok(req.json(&R { category: cat.encodable() }))
+    struct R { category: EncodableCategoryWithSubcategories}
+    Ok(req.json(&R { category: cat_with_subcats }))
 }

src/tests/category.rs

@@ -3,14 +3,18 @@ use conduit::{Handler, Request, Method};
 use conduit_test::MockRequest;
 
 use cargo_registry::db::RequestTransaction;
-use cargo_registry::category::{Category, EncodableCategory};
+use cargo_registry::category::{Category, EncodableCategory, EncodableCategoryWithSubcategories};
 
 #[derive(RustcDecodable)]
 struct CategoryList { categories: Vec<EncodableCategory>, meta: CategoryMeta }
 #[derive(RustcDecodable)]
 struct CategoryMeta { total: i32 }
 #[derive(RustcDecodable)]
 struct GoodCategory { category: EncodableCategory }
+#[derive(RustcDecodable)]
+struct CategoryWithSubcategories {
+    category: EncodableCategoryWithSubcategories
+}
 
 #[test]
 fn index() {
@@ -39,15 +43,23 @@ fn index() {
 #[test]
 fn show() {
     let (_b, app, middle) = ::app();
+
+    // Return not found if a category doesn't exist
     let mut req = ::req(app, Method::Get, "/api/v1/categories/foo-bar");
     let response = t_resp!(middle.call(&mut req));
     assert_eq!(response.status.0, 404);
 
+    // Create a category and a subcategory
     ::mock_category(&mut req, "Foo Bar", "foo-bar");
+    ::mock_category(&mut req, "Foo Bar::Baz", "foo-bar::baz");
+
+    // The category and its subcategories should be in the json
     let mut response = ok_resp!(middle.call(&mut req));
-    let json: GoodCategory = ::json(&mut response);
+    let json: CategoryWithSubcategories = ::json(&mut response);
     assert_eq!(json.category.category, "Foo Bar");
     assert_eq!(json.category.slug, "foo-bar");
+    assert_eq!(json.category.subcategories.len(), 1);
+    assert_eq!(json.category.subcategories[0].category, "Foo Bar::Baz");
 }
 
 fn tx(req: &Request) -> &GenericConnection { req.tx().unwrap() }