Properly sideload keywords in crates#show

The data is sent properly in this endpoint, but they aren't actually
associated with the crate as the ids aren't present. This appears to be
the only endpoint where these are sideloaded.

I've added a test for this, but haven't visually verified the fix (as I
don't have everything set up to run the backend locally), so this should
be tested on staging before deployment.

Fixes #271

Author: sgrif

src/krate.rs

@@ -59,6 +59,7 @@ pub struct EncodableCrate {
     pub name: String,
     pub updated_at: String,
     pub versions: Option<Vec<i32>>,
+    pub keywords: Option<Vec<String>>,
     pub created_at: String,
     pub downloads: i32,
     pub max_version: String,
@@ -231,7 +232,11 @@ impl Crate {
         parts.next().is_none()
     }
 
-    pub fn encodable(self, versions: Option<Vec<i32>>) -> EncodableCrate {
+    pub fn encodable(
+        self,
+        versions: Option<Vec<i32>>,
+        keywords: Option<&[Keyword]>,
+    ) -> EncodableCrate {
         let Crate {
             name, created_at, updated_at, downloads, max_version, description,
             homepage, documentation, license, repository,
@@ -241,13 +246,15 @@ impl Crate {
             Some(..) => None,
             None => Some(format!("/api/v1/crates/{}/versions", name)),
         };
+        let keyword_ids = keywords.map(|kws| kws.iter().map(|kw| kw.keyword.clone()).collect());
         EncodableCrate {
             id: name.clone(),
             name: name.clone(),
             updated_at: ::encode_time(updated_at),
             created_at: ::encode_time(created_at),
             downloads: downloads,
             versions: versions,
+            keywords: keyword_ids,
             max_version: max_version.to_string(),
             documentation: documentation,
             homepage: homepage,
@@ -548,7 +555,7 @@ pub fn index(req: &mut Request) -> CargoResult<Response> {
     let mut crates = Vec::new();
     for row in try!(stmt.query(&args)).iter() {
         let krate: Crate = Model::from_row(&row);
-        crates.push(krate.encodable(None));
+        crates.push(krate.encodable(None, None));
     }
 
     // Query for the total count of crates
@@ -583,7 +590,7 @@ pub fn summary(req: &mut Request) -> CargoResult<Response> {
         let rows = try!(stmt.query(&[]));
         Ok(rows.iter().map(|r| {
             let krate: Crate = Model::from_row(&r);
-            krate.encodable(None)
+            krate.encodable(None, None)
         }).collect::<Vec<EncodableCrate>>())
     };
     let new_crates = try!(tx.prepare("SELECT * FROM crates \
@@ -628,7 +635,7 @@ pub fn show(req: &mut Request) -> CargoResult<Response> {
         keywords: Vec<EncodableKeyword>,
     }
     Ok(req.json(&R {
-        krate: krate.clone().encodable(Some(ids)),
+        krate: krate.clone().encodable(Some(ids), Some(&kws)),
         versions: versions.into_iter().map(|v| {
             v.encodable(&krate.name)
         }).collect(),
@@ -750,7 +757,7 @@ pub fn new(req: &mut Request) -> CargoResult<Response> {
 
     #[derive(RustcEncodable)]
     struct R { krate: EncodableCrate }
-    Ok(req.json(&R { krate: krate.encodable(None) }))
+    Ok(req.json(&R { krate: krate.encodable(None, None) }))
 }
 
 fn parse_new_headers(req: &mut Request) -> CargoResult<(upload::NewCrate, User)> {

src/tests/krate.rs

@@ -11,7 +11,7 @@ use semver;
 use cargo_registry::db::RequestTransaction;
 use cargo_registry::dependency::EncodableDependency;
 use cargo_registry::download::EncodableVersionDownload;
-use cargo_registry::keyword::Keyword;
+use cargo_registry::keyword::{Keyword, EncodableKeyword};
 use cargo_registry::krate::{Crate, EncodableCrate};
 use cargo_registry::upload as u;
 use cargo_registry::user::EncodableUser;
@@ -28,7 +28,7 @@ struct GitCrate { name: String, vers: String, deps: Vec<String>, cksum: String }
 #[derive(RustcDecodable)]
 struct GoodCrate { krate: EncodableCrate }
 #[derive(RustcDecodable)]
-struct CrateResponse { krate: EncodableCrate, versions: Vec<EncodableVersion> }
+struct CrateResponse { krate: EncodableCrate, versions: Vec<EncodableVersion>, keywords: Vec<EncodableKeyword> }
 #[derive(RustcDecodable)]
 struct Deps { dependencies: Vec<EncodableDependency> }
 #[derive(RustcDecodable)]
@@ -136,7 +136,8 @@ fn show() {
     krate.description = Some(format!("description"));
     krate.documentation = Some(format!("https://example.com"));
     krate.homepage = Some(format!("http://example.com"));
-    ::mock_crate(&mut req, krate.clone());
+    let (krate, _) = ::mock_crate(&mut req, krate.clone());
+    Keyword::update_crate(tx(&req), &krate, &["kw1".into()]).unwrap();
 
     let mut response = ok_resp!(middle.call(&mut req));
     let json: CrateResponse = ::json(&mut response);
@@ -145,6 +146,7 @@ fn show() {
     assert_eq!(json.krate.description, krate.description);
     assert_eq!(json.krate.homepage, krate.homepage);
     assert_eq!(json.krate.documentation, krate.documentation);
+    assert_eq!(json.krate.keywords, Some(vec!["kw1".into()]));
     let versions = json.krate.versions.as_ref().unwrap();
     assert_eq!(versions.len(), 1);
     assert_eq!(json.versions.len(), 1);
@@ -154,6 +156,8 @@ fn show() {
     let suffix = "/api/v1/crates/foo/1.0.0/download";
     assert!(json.versions[0].dl_path.ends_with(suffix),
             "bad suffix {}", json.versions[0].dl_path);
+    assert_eq!(1, json.keywords.len());
+    assert_eq!("kw1".to_string(), json.keywords[0].id);
 }
 
 #[test]

src/user/mod.rs

@@ -311,7 +311,7 @@ pub fn updates(req: &mut Request) -> CargoResult<Response> {
     }
 
     // Encode everything!
-    let crates = crates.into_iter().map(|c| c.encodable(None)).collect();
+    let crates = crates.into_iter().map(|c| c.encodable(None, None)).collect();
     let versions = versions.into_iter().map(|v| {
         let id = v.crate_id;
         v.encodable(&map[&id])