Merge pull request #22 from ijackson/remove-dir-contents

Provide remove_dir_contents

Author: rbtcollins

Cargo.toml

@@ -23,6 +23,9 @@ num_cpus = "1.13"
 rayon = "1.4"
 winapi = {version = "0.3", features = ["std", "errhandlingapi", "winerror", "fileapi", "winbase"]}
 
+[target.'cfg(not(windows))'.dependencies]
+libc = "0.2"
+
 [dev-dependencies]
 doc-comment = "0.3"
 env_logger = "0.8.1"

README.md

@@ -6,8 +6,17 @@
 
 ## Description
 
-A reliable implementation of `remove_dir_all` for Windows. For Unix systems
-re-exports `std::fs::remove_dir_all`.
+Reliable and fast directory removal functions.
+
+* `remove_dir_all` - on non-Windows this is a re-export of
+  `std::fs::remove_dir_all`. For Windows an implementation that handles the
+  locking of directories that occurs when deleting directory trees rapidly.
+
+* `remove_dir_contents` - as for `remove_dir_all` but does not delete the
+  supplied root directory.
+
+* `ensure_empty_dir` - as for `remove_dir_contents` but will create the
+  directory if it does not exist.
 
 ```rust,no_run
 extern crate remove_dir_all;
@@ -16,6 +25,7 @@ use remove_dir_all::*;
 
 fn main() {
     remove_dir_all("./temp/").unwrap();
+    remove_dir_contents("./cache/").unwrap();
 }
 ```
 

src/fs.rs

@@ -60,8 +60,8 @@ pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
     // To handle files with names like `CON` and `morse .. .`,  and when a
     // directory structure is so deep it needs long path names the path is first
     // converted to the Win32 file namespace by calling `canonicalize()`.
-    let path = path.as_ref().canonicalize()?;
-    _delete_dir_contents(&path)?;
+
+    let path = _remove_dir_contents(path)?;
     let metadata = path.metadata()?;
     if metadata.permissions().readonly() {
         delete_readonly(metadata, &path)?;
@@ -76,6 +76,13 @@ pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
     Ok(())
 }
 
+/// Returns the canonicalised path, for one of caller's convenience.
+pub fn _remove_dir_contents<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {
+    let path = path.as_ref().canonicalize()?;
+    _delete_dir_contents(&path)?;
+    Ok(path)
+}
+
 fn _delete_dir_contents(path: &PathBuf) -> io::Result<()> {
     log::trace!("scanning {}", &path.display());
     let iter = path.read_dir()?.par_bridge();

src/lib.rs

@@ -2,6 +2,9 @@
 //!
 //! This library provides a reliable implementation of `remove_dir_all` for Windows.
 //! For Unix systems, it re-exports `std::fs::remove_dir_all`.
+//!
+//! It also provides `remove_dir_contents` and `ensure_empty_dir`
+//! for both Unix and Windows.
 
 #![deny(missing_debug_implementations)]
 #![deny(missing_docs)]
@@ -19,8 +22,16 @@ doctest!("../README.md");
 #[cfg(windows)]
 mod fs;
 
+#[cfg(not(windows))]
+mod unix;
+
+mod portable;
+
 #[cfg(windows)]
 pub use self::fs::remove_dir_all;
 
 #[cfg(not(windows))]
 pub use std::fs::remove_dir_all;
+
+pub use portable::ensure_empty_dir;
+pub use portable::remove_dir_contents;

src/portable.rs

@@ -0,0 +1,105 @@
+use std::io;
+use std::path::Path;
+
+#[cfg(windows)]
+use crate::fs::_remove_dir_contents;
+
+#[cfg(not(windows))]
+use crate::unix::_remove_dir_contents;
+
+/// Deletes the contents of `path`, but not the directory iteself.
+///
+/// If `path` is a symlink to a directory, deletes the contents
+/// of that directory.  Fails if `path` does not exist.
+pub fn remove_dir_contents<P: AsRef<Path>>(path: P) -> io::Result<()> {
+    // This wrapper function exists because the core function
+    // for Windows, in crate::fs, returns a PathBuf, which our
+    // caller shouldn't see.
+    _remove_dir_contents(path)?;
+    Ok(())
+}
+
+/// Makes `path` an empty directory: if it does not exist, it is
+/// created it as an empty directory (as if with
+/// `std::fs::create_dir`); if it does exist, its contents are
+/// deleted (as if with `remove_dir_contents`).
+///
+/// It is an error if `path` exists but is not a directory (or
+/// a symlink to one).
+pub fn ensure_empty_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
+    match std::fs::create_dir(&path) {
+        Err(e) if e.kind() == io::ErrorKind::AlreadyExists
+            => remove_dir_contents(path),
+        otherwise => otherwise,
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use tempfile::TempDir;
+    use crate::remove_dir_all;
+    use crate::remove_dir_contents;
+    use crate::ensure_empty_dir;
+    use std::fs::{self, File};
+    use std::path::PathBuf;
+    use std::io;
+
+    fn expect_failure<T>(k: io::ErrorKind, r: io::Result<T>) -> io::Result<()> {
+        match r {
+            Err(e) if e.kind() == k => Ok(()),
+            Err(e) => Err(e),
+            Ok(_) => Err(io::Error::new(
+                io::ErrorKind::Other,
+                "unexpected success".to_string(),
+            )),
+        }
+    }
+
+    struct Prep {
+        _tmp: TempDir,
+        ours: PathBuf,
+        file: PathBuf,
+    }
+
+    fn prep() -> Result<Prep, io::Error> {
+        let tmp = TempDir::new()?;
+        let ours = tmp.path().join("t.mkdir");
+        let file = ours.join("file");
+        fs::create_dir(&ours)?;
+        File::create(&file)?;
+        File::open(&file)?;
+        Ok(Prep { _tmp: tmp, ours, file })
+    }
+
+    #[test]
+    fn mkdir_rm() -> Result<(), io::Error> {
+        let p = prep()?;
+
+        expect_failure(io::ErrorKind::Other, remove_dir_contents(&p.file))?;
+
+        remove_dir_contents(&p.ours)?;
+        expect_failure(io::ErrorKind::NotFound, File::open(&p.file))?;
+
+        remove_dir_contents(&p.ours)?;
+        remove_dir_all(&p.ours)?;
+        expect_failure(io::ErrorKind::NotFound, remove_dir_contents(&p.ours))?;
+        Ok(())
+    }
+
+    #[test]
+    fn ensure_rm() -> Result<(), io::Error> {
+        let p = prep()?;
+
+        expect_failure(io::ErrorKind::Other, ensure_empty_dir(&p.file))?;
+
+        ensure_empty_dir(&p.ours)?;
+        expect_failure(io::ErrorKind::NotFound, File::open(&p.file))?;
+        ensure_empty_dir(&p.ours)?;
+
+        remove_dir_all(&p.ours)?;
+        ensure_empty_dir(&p.ours)?;
+        File::create(&p.file)?;
+
+        Ok(())
+    }
+}

src/unix.rs

@@ -0,0 +1,21 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+fn remove_file_or_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
+    match fs::remove_file(&path) {
+        // Unfortunately, there is no ErrorKind for EISDIR
+        Err(e) if e.raw_os_error() == Some(libc::EISDIR) =>
+            fs::remove_dir_all(&path),
+        r => r,
+    }
+}
+
+pub fn _remove_dir_contents<P: AsRef<Path>>(path: P) -> Result<(), io::Error> {
+    for entry in fs::read_dir(path)? {
+        let entry_path = entry?.path();
+        remove_file_or_dir_all(&entry_path)?;
+    }
+
+    Ok(())
+}