Struct TempDir

pub struct TempDir { /* private fields */ }

A temporary directory that automatically cleans up its contents when dropped.

Files created through the TempDir are tracked and removed upon drop.

Implementations

impl TempDir

pub fn new<P: AsRef<Path>>(path: P) -> TempResult<Self>

Creates a new temporary directory at the specified path.

The directory (and any missing parent directories) will be created.

Arguments

• path - The path at which to create the directory. If a relative path is provided, it is resolved relative to the system temporary directory.

Errors

Returns an error if the directory cannot be created.

pub fn new_here<P: AsRef<Path>>(path: P) -> TempResult<Self>

Creates a new temporary directory at the specified path.

The directory (and any missing parent directories) will be created.

Arguments

• path - The path at which to create the directory. If a relative path is provided, it is resolved relative to the current directory.

Errors

Returns an error if the directory cannot be created.

pub fn new_random<P: AsRef<Path>>(dir: Option<P>) -> TempResult<Self>

Creates a new temporary directory with a random name in the given parent directory.

The directory name will consist of alphanumeric characters only, ensuring compatibility across different filesystems.

Arguments

• dir - An optional parent directory in which to create the temporary directory. If a relative directory is provided, it is resolved relative to the system temporary directory.

Errors

Returns an error if a unique directory name cannot be generated or if directory creation fails.

Examples found in repository

ex/e2.rs (line 6)

fn main() -> Result<(), TempError> {
    // Create a temporary directory with a random name.
    let mut temp_dir = TempDir::new_random::<std::path::PathBuf>(None)?;

    // Create a temporary file with a specific name.
    {
        let file = temp_dir.create_file("test1.txt")?;
        write!(file, "Content for test1")?;
    }

    // Create another temporary file with a random name.
    {
        let file = temp_dir.create_random_file()?;
        write!(file, "Random file content")?;
    }

    // List all the temporary files managed by the directory.
    for file_path in temp_dir.list_files() {
        println!("Managed temp file: {file_path:?}");
    }

    // If the library was built with regex support, search for files matching a pattern.
    #[cfg(feature = "regex_support")]
    {
        let matching_files = temp_dir.find_files_by_pattern(r"^test\d\.txt$")?;
        for file in matching_files {
            if let Some(path) = file.path() {
                println!("Found file matching regex: {path:?}");
            }
        }
    }

    // When `temp_dir` goes out of scope, the directory and all its managed files are automatically deleted.
    Ok(())
}

pub fn new_random_here<P: AsRef<Path>>(dir: Option<P>) -> TempResult<Self>

Creates a new temporary directory with a random name in the given parent directory.

The directory name will consist of alphanumeric characters only, ensuring compatibility across different filesystems.

Arguments

• dir - An optional parent directory in which to create the temporary directory. If a relative directory is provided, it is resolved relative to the current working directory.

Errors

Returns an error if a unique directory name cannot be generated or if directory creation fails.

pub fn create_file<S: AsRef<str>>( &mut self, filename: S, ) -> TempResult<&mut TempFile>

Creates a new temporary file with the given filename in the directory.

The created file is tracked and will be automatically deleted on drop.

Arguments

• filename - The name of the file to create.

Errors

This function will return an error if the inner path is None.

Examples found in repository

ex/e2.rs (line 10)

fn main() -> Result<(), TempError> {
    // Create a temporary directory with a random name.
    let mut temp_dir = TempDir::new_random::<std::path::PathBuf>(None)?;

    // Create a temporary file with a specific name.
    {
        let file = temp_dir.create_file("test1.txt")?;
        write!(file, "Content for test1")?;
    }

    // Create another temporary file with a random name.
    {
        let file = temp_dir.create_random_file()?;
        write!(file, "Random file content")?;
    }

    // List all the temporary files managed by the directory.
    for file_path in temp_dir.list_files() {
        println!("Managed temp file: {file_path:?}");
    }

    // If the library was built with regex support, search for files matching a pattern.
    #[cfg(feature = "regex_support")]
    {
        let matching_files = temp_dir.find_files_by_pattern(r"^test\d\.txt$")?;
        for file in matching_files {
            if let Some(path) = file.path() {
                println!("Found file matching regex: {path:?}");
            }
        }
    }

    // When `temp_dir` goes out of scope, the directory and all its managed files are automatically deleted.
    Ok(())
}

pub fn create_random_file(&mut self) -> TempResult<&mut TempFile>

Creates a new temporary file with a random name in the directory.

The file is tracked and will be automatically deleted on drop.

Errors

Returns an error if a unique filename cannot be generated or if file creation fails.

Examples found in repository

ex/e2.rs (line 16)

