Add API endpoint to retrieve the reverse dependencies.

This /api/v1/crates/foo/reverse_dependencies gives the full dependency
information about each crate that depends on foo (i.e. crates with
`[dependencies] foo = "..."`).

Author: huonw

src/krate.rs

@@ -17,6 +17,7 @@ use url::{mod, Url};
 use {Model, User, Keyword, Version};
 use app::{App, RequestApp};
 use db::{Connection, RequestTransaction};
+use dependency::{Dependency, EncodableDependency};
 use download::{VersionDownload, EncodableVersionDownload};
 use git;
 use keyword::EncodableKeyword;
@@ -319,6 +320,22 @@ impl Crate {
         let rows = try!(stmt.query(&[&self.id]));
         Ok(rows.map(|r| Model::from_row(&r)).collect())
     }
+
+    /// Returns (dependency, dependent crate name)
+    pub fn reverse_dependencies(&self, conn: &Connection) -> CargoResult<Vec<(Dependency, String)>> {
+        let stmt = try!(conn.prepare("SELECT dependencies.*,
+                                             crates.name AS crate_name
+                                      FROM dependencies
+                                      INNER JOIN versions
+                                        ON versions.id = dependencies.version_id
+                                      INNER JOIN crates
+                                        ON crates.id = versions.crate_id
+                                      WHERE dependencies.crate_id = $1
+                                        AND versions.num = crates.max_version"));
+        Ok(try!(stmt.query(&[&self.id])).map(|r| {
+            (Model::from_row(&r), r.get("crate_name"))
+        }).collect())
+    }
 }
 
 impl Model for Crate {
@@ -846,3 +863,18 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult<Response> {
     struct R { ok: bool }
     Ok(req.json(&R{ ok: true }))
 }
+
+pub fn reverse_dependencies(req: &mut Request) -> CargoResult<Response> {
+    let name = &req.params()["crate_id"];
+    let conn = try!(req.tx());
+    let krate = try!(Crate::find_by_name(conn, name.as_slice()));
+    let tx = try!(req.tx());
+    let rev_deps = try!(krate.reverse_dependencies(tx));
+    let rev_deps = rev_deps.into_iter().map(|(dep, crate_name)| {
+        dep.encodable(crate_name.as_slice())
+    }).collect();
+
+    #[deriving(Encodable)]
+    struct R { reverse_dependencies: Vec<EncodableDependency> }
+    Ok(req.json(&R{ reverse_dependencies: rev_deps }))
+}

src/lib.rs

@@ -89,6 +89,7 @@ pub fn middleware(app: Arc<App>) -> MiddlewareBuilder {
     api_router.delete("/crates/:crate_id/owners", C(krate::remove_owners));
     api_router.delete("/crates/:crate_id/:version/yank", C(version::yank));
     api_router.put("/crates/:crate_id/:version/unyank", C(version::unyank));
+    api_router.get("/crates/:crate_id/reverse_dependencies", C(krate::reverse_dependencies));
     api_router.get("/versions", C(version::index));
     api_router.get("/versions/:version_id", C(version::show));
     api_router.get("/keywords", C(keyword::index));