Big rewrite of the application

Cargo.toml

@@ -9,6 +9,7 @@ authors = [
   "Gabor Nagy <[email protected]>",
   "Ivan Jager <[email protected]>",
   "Christopher Brickley <[email protected]>",
+  "Lukas Kalbertodt <[email protected]>",
 ]
 
 description = "Utility for cargo to compile projects when sources change"
@@ -27,8 +28,8 @@ keywords = [
 [dependencies]
 docopt = "^0.6.78"
 env_logger = "^0.3.2"
+lazy_static = "0.1.15"
 log = "^0.3.4"
 notify = "^2.5.4"
 regex = "^0.1.44"
 rustc-serialize = "^0.3.16"
-time = "^0.1.34"

src/cargo.rs

@@ -1,57 +1,50 @@
-//! Utilities for working with cargo,
+//! Utilities for working with cargo and rust files
 
+use config;
+use regex::Regex;
 use std::env;
-use std::ffi::OsStr;
 use std::fs;
 use std::path::PathBuf;
-use std::process::Command;
-use std::process::Stdio;
 
-macro_rules! Sl(($v:expr) => (String::from_utf8_lossy($v.as_slice())));
-
-/// Returns the closest ancestor Path containing a Cargo.toml.
+/// Returns the closest ancestor path containing a `Cargo.toml`.
 ///
-/// Returns None if no ancestor Path contains a Cargo.toml, or if
-/// the limit of 10 ancestors has been run through.
+/// Returns `None` if no ancestor path contains a `Cargo.toml`, or if
+/// the limit of MAX_ANCESTORS ancestors has been reached.
 pub fn root() -> Option<PathBuf> {
-  let mut wd = match env::current_dir() {
-    Err(_) => { return None; },
-    Ok(w) => w
-  };
-
-  fn contains_manifest(path: &mut PathBuf) -> bool {
-    match fs::read_dir(path) {
-      Ok(mut entries) =>
-        entries.any(|ent| match ent {
-          Err(_) => false,
-          Ok(ref ent) => {
-            ent.path().file_name() == Some(OsStr::new("Cargo.toml"))
-          }
-        }),
-      Err(_) => false
+    /// Checks if the directory contains `Cargo.toml`
+    fn contains_manifest(path: &PathBuf) -> bool {
+        fs::read_dir(path).map(|entries| {
+            entries.filter_map(|res| res.ok())
+                   .any(|ent| &ent.file_name() == "Cargo.toml")
+        }).unwrap_or(false)
     }
-  }
 
-  for _ in 0..11 {
-    if contains_manifest(&mut wd) {
-      return Some(wd)
-    }
-    if !wd.pop() { break }
-  }
+    // From the current directory we work our way up, looking for `Cargo.toml`
+    env::current_dir().ok().and_then(|mut wd| {
+        for _ in 0..config::MAX_ANCESTORS {
+            if contains_manifest(&mut wd) {
+                return Some(wd);
+            }
+            if !wd.pop() {
+                break;
+            }
+        }
+
+        None
+    })
+}
 
-  None
+lazy_static! {
+    static ref IGNORED_FILES: Vec<Regex> = {
+        config::IGNORED_FILES.iter().map(|s| {
+            // FIXME: This should use the compile-time `regex!` macros, when
+            // syntax extensions become stabilized (see #32)
+            Regex::new(s).expect("Couldn't parse regex")
+        }).collect()
+    };
 }
 
-/// Runs one or more cargo commands and displays the output.
-pub fn run(cmds: &str) {
-  let cmds_vec: Vec<&str> = cmds.split_whitespace().collect();
-  println!("\n$ cargo {}", cmds);
-  match Command::new("cargo")
-    .stderr(Stdio::inherit())
-    .stdout(Stdio::inherit())
-    .args(&cmds_vec)
-    .output() {
-    Ok(o) => println!("-> {}", o.status),
-    Err(e) => println!("Failed to execute 'cargo {}': {}", cmds, e)
-  };
+/// Checks if the given filename should be ignored
+pub fn is_ignored_file(f: &str) -> bool {
+    IGNORED_FILES.iter().any(|fr| fr.is_match(f))
 }

src/config.rs

@@ -0,0 +1,16 @@
+/// These commands are executed when no arguments are given to `cargo watch`
+pub const DEFAULT_COMMANDS: [&'static str; 1] = ["test"];
+
+/// How many parent folders are searched for a `Cargo.toml`
+pub const MAX_ANCESTORS: u32 = 10;
+
+/// Which subdirectories are being watched for changes
+pub const WATCH_DIRS: [&'static str; 3] = ["src", "tests", "benches"];
+
+/// Changes on files whose names match one of these regexes are ignored
+pub const IGNORED_FILES: [&'static str; 3] = [
+    // FIXME: It should be possible to trigger on non-.rs changes (see #31)
+    r"[^.][^r][^s]$",
+    r"^\.",
+    r"^~",
+];