fn main() -> Result<(), TempError> {
    // Create a temporary directory with a random name.
    let mut temp_dir = TempDir::new_random::<std::path::PathBuf>(None)?;

    // Create a temporary file with a specific name.
    {
        let file = temp_dir.create_file("test1.txt")?;
        write!(file, "Content for test1")?;
    }

    // Create another temporary file with a random name.
    {
        let file = temp_dir.create_random_file()?;
        write!(file, "Random file content")?;
    }

    // List all the temporary files managed by the directory.
    for file_path in temp_dir.list_files() {
        println!("Managed temp file: {file_path:?}");
    }

    // If the library was built with regex support, search for files matching a pattern.
    #[cfg(feature = "regex_support")]
    {
        let matching_files = temp_dir.find_files_by_pattern(r"^test\d\.txt$")?;
        for file in matching_files {
            if let Some(path) = file.path() {
                println!("Found file matching regex: {path:?}");
            }
        }
    }

    // When `temp_dir` goes out of scope, the directory and all its managed files are automatically deleted.
    Ok(())
}

pub fn remove_file<S: AsRef<str>>(&mut self, filename: S)

Removes a file from the directory’s management.

This does not delete the file immediately—it will be removed when the directory is dropped.

Arguments

• filename - The name of the file to remove from management.

pub fn get_file<S: AsRef<str>>(&self, filename: S) -> Option<&TempFile>

Retrieves a reference to a temporary file by filename.

Arguments

• filename - The name of the file to retrieve.

pub fn get_file_mut<S: AsRef<str>>( &mut self, filename: S, ) -> Option<&mut TempFile>

Retrieves a mutable reference to a temporary file by filename.

Arguments

• filename - The name of the file to retrieve.

pub fn path(&self) -> Option<&Path>

Returns the path of the temporary directory.

pub fn into_path(self) -> Option<PathBuf>

Consumes the TempDir, returning its path and preventing cleanup.

pub fn list_files(&self) -> Vec<&Path>

Lists the paths of all files managed by the directory.

Examples found in repository

ex/e2.rs (line 21)

fn main() -> Result<(), TempError> {
    // Create a temporary directory with a random name.
    let mut temp_dir = TempDir::new_random::<std::path::PathBuf>(None)?;

    // Create a temporary file with a specific name.
    {
        let file = temp_dir.create_file("test1.txt")?;
        write!(file, "Content for test1")?;
    }

    // Create another temporary file with a random name.
    {
        let file = temp_dir.create_random_file()?;
        write!(file, "Random file content")?;
    }

    // List all the temporary files managed by the directory.
    for file_path in temp_dir.list_files() {
        println!("Managed temp file: {file_path:?}");
    }

    // If the library was built with regex support, search for files matching a pattern.
    #[cfg(feature = "regex_support")]
    {
        let matching_files = temp_dir.find_files_by_pattern(r"^test\d\.txt$")?;
        for file in matching_files {
            if let Some(path) = file.path() {
                println!("Found file matching regex: {path:?}");
            }
        }
    }

    // When `temp_dir` goes out of scope, the directory and all its managed files are automatically deleted.
    Ok(())
}

pub fn new_in<P: AsRef<Path>>(path: P) -> TempResult<Self>

Creates a new temporary directory with a random name within the given parent directory.

Arguments

• path - The parent directory in which to create the temporary directory. If a relative path is provided, it is resolved relative to the system temporary directory.

Errors

Returns an error if a unique directory name cannot be generated or if directory creation fails.

impl TempDir

pub fn find_files_by_pattern<S: AsRef<str>>( &self, pattern: S, ) -> Result<Vec<&TempFile>, RErr>

Finds files with names matching a regex pattern.

Arguments

• pattern - A regex pattern to match file names.

Errors

Returns an error if the regex pattern is invalid.

Examples found in repository

ex/e2.rs (line 28)

fn main() -> Result<(), TempError> {
    // Create a temporary directory with a random name.
    let mut temp_dir = TempDir::new_random::<std::path::PathBuf>(None)?;

    // Create a temporary file with a specific name.
    {
        let file = temp_dir.create_file("test1.txt")?;
        write!(file, "Content for test1")?;
    }

    // Create another temporary file with a random name.
    {
        let file = temp_dir.create_random_file()?;
        write!(file, "Random file content")?;
    }

    // List all the temporary files managed by the directory.
    for file_path in temp_dir.list_files() {
        println!("Managed temp file: {file_path:?}");
    }

    // If the library was built with regex support, search for files matching a pattern.
    #[cfg(feature = "regex_support")]
    {
        let matching_files = temp_dir.find_files_by_pattern(r"^test\d\.txt$")?;
        for file in matching_files {
            if let Some(path) = file.path() {
                println!("Found file matching regex: {path:?}");
            }
        }
    }

    // When `temp_dir` goes out of scope, the directory and all its managed files are automatically deleted.
    Ok(())
}

pub fn find_files_by_pattern_mut<S: AsRef<str>>( &mut self, pattern: S, ) -> Result<Vec<&mut TempFile>, RErr>

Finds mutable references to files with names matching a regex pattern.

Arguments

• pattern - A regex pattern to match file names.

Errors

Returns an error if the regex pattern is invalid.

Trait Implementations

impl AsRef<Path> for TempDir

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl Drop for TempDir

fn drop(&mut self)

Executes the destructor for this type.