Merge pull request #38 from remram44/fix

Use correct package as root of dependency graph

Author: kbknapp

Cargo.lock

@@ -12,6 +12,7 @@ pub type CliResult<T> = Result<T, CliError>;
 pub enum CliErrorKind {
     UnknownBoolArg,
     TomlTableRoot,
+    TomlNoName,
     CurrentDir,
     Unknown,
     Io(io::Error),
@@ -23,6 +24,7 @@ impl CliErrorKind {
         match *self {
             CliErrorKind::Generic(ref e) => e,
             CliErrorKind::TomlTableRoot => "No root table found for toml file",
+            CliErrorKind::TomlNoName => "No name for package in toml file",
             CliErrorKind::CurrentDir => "Unable to determine the current working directory",
             CliErrorKind::UnknownBoolArg => "The value supplied isn't valid, either use 'true/false', 'yes/no', or the first letter of either.",
             CliErrorKind::Unknown => "An unknown fatal error has occurred, please consider filing a bug-report!",

src/error.rs

@@ -70,7 +70,7 @@ impl<'c, 'o> DepGraph<'c, 'o> {
     }
 
     pub fn remove(&mut self, id: usize) {
-        debugln!("remove; name={}; index={}", name, id);
+        debugln!("remove; index={}", id);
         self.nodes.remove(id);
         // Remove edges of the removed node.
         self.edges = self.edges.iter()
@@ -112,7 +112,7 @@ impl<'c, 'o> DepGraph<'c, 'o> {
                 debugln!("remove_orphans; idr={}", idr);
                 used[idr] = true;
             }
-            debugln!("remove_orphans; unsued_nodes={:?}", used);
+            debugln!("remove_orphans; unused_nodes={:?}", used);
 
             for (id, &u) in used.iter().enumerate() {
                 if !u {
@@ -166,12 +166,48 @@ impl<'c, 'o> DepGraph<'c, 'o> {
         }
     }
 
-    pub fn find_or_add(&mut self, name: &str, ver: &str) -> usize {
+    pub fn set_root(&mut self, name: &str, ver: &str) -> bool {
+        let root_id = if let Some(i) = self.find(name, ver) {
+            i
+        } else {
+            return false;
+        };
+        if root_id == 0 {
+            return true;
+        }
+
+        // Swap with 0
+        self.nodes.swap(0, root_id);
+
+        // Adjust edges
+        for edge in self.edges.iter_mut() {
+            if edge.0 == 0 {
+                edge.0 = root_id;
+            } else if edge.0 == root_id {
+                edge.0 = 0;
+            }
+            if edge.1 == 0 {
+                edge.1 = root_id;
+            } else if edge.1 == root_id {
+                edge.1 = 0;
+            }
+        }
+        true
+    }
+
+    pub fn find(&self, name: &str, ver: &str) -> Option<usize> {
         for (i, d) in self.nodes.iter().enumerate() {
             if d.name == name && d.ver == ver {
-                return i;
+                return Some(i);
             }
         }
+        None
+    }
+
+    pub fn find_or_add(&mut self, name: &str, ver: &str) -> usize {
+        if let Some(i) = self.find(name, ver) {
+            return i;
+        }
         self.nodes.push(ResolvedDep::new(name.to_owned(), ver.to_owned()));
         self.nodes.len() - 1
     }

src/graph.rs

@@ -21,8 +21,11 @@ impl<'c, 'o> Project<'c, 'o> {
     }
 
     pub fn graph(mut self) -> CliResult<DepGraph<'c, 'o>> {
-        let root_deps = try!(self.parse_root_deps());
+        let (root_deps, root_name, root_version) = try!(self.parse_root_deps());
         let mut dg = try!(self.parse_lock_file());
+        if !dg.set_root(&root_name, &root_version) {
+            return Err(From::from(CliErrorKind::TomlNoName));
+        }
         self.set_resolved_kind(&root_deps, &mut dg);
         if !self.cfg.include_vers {
             Project::show_version_on_duplicates(&mut dg);
@@ -155,8 +158,6 @@ impl<'c, 'o> Project<'c, 'o> {
 
         if let Some(root) = lock_toml.get("root") {
             parse_package(&mut dg, root);
-        } else {
-            return Err(From::from(CliErrorKind::TomlTableRoot));
         }
 
         if let Some(&Value::Array(ref packages)) = lock_toml.get("package") {
@@ -166,18 +167,39 @@ impl<'c, 'o> Project<'c, 'o> {
         }
 
         debugln!("return=parse_lock_file; self={:#?}", self);
+        debugln!("return=parse_lock_file; dg={:#?}", dg);
         Ok(dg)
     }
 
     /// Builds a list of the dependencies declared in the manifest file.
-    pub fn parse_root_deps(&mut self) -> CliResult<Vec<DeclaredDep>> {
+    pub fn parse_root_deps(&mut self) -> CliResult<(Vec<DeclaredDep>, String, String)> {
         debugln!("executing; parse_root_deps;");
         let manifest_path = try!(util::find_manifest_file(self.cfg.manifest_file));
         let manifest_toml = try!(util::toml_from_file(manifest_path));
 
         let mut declared_deps = vec![];
         let mut v = vec![];
 
+        let (root_name, root_version) = {
+            let mut name = None;
+            let mut version = None;
+            if let Some(table) = manifest_toml.get("package") {
+                if let Some(table) = table.as_table() {
+                    if let Some(&Value::String(ref n)) = table.get("name") {
+                        name = Some(n);
+                    }
+                    if let Some(&Value::String(ref v)) = table.get("version") {
+                        version = Some(v);
+                    }
+                }
+            }
+            if let (Some(n), Some(v)) = (name, version) {
+                (n.to_owned(), v.to_owned())
+            } else {
+                return Err(From::from(CliErrorKind::TomlNoName));
+            }
+        };
+
         if let Some(table) = manifest_toml.get("dependencies") {
             if let Some(table) = table.as_table() {
                 for (name, dep_table) in table.into_iter() {
@@ -202,6 +224,7 @@ impl<'c, 'o> Project<'c, 'o> {
 
         debugln!("return=parse_root_deps; self={:#?}", self);
         debugln!("return=parse_root_deps; declared_deps={:#?}", declared_deps);
-        Ok(declared_deps)
+        debugln!("return=parse_root_deps; root_name={:#?}", root_name);
+        Ok((declared_deps, root_name, root_version))
     }
 }