Return errors on first entry of WalkDir

The first entry of WalkDir is being skipped - the problem with this is
that the first entry is where WalkDir can report that the directory for
comparison doesn't exist. The current code will return `false` for the
following cases:

  dir_diff::is_different("dir_that_exists", "dir_that_does_not_exist");
  dir_diff::is_different("dir_that_does_not_exist", "also_does_not_exist");

This is obviously not ideal since the directory not existing is probably
not what the user intended.

This commit fixes up the issue by checking the first entry returned from
WalkDir for error instead of skipping it. This causes `is_different` to
return an error if either or both directories don't actually exist.

Signed-off-by: Nick Stevens <nick@bitcurry.com>

Author: nastevens

src/lib.rs

@@ -38,8 +38,8 @@ pub enum Error {
 /// assert!(dir_diff::is_different("dir/a", "dir/b").unwrap());
 /// ```
 pub fn is_different<A: AsRef<Path>, B: AsRef<Path>>(a_base: A, b_base: B) -> Result<bool, Error> {
-    let mut a_walker = walk_dir(a_base);
-    let mut b_walker = walk_dir(b_base);
+    let mut a_walker = walk_dir(a_base)?;
+    let mut b_walker = walk_dir(b_base)?;
 
     for (a, b) in (&mut a_walker).zip(&mut b_walker) {
         let a = a?;
@@ -53,14 +53,16 @@ pub fn is_different<A: AsRef<Path>, B: AsRef<Path>>(a_base: A, b_base: B) -> Res
         }
     }
 
-    Ok(!a_walker.next().is_none() || !b_walker.next().is_none())
+    Ok(a_walker.next().is_some() || b_walker.next().is_some())
 }
 
-fn walk_dir<P: AsRef<Path>>(path: P) -> std::iter::Skip<walkdir::IntoIter> {
-    WalkDir::new(path)
-        .sort_by(compare_by_file_name)
-        .into_iter()
-        .skip(1)
+fn walk_dir<P: AsRef<Path>>(path: P) -> Result<walkdir::IntoIter, std::io::Error> {
+    let mut walkdir = WalkDir::new(path).sort_by(compare_by_file_name).into_iter();
+    if let Some(Err(e)) = walkdir.next() {
+        Err(e.into())
+    } else {
+        Ok(walkdir)
+    }
 }
 
 fn compare_by_file_name(a: &DirEntry, b: &DirEntry) -> Ordering {

tests/smoke.rs

@@ -34,6 +34,24 @@ fn oneempty() {
     assert!(dir_diff::is_different("tests/oneempty/dir1", "tests/oneempty/dir2").unwrap());
 }
 
+#[test]
+#[should_panic]
+fn firstmissing() {
+    assert!(dir_diff::is_different("does_not_exist", "tests/easy/good/dir1").unwrap());
+}
+
+#[test]
+#[should_panic]
+fn secondmissing() {
+    assert!(dir_diff::is_different("tests/easy/good/dir1", "does_not_exist").unwrap());
+}
+
+#[test]
+#[should_panic]
+fn bothmissing() {
+    assert!(dir_diff::is_different("does_not_exist", "also_does_not_exist").unwrap());
+}
+
 #[test]
 fn reflexive() {
     assert!(dir_diff::is_different("tests/reflexive/dir1", "tests/reflexive/dir2").unwrap());