Fix recursion handling in remove_dir_all_where

Fixes trussed-dev#35

`remove_dir_all_where` correctly handles the case where a file in the directory was skipped, but not if a subdirectory was skipped.
This commit fixes it

src/fs.rs

@@ -223,6 +223,11 @@ impl From<ll::lfs_info> for Metadata
     }
 }
 
+struct RemoveDirAllProgress {
+    files_removed: usize,
+    skipped_any: bool,
+}
+
 impl<Storage: driver::Storage> Filesystem<'_, Storage> {
 
     pub fn allocate() -> Allocation<Storage> {
@@ -315,14 +320,21 @@ impl<Storage: driver::Storage> Filesystem<'_, Storage> {
         self.remove_dir_all_where(path, &|_| true).map(|_| ())
     }
 
-    #[cfg(feature = "dir-entry-path")]
-    pub fn remove_dir_all_where<P>(&self, path: &Path, predicate: &P) -> Result<usize>
+    /// Returns number of deleted files + whether the directory was fully deleted or not
+    fn remove_dir_all_where_inner<P>(
+        &self,
+        path: &Path,
+        predicate: &P,
+    ) -> Result<RemoveDirAllProgress>
     where
         P: Fn(&DirEntry) -> bool,
     {
         if !path.exists(self) {
             debug_now!("no such directory {}, early return", path);
-            return Ok(0);
+            return Ok(RemoveDirAllProgress {
+                files_removed: 0,
+                skipped_any: false,
+            });
         }
         let mut skipped_any = false;
         let mut files_removed = 0;
@@ -345,7 +357,9 @@ impl<Storage: driver::Storage> Filesystem<'_, Storage> {
                 }
                 if entry.file_type().is_dir() {
                     debug_now!("recursing into directory {}", &entry.path());
-                    files_removed += self.remove_dir_all_where(entry.path(), predicate)?;
+                    let progress = self.remove_dir_all_where_inner(entry.path(), predicate)?;
+                    files_removed += progress.files_removed;
+                    skipped_any |= progress.skipped_any;
                     debug_now!("...back");
                 }
             }
@@ -356,7 +370,19 @@ impl<Storage: driver::Storage> Filesystem<'_, Storage> {
             self.remove_dir(path)?;
             debug_now!("..worked");
         }
-        Ok(files_removed)
+        Ok(RemoveDirAllProgress {
+            files_removed,
+            skipped_any,
+        })
+    }
+
+    #[cfg(feature = "dir-entry-path")]
+    pub fn remove_dir_all_where<P>(&self, path: &Path, predicate: &P) -> Result<usize>
+    where
+        P: Fn(&DirEntry) -> bool,
+    {
+        self.remove_dir_all_where_inner(path, predicate)
+            .map(|progress| progress.files_removed)
     }
 
     /// Rename or move a file or directory.

src/path.rs

@@ -15,6 +15,7 @@ use crate::consts;
 /// accepts arbitrary C strings), but the assumption makes `AsRef<str>` trivial
 /// to implement.
 #[derive(PartialEq, Eq)]
+#[repr(transparent)]
 pub struct Path {
     inner: CStr,
 }

src/tests.rs

@@ -13,6 +13,7 @@ use crate::{
         Read,
         SeekFrom,
     },
+    path::Path,
     driver,
 };
 
@@ -347,6 +348,35 @@ fn test_fancy_open() {
     assert_eq!(&buf, b"world");
 }
 
+#[test]
+fn remove_dir_all_where() {
+    let mut backend = Ram::default();
+    let mut storage = RamStorage::new(&mut backend);
+
+    Filesystem::format(&mut storage).unwrap();
+
+    Filesystem::mount_and_then(&mut storage, |fs| {
+        fs.write(path!("test_file"), b"some data").unwrap();
+        fs.create_dir(path!("test_dir")).unwrap();
+        fs.write(path!("test_dir/test_file"), b"some_inner_data")
+            .unwrap();
+        fs.write(path!("test_dir/test_file2"), b"some_inner_data")
+            .unwrap();
+        fs.remove_dir_all_where(path!(""), &|entry| {
+            entry.path() != path!("test_dir/test_file")
+        })
+        .unwrap();
+        assert!(fs.metadata(path!("test_dir/test_file")).unwrap().is_file());
+        assert_eq!(fs.metadata(path!("test_file")), Err(Error::NoSuchEntry));
+        assert_eq!(
+            fs.metadata(path!("test_dir/test_file2")),
+            Err(Error::NoSuchEntry)
+        );
+        Ok(())
+    })
+    .unwrap();
+}
+
 #[test]
 fn attributes() {
     let mut backend = Ram::default();