Basic dependency modeling

This uh, hangs the interface. Good job steve

frontend/app/models/dependency.js

@@ -0,0 +1,8 @@
+import DS from 'ember-data';
+
+export default DS.Model.extend({
+  name: DS.attr('string'),
+  requirement: DS.attr('string'),
+  optional: DS.attr('boolean'),
+  versions: DS.belongsTo('version'),
+});

frontend/app/models/version.js

@@ -1,13 +1,8 @@
 import DS from 'ember-data';
 
-const {
-  Model,
-  attr,
-  belongsTo
-} = DS;
+export default DS.Model.extend({
+  name: DS.attr('string'),
 
-export default Model.extend({
-  name: attr('string'),
-
-  crate: belongsTo("crate"),
+  crate: DS.belongsTo("crate"),
+  dependencies: DS.hasMany('dependency'),
 });

frontend/app/templates/crate.hbs

@@ -4,6 +4,13 @@
 Versions:
 <ul>
   {{#each model.sortedVersions as |version|}}
-    <li>{{version.name}}</li>
+    <li>{{version.name}}
+      Deps:
+      <ul>
+        {{#each version.dependencies as |dep|}}
+          <li>{{dep.id}}</li> 
+        {{/each}}
+      </ul>
+    </li>
   {{/each}}
-</ul>
+</ul>

src/main.rs

@@ -77,10 +77,14 @@ fn crates(req: &mut Request) -> IronResult<Response> {
 
                 let id = format!("{}-{}", krate.id, v.id);
 
-                format!("{{\"type\": \"version\",\"id\": \"{}\"}}", id)
-            }).collect::<Vec<_>>().join(",");
+                let deps = v.dependencies.iter().map(|(_, d)| {
+                    format!("{{\"type\": \"dependency\", \"id\": \"{}\"}}", d.id)
+                }).collect::<Vec<_>>().join(",");
+
+                format!("{{\"type\": \"version\",\"id\": \"{}\",\"relationships\": {{\"dependencies\": {{\"data\": [{}]}}}}}}", id, deps)
+                }).collect::<Vec<_>>().join(",");
 
-            format!("{{\"id\": \"{}\", \"type\":\"crate\",\"relationships\": {{\"versions\": {{\"data\": [{}]}}}}}}", krate.id, krate_versions)
+                format!("{{\"id\": \"{}\", \"type\":\"crate\",\"relationships\": {{\"versions\": {{\"data\": [{}]}}}}}}", krate.id, krate_versions)
         }).collect::<Vec<String>>().join(",");
     } else {
         let krate = data.get(id.clone()).unwrap();
@@ -90,7 +94,11 @@ fn crates(req: &mut Request) -> IronResult<Response> {
 
             let id = format!("{}-{}", krate.id, v.id);
 
-            format!("{{\"type\": \"version\",\"id\": \"{}\"}}", id)
+            let deps = v.dependencies.iter().map(|(_, d)| {
+                format!("{{\"type\": \"dependency\", \"id\": \"{}\"}}", d.id)
+            }).collect::<Vec<_>>().join(",");
+
+            format!("{{\"type\": \"version\",\"id\": \"{}\",\"relationships\": {{\"dependencies\": {{\"data\": [{}]}}}}}}", id, deps)
         }).collect::<Vec<_>>().join(",");
 
         crates = format!("{{\"id\": \"{}\", \"type\":\"crate\",\"relationships\": {{\"versions\": {{\"data\": [{}]}}}}}}", krate.id, krate_versions);
@@ -104,14 +112,26 @@ fn crates(req: &mut Request) -> IronResult<Response> {
 
     json.push_str(",\"included\":[");
 
-    let included = versions.iter().map(|v| {
+    let included_versions = versions.iter().map(|v| {
         let id = format!("{}-{}", v.crate_id, v.id);
 
         format!("{{\"type\": \"version\",\"id\": \"{}\", \"crate-id\": \"{}\", \"attributes\": {{\"name\": \"{}\"}}}}", id, v.crate_id, v.id)
     }).collect::<Vec<_>>().join(",");
 
-    json.push_str(&included);
+    json.push_str(&included_versions);
+
+    json.push_str(",");
+
+    let mut included_dependencies = vec![];
+    for &version in versions.iter() {
+        for (_, d) in version.dependencies.iter() {
+            included_dependencies.push(format!("{{\"type\": \"dependency\",\"id\": \"{}\", \"version-id\": \"{}\", \"attributes\": {{\"name\": \"{}\",\"requirement\":\"{}\",\"optional\":{}}}}}", d.id, version.id, d.name, d.requirement, d.optional))
+        }
+    }
+
+    json.push_str(&(included_dependencies.join(",")));
+
     json.push_str("]}");
 
     Ok(Response::with((status::Ok, json)))
-}
+}

src/version.rs

@@ -1,4 +1,5 @@
 use serde_json::Value;
+use std::collections::BTreeMap;
 
 #[derive(Debug)]
 pub struct Version {
@@ -7,6 +8,15 @@ pub struct Version {
     pub name: String,
     pub checksum: String,
     pub yanked: bool,
+    pub dependencies: BTreeMap<String, Dependency>,
+}
+
+#[derive(Debug)]
+pub struct Dependency {
+    pub id: String,
+    pub name: String,
+    pub requirement: String,
+    pub optional: bool,
 }
 
 impl Version {
@@ -19,13 +29,33 @@ impl Version {
         let checksum = obj.get("cksum").unwrap().as_string().unwrap().to_string();
         let yanked = obj.get("yanked").unwrap().as_boolean().unwrap();
 
+        let raw_deps = obj.get("deps").unwrap().as_array().unwrap();
+
+        let mut dependencies = BTreeMap::new();
+
+        for dep in raw_deps.iter() {
+            let dep = dep.as_object().unwrap();
+
+            let name = dep.get("name").unwrap().as_string().unwrap().to_string();
+            let id = format!("{}-{}-{}", crate_id, id, name);
+            let requirement = dep.get("req").unwrap().as_string().unwrap().to_string();
+            let optional = dep.get("optional").unwrap().as_boolean().unwrap();
+
+            dependencies.insert(id.clone(), Dependency {
+                id: id,
+                name: name,
+                requirement: requirement,
+                optional: optional,
+            });
+        }
+
         Version {
             id: id,
             crate_id: crate_id,
             name: name,
             checksum: checksum,
             yanked: yanked,
+            dependencies: dependencies,
         }
     }
 }
-