Merge pull request #272 from sgrif/sg-sideload-keywords-in-crates-show

Properly sideload keywords in crates#show

Author: alexcrichton

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])