Merge pull request #4 from sunsided/feature/random-names

Add new and new_in without uuid dependency

Author: sunsided

.github/workflows/rust.yml

@@ -11,20 +11,21 @@ env:
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
-
+    strategy:
+      matrix:
+        features: [[], ["--all-features"]]
     steps:
-    - uses: actions/checkout@v3
-    - name: Check Formatting
-      run: cargo fmt --check
-    - name: Clippy
-      run: cargo clippy
-    - name: Build
-      run: cargo build --verbose
-    - name: Run build tests
-      run: cargo build --tests --all-features
-    - name: Run tests
-      run: cargo test --tests --all-features --verbose
-    - name: Run doctests
-      run: cargo test --doc --all-features --verbose
+      - uses: actions/checkout@v2
+      - name: Check Formatting
+        run: cargo fmt --check
+      - name: Clippy
+        run: cargo clippy ${{ join(matrix.features, ' ') }}
+      - name: Build
+        run: cargo build --verbose ${{ join(matrix.features, ' ') }}
+      - name: Run build tests
+        run: cargo build --tests ${{ join(matrix.features, ' ') }}
+      - name: Run tests
+        run: cargo test --tests --verbose ${{ join(matrix.features, ' ') }}
+      - name: Run doctests
+        run: cargo test --doc --verbose ${{ join(matrix.features, ' ') }}

CHANGELOG.md

@@ -7,6 +7,8 @@ This project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Changed
 
+- The `new` and `new_in` functions now do not rely on the `uuid` feature anymore
+  for the generation of temporary file names.
 - The `uuid` feature is now not enabled by default anymore.
 
 ### Internal

Cargo.toml

@@ -18,7 +18,6 @@ uuid = ["dep:uuid"]
 [[test]]
 name = "tests"
 path = "tests/tests.rs"
-required-features = ["uuid"]
 
 [dependencies]
 tokio = { version = "1.34.0", features = ["fs"] }

README.md

@@ -9,7 +9,6 @@ use async_tempfile::TempFile;
 
 #[tokio::main]
 async fn main() {
-    // NOTE: The new() function is available with the `uuid` crate feature.
     let parent = TempFile::new().await.unwrap();
 
     // The cloned reference will not delete the file when dropped.

src/lib.rs

@@ -44,14 +44,14 @@ use std::path::PathBuf;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
+use std::time::SystemTime;
 use tokio::fs::{File, OpenOptions};
 use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
 
 #[cfg(feature = "uuid")]
 use uuid::Uuid;
 
-#[cfg(feature = "uuid")]
-const FILE_PREFIX: &'static str = "atmp_";
+const FILE_PREFIX: &str = "atmp_";
 
 /// A named temporary file that will be cleaned automatically
 /// after the last reference to it is dropped.
@@ -115,8 +115,6 @@ impl TempFile {
     /// # Ok::<(), Error>(())
     /// # });
     /// ```
-    #[cfg_attr(docsrs, doc(cfg(feature = "uuid")))]
-    #[cfg(feature = "uuid")]
     pub async fn new() -> Result<Self, Error> {
         Self::new_in(Self::default_dir()).await
     }
@@ -189,6 +187,11 @@ impl TempFile {
     /// Creates a new temporary file in the specified location.
     /// When the instance goes out of scope, the file will be deleted.
     ///
+    /// ## Crate Features
+    ///
+    /// * `uuid` - When the `uuid` crate feature is enabled, a random UUIDv4 is used to
+    ///   generate the temporary file name.
+    ///
     /// ## Arguments
     ///
     /// * `dir` - The directory to create the file in.
@@ -213,12 +216,18 @@ impl TempFile {
     /// assert!(fs::metadata(file_path).await.is_err());
     /// # Ok::<(), Error>(())
     /// # });
-    /// ```
-    #[cfg_attr(docsrs, doc(cfg(feature = "uuid")))]
-    #[cfg(feature = "uuid")]
     pub async fn new_in<P: Borrow<PathBuf>>(dir: P) -> Result<Self, Error> {
-        let id = Uuid::new_v4();
-        return Self::new_with_uuid_in(id, dir).await;
+        #[cfg(feature = "uuid")]
+        {
+            let id = Uuid::new_v4();
+            Self::new_with_uuid_in(id, dir).await
+        }
+
+        #[cfg(not(feature = "uuid"))]
+        {
+            let name = RandomName::new();
+            Self::new_with_name_in(name, dir).await
+        }
     }
 
     /// Creates a new temporary file in the specified location.
@@ -405,6 +414,40 @@ impl TempFile {
     }
 }
 
+/// Represents a randomly generated file name.
+struct RandomName {
+    name: String,
+}
+
+impl RandomName {
+    #[allow(dead_code)]
+    fn new() -> Self {
+        let pid = std::process::id();
+
+        // Using the address of a local variable for extra variation.
+        let marker = &pid as *const _ as usize;
+
+        // Current timestamp for added variation.
+        let now = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .unwrap_or(std::time::Duration::from_secs(0));
+        let (secs, subsec_nanos) = (now.as_secs(), now.subsec_nanos());
+
+        Self {
+            name: format!(
+                "{}{}{:x}{:x}{:x}",
+                FILE_PREFIX, pid, marker, secs, subsec_nanos
+            ),
+        }
+    }
+}
+
+impl AsRef<str> for RandomName {
+    fn as_ref(&self) -> &str {
+        &self.name
+    }
+}
+
 /// Ensures the file handles are closed before the core reference is freed.
 /// If the core reference would be freed while handles are still open, it is
 /// possible that the underlying file cannot be deleted.
@@ -535,3 +578,14 @@ impl AsyncSeek for TempFile {
         Pin::new(self.file.deref_mut()).poll_complete(cx)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_random_name() {
+        let name = RandomName::new();
+        assert!(name.as_ref().starts_with(FILE_PREFIX))
+    }
+}

tests/tests.rs

@@ -1,5 +1,12 @@
-use async_tempfile::{Ownership, TempFile};
+use async_tempfile::TempFile;
+
+#[cfg(feature = "uuid")]
+use async_tempfile::Ownership;
+
+#[cfg(feature = "uuid")]
 use tokio::fs::OpenOptions;
+
+#[cfg(feature = "uuid")]
 use uuid::Uuid;
 
 #[tokio::test]
@@ -41,7 +48,8 @@ async fn ro_file_is_not_dropped_while_still_referenced() {
 }
 
 #[tokio::test]
-async fn borrowed_file_is_not_dropped() {
+#[cfg(feature = "uuid")]
+async fn uuid_borrowed_file_is_not_dropped() {
     let file_name = format!("test_{}", Uuid::new_v4());
     let path = std::env::temp_dir().join(file_name);
     let _original = OpenOptions::new()
@@ -64,7 +72,8 @@ async fn borrowed_file_is_not_dropped() {
 }
 
 #[tokio::test]
-async fn owned_file_is_dropped() {
+#[cfg(feature = "uuid")]
+async fn uuid_owned_file_is_dropped() {
     let file_name = format!("test_{}", Uuid::new_v4());
     let path = std::env::temp_dir().join(file_name);
     let _original = OpenOptions::new()