Add a validate method and tests

Author: andrewdavidmackenzie

src/lib.rs

@@ -16,7 +16,7 @@ use std::io::{Error, ErrorKind};
 /// which you then use to interact with the `Path`
 pub struct Simpath {
     name: String,
-    dirs: Vec<PathBuf>
+    entries: Vec<PathBuf>
 }
 
 #[derive(Debug)]
@@ -33,8 +33,6 @@ pub enum FileType {
 
 /// When validating a `Path` there can be the following types of `PathError`s returned
 pub enum PathError {
-    /// The syntax for a segment of the `Path` does not match a file system path
-    InvalidSyntax(String),
     /// The `Path` entry does not exist on the file system
     DoesNotExist(String),
     /// The `Path` entry cannot be reads
@@ -68,7 +66,7 @@ impl Simpath {
     pub fn new(var_name: &str) -> Self {
         let mut search_path = Simpath {
             name: var_name.to_string(),
-            dirs: vec!()
+            entries: vec!()
         };
 
         search_path.add_from_env_var(var_name);
@@ -103,7 +101,7 @@ impl Simpath {
     /// ```
     ///
     pub fn directories(&self) -> &Vec<PathBuf> {
-        &self.dirs
+        &self.entries
     }
 
     /// Try to find a file by filename (not full path) on a search path.
@@ -144,7 +142,7 @@ impl Simpath {
     /// }
     /// ```
     pub fn find_type(&self, file_name: &str, file_type: FileType) -> Result<PathBuf, Error> {
-        for search_dir in &self.dirs {
+        for search_dir in &self.entries {
             for entry in fs::read_dir(search_dir)? {
                 let file = entry?;
                 if let Some(filename) = file.file_name().to_str() {
@@ -184,7 +182,7 @@ impl Simpath {
     pub fn add_directory(&mut self, dir: &str) {
         let path = PathBuf::from(dir);
         if path.exists() && path.is_dir() && path.read_dir().is_ok() {
-            self.dirs.push(path);
+            self.entries.push(path);
         }
     }
 
@@ -201,7 +199,7 @@ impl Simpath {
     /// }
     /// ```
     pub fn contains(&self, entry: &str) -> bool {
-        for search_dir in &self.dirs {
+        for search_dir in &self.entries {
             if search_dir.to_str().unwrap() == entry {
                 return true;
             }
@@ -234,12 +232,30 @@ impl Simpath {
             }
         }
     }
+
+    /// `validate` checks that all the entries in the `Path` are of a valid syntax, exist on
+    /// the file system and can be read
+    pub fn validate(&self) -> Vec<PathError> {
+        let mut errors = vec!();
+
+        for entry in &self.entries {
+            if !entry.exists() {
+                errors.push(PathError::DoesNotExist(entry.to_str().unwrap().into()));
+            }
+
+            if fs::metadata(entry).is_err() {
+                errors.push(PathError::CannotRead(entry.to_str().unwrap().into()));
+            }
+        }
+
+        errors
+    }
 }
 
 impl fmt::Display for Simpath {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "Search Path: '{}', Directories: {{", self.name).unwrap();
-        for dir in &self.dirs {
+        for dir in &self.entries {
             write!(f, "'{}', ", dir.display()).unwrap();
 
         }
@@ -400,4 +416,25 @@ mod test {
 
         println!("Simpath can be printed: {}", path);
     }
+
+    #[test]
+    fn entry_does_not_exist() {
+        let var_name = "MyPathEnv";
+        env::set_var(var_name, "/foo");
+        let mut path = Simpath::new("MyName");
+        path.add_from_env_var(var_name);
+
+        assert_eq!(path.directories().len(), 0);
+    }
+
+    #[test]
+    fn one_entry_does_not_exist() {
+        let var_name = "MyPathEnv";
+        env::set_var(var_name, ".:/foo");
+        let mut path = Simpath::new("MyName");
+        path.add_from_env_var(var_name);
+
+        assert_eq!(path.directories().len(), 1);
+        assert_eq!(path.validate().len(), 0);
+    }
 }