Add test for loader.rs

Author: x4d3

src/hash.rs

@@ -8,8 +8,8 @@ use std::result::Result;
 use std::str::FromStr;
 use std::u64;
 
-const FILE_SEPARATOR: &'static str = "\x1C";
-const GROUP_SEPARATOR: &'static str = "\x1D";
+const FILE_SEPARATOR: &str = "\x1C";
+const GROUP_SEPARATOR: &str = "\x1D";
 
 #[derive(Debug, Clone)]
 pub struct Source {
@@ -25,7 +25,7 @@ pub struct SourceFile {
 
 impl Ord for SourceFile {
     fn cmp(&self, other: &Self) -> Ordering {
-        return self.name.cmp(&other.name);
+        self.name.cmp(&other.name)
     }
 }
 
@@ -41,7 +41,7 @@ impl PartialEq for SourceFile {
     }
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Hash {
     pub hash: u64,
 }
@@ -52,22 +52,15 @@ struct WrongInputSize;
 
 impl Source {
     pub fn new(dir: String) -> Self {
-        Source {
-            dir: dir,
-            files: vec![],
-        }
+        Source { dir, files: vec![] }
     }
 
-    pub fn add_file(&mut self, name: String, contents: String) -> Result<(), Error> {
-        self.files.push(SourceFile {
-            name: name.to_string(),
-            contents: contents.to_string(),
-        });
-        Ok(())
+    pub fn add_file(&mut self, name: String, contents: String) {
+        self.files.push(SourceFile { name, contents })
     }
 
     pub fn hash(&self) -> Result<u64, Error> {
-        if self.files.len() == 0 {
+        if self.files.is_empty() {
             return Ok(0);
         }
         let mut hasher = VarBlake2b::new(8)?;
@@ -94,7 +87,7 @@ impl FromStr for Hash {
         if key.len() != 16 {
             return Err(WrongInputSize {}.into());
         }
-        let hash = u64::from_str_radix(&key, 16)?;
+        let hash = u64::from_str_radix(key, 16)?;
         Ok(Hash { hash })
     }
 }

src/loader.rs

@@ -1,13 +1,12 @@
 use crate::hash::Source;
 
-use std::fs::{self, File};
-use std::io::{prelude::*, ErrorKind};
+use std::fs;
+use std::io::ErrorKind;
 use std::path::PathBuf;
-use std::string::String;
 
 use failure::Error;
 
-pub const DEFAULT_RELATIVE_COMPONENT: &'static str = ".shadowenv.d";
+pub const DEFAULT_RELATIVE_COMPONENT: &str = ".shadowenv.d";
 
 /// Search upwards the filesystem branch starting with `at` and then its ancestors looking
 /// for a file or directory named `relative_component`.
@@ -16,41 +15,71 @@ pub fn find_root(at: PathBuf, relative_component: &str) -> Result<Option<PathBuf
         let dirpath = curr.join(relative_component);
 
         match fs::read_dir(&dirpath) {
-            Ok(_) => return Ok(Some(std::fs::canonicalize(dirpath)?)),
+            Ok(_) => return Ok(Some(fs::canonicalize(dirpath)?)),
             Err(ref e) if e.kind() == ErrorKind::NotFound => (),
             Err(e) => return Err(e.into()),
         }
     }
-    return Ok(None);
+    Ok(None)
 }
 
 /// Load all .lisp files in the directory pointed by `dirpath` storing their names and contents as
 /// `SourceFiles` inside a `Source` struct.
 ///
 /// Note that this function assumes that the dirpath is trusted.
 pub fn load(dirpath: PathBuf) -> Result<Option<Source>, Error> {
-    let mut source = Source::new(dirpath.parent().unwrap().to_str().unwrap().to_string());
-
-    for entry in fs::read_dir(dirpath)? {
-        if let Ok(entry) = entry {
-            let path = entry.path();
-            if path.is_file() {
-                // TODO: there HAS to  be a better way to do this.
-                let basename = path.file_name().unwrap().to_str().unwrap().to_string();
-                if !basename.ends_with(".lisp") {
-                    continue;
-                }
-                let mut file = File::open(&path)?;
-                let mut contents = String::new();
-                file.read_to_string(&mut contents)?;
-                // TODO: surely  there's a better way to do this.
-                source.add_file(basename, contents)?;
+    let mut source = Source::new(dirpath.parent().unwrap().to_string_lossy().to_string());
+
+    for entry in fs::read_dir(dirpath)?.flatten() {
+        let path = entry.path();
+        if path.is_file() {
+            // TODO: there HAS to be a better way to do this.
+            let basename = path.file_name().unwrap().to_string_lossy().to_string();
+            if !basename.ends_with(".lisp") {
+                continue;
             }
+            let contents = fs::read_to_string(&path)?;
+            source.add_file(basename, contents);
         }
     }
 
-    if source.files.len() == 0 {
+    if source.files.is_empty() {
         return Ok(None);
     }
-    return Ok(Some(source));
+    Ok(Some(source))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::hash::SourceFile;
+
+    #[test]
+    fn test_load() {
+        let path: PathBuf = [env!("CARGO_MANIFEST_DIR"), "tests", "fixtures", "simple"]
+            .iter()
+            .collect();
+        let res = load(path);
+        let source = res.unwrap().unwrap();
+        assert_eq!(source.files.len(), 2, "it should contain 2 files");
+        let mut files = source.files.clone();
+        files.sort_by(|a, b| a.name.cmp(&b.name));
+
+        let expected = vec![
+            SourceFile {
+                name: "550_dev_ruby.lisp".to_string(),
+                contents: r#"(provide "ruby" "3.1.2")
+"#
+                .to_string(),
+            },
+            SourceFile {
+                name: "585_dev_rust.lisp".to_string(),
+                contents: r#"(provide "rust" "stable")
+"#
+                .to_string(),
+            },
+        ];
+
+        assert_eq!(files, expected)
+    }
 }

tests/fixtures/simple/550_dev_ruby.lisp

@@ -0,0 +1 @@
+(provide "ruby" "3.1.2")

tests/fixtures/simple/585_dev_rust.lisp

@@ -0,0 +1 @@
+(provide "rust" "stable")

tests/fixtures/simple/not_lisp.txt

@@ -0,0 +1 @@
+This is not lisp.