fix(Dev Deps): fixes a bug where dev deps are not properly filtered

Closes #4

Author: kbknapp

src/dep.rs

@@ -2,7 +2,7 @@ use std::io::{Result, Write};
 
 use config::Config;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub enum DepKind {
     Build,
     Dev,

src/graph.rs

@@ -62,6 +62,54 @@ impl<'c, 'o> DepGraph<'c, 'o> {
         None
     }
 
+    pub fn update_style(&mut self, name: &str, kind: DepKind) {
+        if let Some(id) = self.find(name) {
+            if let Some(dep) = self.get_mut(id) {
+                dep.kind = kind;
+            }
+        }
+    }
+
+    pub fn remove(&mut self, name: &str) {
+        if let Some(id) = self.find(name) {
+            debugln!("Removing node: {} index {}", name, id);
+            self.nodes.remove(id);
+        }
+    }
+
+    pub fn remove_orphans(&mut self) {
+        let len = self.nodes.len();
+        loop {
+            let mut to_rem = None;
+            for (eid, &Ed(idl, idr)) in self.edges.iter().enumerate() {
+                if idl > len || idr > len {
+                    to_rem = Some(eid);
+                }
+            }
+            if let Some(id) = to_rem {
+                self.edges.remove(id);
+                continue;
+            }
+            break;
+        }
+    }
+
+    pub fn get_mut(&mut self, id: usize) -> Option<&mut Dep> {
+        if id < self.nodes.len() {
+            return Some(&mut self.nodes[id]);
+        }
+        None
+    }
+
+    pub fn find(&self, name: &str) -> Option<usize> {
+        for (i, d) in self.nodes.iter().enumerate() {
+            if d.name == name {
+                return Some(i);
+            }
+        }
+        None
+    }
+
     pub fn find_or_add(&mut self, new: &str, k: DepKind) -> usize {
         for (i, d) in self.nodes.iter().enumerate() {
             if d.name == new {
@@ -72,7 +120,8 @@ impl<'c, 'o> DepGraph<'c, 'o> {
         self.nodes.len() - 1
     }
 
-    pub fn render_to<W: Write>(self, output: &mut W) -> CliResult<()> {
+    pub fn render_to<W: Write>(mut self, output: &mut W) -> CliResult<()> {
+        self.remove_orphans();
         try!(writeln!(output, "{}", "digraph dependencies {"));
         for (i, dep) in self.nodes.iter().enumerate() {
             try!(write!(output, "\tN{}", i));
@@ -85,4 +134,5 @@ impl<'c, 'o> DepGraph<'c, 'o> {
         try!(writeln!(output, "{}", "}"));
         Ok(())
     }
+
 }

src/main.rs

@@ -239,6 +239,7 @@ mod fmt;
 mod project;
 mod dep;
 mod config;
+mod util;
 
 static LINE_STYLES: [&'static str; 3] = ["solid", "dotted", "dashed"];
 static COLORS: [&'static str; 8] = ["blue", "black", "yellow", "purple", "green", "red", "white",
@@ -374,14 +375,12 @@ fn main() {
     if let Some(m) = m.subcommand_matches("graph") {
         let cfg = Config::from_matches(m).unwrap_or_else(|e| e.exit());
         debugln!("cfg={:#?}", cfg);
-        if let Err(e) = execute(cfg) {
-            e.exit();
-        }
+        execute(cfg).map_err(|e| e.exit() ).unwrap();
     }
 }
 
 fn execute(cfg: Config) -> CliResult<()> {
-    let project = try!(Project::from_config(&cfg));
+    let project = try!(Project::with_config(&cfg));
     let graph = try!(project.graph());
 
     match cfg.dot_file {

src/project.rs

@@ -1,126 +1,121 @@
-use std::io::Read;
-use std::env;
-use std::fs::{self, File};
-use std::path::{Path, PathBuf};
+use std::collections::HashMap;
 
-use toml::{self, Table, Value};
+use toml::Value;
 
 use dep::{Dep, DepKind};
 use graph::DepGraph;
 use error::{CliErrorKind, CliResult};
 use config::Config;
+use util;
+
+macro_rules! propagate_kind {
+    ($me:ident, $kind:expr) => ({
+        let mut changes = false;
+        loop {
+            for (dep, children) in &$me.dep_tree {
+                if $me.styles.get(dep).unwrap() == &$kind {
+                    for child in children {
+                        if $me.styles.get(child).unwrap() != &$kind {
+                            *$me.styles.get_mut(child).unwrap() = $kind;
+                            changes = true;
+                        }
+                    }
+                }
+            }
+            if !changes { break; }
+            changes = false;
+        }
+    });
+}
 
 pub struct Project<'c, 'o>
     where 'o: 'c
 {
-    pwd: PathBuf,
     cfg: &'c Config<'o>,
+    styles: HashMap<String, DepKind>,
+    dep_tree: HashMap<String, Vec<String>>,
+    blacklist: Vec<String>
 }
 
 impl<'c, 'o> Project<'c, 'o> {
-    pub fn from_config(cfg: &'c Config<'o>) -> CliResult<Self> {
-        let pwd = try!(env::current_dir());
-
+    pub fn with_config(cfg: &'c Config<'o>) -> CliResult<Self> {
         Ok(Project {
-            pwd: pwd,
             cfg: cfg,
+            styles: HashMap::new(),
+            dep_tree: HashMap::new(),
+            blacklist: vec![]
         })
     }
 
-    fn find_project_file(&self, file: &str) -> CliResult<PathBuf> {
-        let mut pwd = self.pwd.as_path();
+    pub fn graph(mut self) -> CliResult<DepGraph<'c, 'o>> {
+        let mut dg = try!(self.parse_root_deps());
 
-        loop {
-            let manifest = pwd.join(file);
-            if let Ok(metadata) = fs::metadata(&manifest) {
-                if metadata.is_file() {
-                    return Ok(manifest);
-                }
-            }
+        try!(self.parse_lock_file(&mut dg));
 
-            match pwd.parent() {
-                Some(p) => pwd = p,
-                None => break,
-            }
-        }
+        self.update_styles(&mut dg);
 
-        Err(From::from(CliErrorKind::Generic(format!("Could not find `{}` in `{}` or any \
-                                                      parent directory, or it isn't a valid \
-                                                      lock-file",
-                                                     file,
-                                                     pwd.display()))))
+        Ok(dg)
     }
 
-    fn toml_from_file<P: AsRef<Path>>(p: P) -> CliResult<Box<Table>> {
-        debugln!("executing; from_file; file={:?}", p.as_ref());
-        let mut f = try!(File::open(p.as_ref()));
-
-        let mut s = String::new();
-        try!(f.read_to_string(&mut s));
-
-        let mut parser = toml::Parser::new(&s);
-        match parser.parse() {
-            Some(toml) => return Ok(Box::new(toml)),
-            None => {}
-        }
-
-        // On err
-        let mut error_str = format!("could not parse input as TOML\n");
-        for error in parser.errors.iter() {
-            let (loline, locol) = parser.to_linecol(error.lo);
-            let (hiline, hicol) = parser.to_linecol(error.hi);
-            error_str.push_str(&format!("{:?}:{}:{}{} {}\n",
-                                        f,
-                                        loline + 1,
-                                        locol + 1,
-                                        if loline != hiline || locol != hicol {
-                                            format!("-{}:{}", hiline + 1, hicol + 1)
-                                        } else {
-                                            "".to_owned()
-                                        },
-                                        error.desc));
+    fn update_styles(&mut self, dg: &mut DepGraph<'c, 'o>) {
+        propagate_kind!(self, DepKind::Dev);
+        propagate_kind!(self, DepKind::Optional);
+        propagate_kind!(self, DepKind::Build);
+        for (name, kind) in &self.styles {
+            if (*kind == DepKind::Dev && !self.cfg.dev_deps) ||
+                (*kind == DepKind::Optional && !self.cfg.optional_deps) ||
+                (*kind == DepKind::Build && !self.cfg.build_deps) {
+                dg.remove(&*name);
+            } else {
+                dg.update_style(&*name, *kind);
+            }
         }
-        Err(From::from(CliErrorKind::Generic(error_str)))
+        dg.remove_orphans();
     }
 
-    pub fn graph(mut self) -> CliResult<DepGraph<'c, 'o>> {
-        let dg = try!(self.parse_root_deps());
-
-        self.parse_lock_file(dg)
-    }
-
-    fn parse_lock_file(&self, mut dg: DepGraph<'c, 'o>) -> CliResult<DepGraph<'c, 'o>> {
-        let lock_path = try!(self.find_project_file(self.cfg.lock_file));
-        let lock_toml = try!(Project::toml_from_file(lock_path));
+    fn parse_lock_file(&mut self, dg: &mut DepGraph<'c, 'o>) -> CliResult<()> {
+        let lock_path = try!(util::find_manifest_file(self.cfg.lock_file));
+        let lock_toml = try!(util::toml_from_file(lock_path));
 
         if let Some(&Value::Array(ref packages)) = lock_toml.get("package") {
             for pkg in packages {
+                let mut children = vec![];
                 let name = pkg.lookup("name")
                               .expect("no 'name' field in Cargo.lock [package] table")
                               .as_str()
                               .expect("'name' field of [package] table in Cargo.lock was not a \
-                                       valid string");
-                let id = dg.find_or_add(name, DepKind::Build);
+                                       valid string").to_owned();
+                let kind = match self.styles.get(&name) {
+                    Some(k) => k.clone(),
+                    None    => DepKind::Build
+                };
+                let id = dg.find_or_add(&*name, kind);
 
                 if let Some(&Value::Array(ref deps)) = pkg.lookup("dependencies") {
                     for dep in deps {
                         let dep_string =
                             dep.as_str().unwrap_or("").split(" ").collect::<Vec<_>>()[0];
 
-                        dg.add_child(id, dep_string, None);
+                        children.push(dep_string.to_owned());
+                        self.styles.insert(dep_string.to_owned(), kind);
+                        dg.add_child(id, dep_string, Some(kind));
                     }
+                    self.dep_tree.insert(name.to_owned(), children);
+                } else {
+                    self.dep_tree.insert(name.to_owned(), vec![]);
                 }
+                self.styles.insert(name.to_owned(), kind);
             }
         }
 
         debugln!("all lock deps: {:#?}", dg);
-        Ok(dg)
+        Ok(())
     }
 
     pub fn parse_root_deps(&mut self) -> CliResult<DepGraph<'c, 'o>> {
         debugln!("executing; parse_root_deps;");
-        let manifest_path = try!(self.find_project_file(self.cfg.manifest_file));
-        let manifest_toml = try!(Project::toml_from_file(manifest_path));
+        let manifest_path = try!(util::find_manifest_file(self.cfg.manifest_file));
+        let manifest_toml = try!(util::toml_from_file(manifest_path));
         let root_table = match manifest_toml.get("package") {
             Some(table) => table,
             None => return Err(From::from(CliErrorKind::TomlTableRoot)),
@@ -140,30 +135,34 @@ impl<'c, 'o> Project<'c, 'o> {
 
         if let Some(table) = manifest_toml.get("dependencies") {
             if let Some(table) = table.as_table() {
-                for (name, dep_table) in table.iter() {
+                for (name, dep_table) in table.into_iter() {
                     if let Some(&Value::Boolean(opt)) = dep_table.lookup("optional") {
-                        if self.cfg.optional_deps && opt {
-                            dg.add_child(root_id, name, Some(DepKind::Optional));
+                        self.styles.insert(name.clone(), DepKind::Optional);
+                        dg.add_child(root_id, name, Some(DepKind::Optional));
+                        if !self.cfg.optional_deps && opt {
+                            self.blacklist.push(name.clone());
                         }
                     } else {
+                        self.styles.insert(name.clone(), DepKind::Build);
                         dg.add_child(root_id, name, None);
                     }
                 }
             }
         }
 
-        if self.cfg.dev_deps {
-            if let Some(table) = manifest_toml.get("dev-dependencies") {
-                if let Some(table) = table.as_table() {
-                    for (name, _) in table.iter() {
-                        dg.add_child(root_id, name, Some(DepKind::Dev));
+        if let Some(table) = manifest_toml.get("dev-dependencies") {
+            if let Some(table) = table.as_table() {
+                for (name, _) in table.into_iter() {
+                    self.styles.insert(name.clone(), DepKind::Dev);
+                    dg.add_child(root_id, name, Some(DepKind::Dev));
+                    if !self.cfg.dev_deps {
+                        self.blacklist.push(name.clone());
                     }
                 }
             }
         }
 
         debugln!("root deps: {:#?}", dg);
-
         Ok(dg)
     }
 }