Add drop_async function

Author: sunsided

CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 This project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2025-02-22
+
+[0.7.0]: https://github.com/sunsided/async-tempfile-rs/releases/tag/v0.7.0
+
+### Added
+
+- Added the `drop_async` functions to provide controlled and `async` dropping.
+
 ## [0.6.0] - 2024-06-30
 
 [0.6.0]: https://github.com/sunsided/async-tempfile-rs/releases/tag/v0.6.0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "async-tempfile"
-version = "0.6.0"
+version = "0.7.0"
 description = "Automatically deleted async I/O temporary files."
 documentation = "https://docs.rs/async-tempfile"
 license = "MIT"
@@ -24,7 +24,7 @@ tokio = { version = "1.38.0", features = ["fs"] }
 uuid = { version = "1.9.1", features = ["v4"], optional = true }
 
 [dev-dependencies]
-tokio = { version = "1.38.0", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1.38.0", features = ["rt-multi-thread", "macros", "rt"] }
 tokio-test = "0.4.4"
 
 [package.metadata.docs.rs]

src/tempdir.rs

@@ -301,6 +301,31 @@ impl TempDir {
         self.core.ownership
     }
 
+    /// Asynchronously drops the [`TempDir`] instance by moving the drop operation 
+    /// to a blocking thread, avoiding potential blocking of the async runtime.
+    ///
+    /// This method is useful in cases where manually handling the blocking drop 
+    /// within an async context is required.
+    ///
+    /// ## Example
+    /// ```
+    /// # use async_tempfile::TempDir;
+    /// # let _ = tokio_test::block_on(async {
+    /// let dir = TempDir::new().await?;
+    ///
+    /// // Drop the directory asynchronously.
+    /// dir.drop_async().await;
+    ///
+    /// // The directory is now removed.
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
+    /// # });
+    /// ```
+    ///
+    /// Note: This function spawns a blocking task for the drop operation.
+    pub async fn drop_async(self) {
+        tokio::task::spawn_blocking(move || drop(self)).await.ok();
+    }
+    
     async fn new_internal<P: Borrow<Path>>(path: P, ownership: Ownership) -> Result<Self, Error> {
         // Create the directory and all its parents.
         tokio::fs::create_dir_all(path.borrow()).await?;

src/tempfile.rs

@@ -372,6 +372,29 @@ impl TempFile {
         self.core.ownership
     }
 
+    /// Asynchronously drops the TempFile, ensuring any resources are properly released.
+    /// This is useful for explicitly managing the lifecycle of the TempFile
+    /// in an asynchronous context.
+    ///
+    /// ## Example
+    ///
+    /// ```rust
+    /// # use async_tempfile::{TempFile, Error};
+    /// # let _ = tokio_test::block_on(async {
+    /// let file = TempFile::new().await?;
+    /// let path = file.file_path().to_path_buf();
+    /// assert!(path.is_file());
+    ///
+    /// file.drop_async().await; // Explicitly drop the TempFile
+    ///
+    /// assert!(!path.exists());
+    /// # Ok::<(), Error>(())
+    /// # });
+    /// ```
+    pub async fn drop_async(self) {
+        tokio::task::spawn_blocking(move || drop(self)).await.ok();
+    }
+    
     async fn new_internal<P: Borrow<Path>>(path: P, ownership: Ownership) -> Result<Self, Error> {
         let path = path.borrow();