Struct TreeBuilder

pub struct TreeBuilder {
    pub root: PathBuf,
    /* private fields */
}

Represents a file tree structure

Examples

use tree_fs::{TreeBuilder, Settings};
let tree = TreeBuilder::default()
    .add_file("config/app.conf", "host = localhost")
    .add_empty_file("logs/app.log")
    .add_directory("data/raw")
    .add_file_with_settings(
        "secrets/api.key",
        "supersecretkey",
        Settings::new().readonly(true)
    )
    .create()
    .expect("create tree fs");
println!("Created a complex tree in: {}", tree.root.display());

// You can verify the readonly status (this requires std::fs)
// let key_path = tree.root.join("secrets/api.key");
// let metadata = std::fs::metadata(key_path).unwrap();
// assert!(metadata.permissions().readonly());

use tree_fs::TreeBuilder;
let tree = TreeBuilder::default()
     .add_file("temp_data/file.txt", "temporary content")
     .add_empty_file("temp_data/another.tmp")
     .drop(true) // This is the default, but explicitly shown here
     .create()
     .expect("create tree fs for drop example");

println!("Temporary tree created at: {}", tree.root.display());

let path_to_check = tree.root.clone();
assert!(path_to_check.exists(), "Directory should exist before drop");

drop(tree); // tree_fs instance goes out of scope
assert!(!path_to_check.exists(), "Directory should be deleted after drop");

Fields

root: PathBuf

Root folder where the tree will be created.

Implementations

impl TreeBuilder

pub fn root_folder<P: AsRef<Path>>(self, dir: P) -> Self

Sets the root folder where the tree will be created.

Examples found in repository

examples/builder.rs (line 30)

fn main() {
    println!("--- Comprehensive TreeBuilder Example ---");

    // 1. Default behavior: creates in a temporary directory, auto-drops
    let default_tree = TreeBuilder::default()
        .add_file("default_file.txt", "Content in default temp dir")
        .create()
        .expect("Failed to create default tree");
    println!("Default tree created in: {}", default_tree.root.display());
    let default_path = default_tree.root.clone();
    assert!(default_path.exists());
    drop(default_tree);
    assert!(
        !default_path.exists(),
        "Default tree should be auto-deleted."
    );
    println!("Default tree auto-deleted successfully.");

    // 2. Custom root, various file types, and settings
    let custom_root_path = std::env::temp_dir().join("tree_fs_custom_example");
    // Clean up previous run if any, for idempotency of example
    if custom_root_path.exists() {
        let _ = fs::remove_dir_all(&custom_root_path);
    }

    let complex_tree = TreeBuilder::default()
        .root_folder(&custom_root_path) // Custom root
        .add_file("project/README.md", "# My Project")
        .add_empty_file("project/.gitignore")
        .add_directory("project/src")
        .add_file("project/src/main.rs", "fn main() { println!(\"Hello!\"); }")
        .add_directory("project/config")
        .add_file_with_settings(
            "project/config/prod.json",
            "{ \"api_key\": \"prod_secret\" }",
            Settings::new().readonly(true), // Read-only setting
        )
        .add_readonly_file("project/config/default.json", "{ \"timeout\": 5000 }")
        .override_file(true) // Allow overwriting if files exist (e.g. from previous run if not cleaned)
        .drop(false) // Do not auto-delete this tree
        .create()
        .expect("Failed to create complex tree");

    println!("Complex tree created at: {}", complex_tree.root.display());
    println!("  (This tree will NOT be auto-deleted)");

    // Verify read-only status
    let readonly_config_path = complex_tree.root.join("project/config/prod.json");
    match fs::metadata(&readonly_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "prod.json should be read-only"
            );
            println!("Verified: {} is read-only.", readonly_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            readonly_config_path.display(),
            e
        ),
    }

    // Verify another readonly file
    let default_config_path = complex_tree.root.join("project/config/default.json");
    match fs::metadata(&default_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "default.json should be read-only"
            );
            println!("Verified: {} is read-only.", default_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            default_config_path.display(),
            e
        ),
    }

    println!(
        "Example finished. To clean up, manually delete: {}",
        custom_root_path.display()
    );
}

pub const fn drop(self, yes: bool) -> Self

Sets the drop flag, indicating whether to automatically delete the temporary folder when the tree_fs instance is dropped

Examples found in repository

examples/drop.rs (line 7)

fn main() {
    let tree = TreeBuilder::default()
        .add_file("temp_data/file.txt", "temporary content")
        .add_empty_file("temp_data/another.tmp")
        .drop(true)
        .create()
        .expect("create tree fs for drop example");

    println!("Temporary tree created at: {}", tree.root.display());

    let path_to_check = tree.root.clone();
    assert!(path_to_check.exists(), "Directory should exist before drop");

    drop(tree);
    assert!(
        !path_to_check.exists(),
        "Directory should be deleted after drop"
    );
    println!("Drop example: Temporary tree auto-deleted successfully.");
}

examples/builder.rs (line 43)

fn main() {
    println!("--- Comprehensive TreeBuilder Example ---");

    // 1. Default behavior: creates in a temporary directory, auto-drops
    let default_tree = TreeBuilder::default()
        .add_file("default_file.txt", "Content in default temp dir")
        .create()
        .expect("Failed to create default tree");
    println!("Default tree created in: {}", default_tree.root.display());
    let default_path = default_tree.root.clone();
    assert!(default_path.exists());
    drop(default_tree);
    assert!(
        !default_path.exists(),
        "Default tree should be auto-deleted."
    );
    println!("Default tree auto-deleted successfully.");

    // 2. Custom root, various file types, and settings
    let custom_root_path = std::env::temp_dir().join("tree_fs_custom_example");
    // Clean up previous run if any, for idempotency of example
    if custom_root_path.exists() {
        let _ = fs::remove_dir_all(&custom_root_path);
    }

    let complex_tree = TreeBuilder::default()
        .root_folder(&custom_root_path) // Custom root
        .add_file("project/README.md", "# My Project")
        .add_empty_file("project/.gitignore")
        .add_directory("project/src")
        .add_file("project/src/main.rs", "fn main() { println!(\"Hello!\"); }")
        .add_directory("project/config")
        .add_file_with_settings(
            "project/config/prod.json",
            "{ \"api_key\": \"prod_secret\" }",
            Settings::new().readonly(true), // Read-only setting
        )
        .add_readonly_file("project/config/default.json", "{ \"timeout\": 5000 }")
        .override_file(true) // Allow overwriting if files exist (e.g. from previous run if not cleaned)
        .drop(false) // Do not auto-delete this tree
        .create()
        .expect("Failed to create complex tree");

    println!("Complex tree created at: {}", complex_tree.root.display());
    println!("  (This tree will NOT be auto-deleted)");

    // Verify read-only status
    let readonly_config_path = complex_tree.root.join("project/config/prod.json");
    match fs::metadata(&readonly_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "prod.json should be read-only"
            );
            println!("Verified: {} is read-only.", readonly_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            readonly_config_path.display(),
            e
        ),
    }

    // Verify another readonly file
    let default_config_path = complex_tree.root.join("project/config/default.json");
    match fs::metadata(&default_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "default.json should be read-only"
            );
            println!("Verified: {} is read-only.", default_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            default_config_path.display(),
            e
        ),
    }

    println!(
        "Example finished. To clean up, manually delete: {}",
        custom_root_path.display()
    );
}

pub const fn override_file(self, yes: bool) -> Self

Sets the override_file flag, indicating whether existing files should be overridden.

Examples found in repository

examples/builder.rs (line 42)

fn main() {
    println!("--- Comprehensive TreeBuilder Example ---");

    // 1. Default behavior: creates in a temporary directory, auto-drops
    let default_tree = TreeBuilder::default()
        .add_file("default_file.txt", "Content in default temp dir")
        .create()
        .expect("Failed to create default tree");
    println!("Default tree created in: {}", default_tree.root.display());
    let default_path = default_tree.root.clone();
    assert!(default_path.exists());
    drop(default_tree);
    assert!(
        !default_path.exists(),
        "Default tree should be auto-deleted."
    );
    println!("Default tree auto-deleted successfully.");

    // 2. Custom root, various file types, and settings
    let custom_root_path = std::env::temp_dir().join("tree_fs_custom_example");
    // Clean up previous run if any, for idempotency of example
    if custom_root_path.exists() {
        let _ = fs::remove_dir_all(&custom_root_path);
    }

    let complex_tree = TreeBuilder::default()
        .root_folder(&custom_root_path) // Custom root
        .add_file("project/README.md", "# My Project")
        .add_empty_file("project/.gitignore")
        .add_directory("project/src")
        .add_file("project/src/main.rs", "fn main() { println!(\"Hello!\"); }")
        .add_directory("project/config")
        .add_file_with_settings(
            "project/config/prod.json",
            "{ \"api_key\": \"prod_secret\" }",
            Settings::new().readonly(true), // Read-only setting
        )
        .add_readonly_file("project/config/default.json", "{ \"timeout\": 5000 }")
        .override_file(true) // Allow overwriting if files exist (e.g. from previous run if not cleaned)
        .drop(false) // Do not auto-delete this tree
        .create()
        .expect("Failed to create complex tree");

    println!("Complex tree created at: {}", complex_tree.root.display());
    println!("  (This tree will NOT be auto-deleted)");

    // Verify read-only status
    let readonly_config_path = complex_tree.root.join("project/config/prod.json");
    match fs::metadata(&readonly_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "prod.json should be read-only"
            );
            println!("Verified: {} is read-only.", readonly_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            readonly_config_path.display(),
            e
        ),
    }

    // Verify another readonly file
    let default_config_path = complex_tree.root.join("project/config/default.json");
    match fs::metadata(&default_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "default.json should be read-only"
            );
            println!("Verified: {} is read-only.", default_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            default_config_path.display(),
            e
        ),
    }

    println!(
        "Example finished. To clean up, manually delete: {}",
        custom_root_path.display()
    );
}

pub fn add<P: AsRef<Path>>(self, path: P, content: &str) -> Self

Adds a file with content to the tree.

pub fn add_file<P: AsRef<Path>>(self, path: P, content: &str) -> Self

Adds a file with content to the tree.

This is an alias for add.

Examples found in repository

examples/drop.rs (line 5)

fn main() {
    let tree = TreeBuilder::default()
        .add_file("temp_data/file.txt", "temporary content")
        .add_empty_file("temp_data/another.tmp")
        .drop(true)
        .create()
        .expect("create tree fs for drop example");

    println!("Temporary tree created at: {}", tree.root.display());

    let path_to_check = tree.root.clone();
    assert!(path_to_check.exists(), "Directory should exist before drop");

    drop(tree);
    assert!(
        !path_to_check.exists(),
        "Directory should be deleted after drop"
    );
    println!("Drop example: Temporary tree auto-deleted successfully.");
}

examples/builder.rs (line 9)

fn main() {
    println!("--- Comprehensive TreeBuilder Example ---");

    // 1. Default behavior: creates in a temporary directory, auto-drops
    let default_tree = TreeBuilder::default()
        .add_file("default_file.txt", "Content in default temp dir")
        .create()
        .expect("Failed to create default tree");
    println!("Default tree created in: {}", default_tree.root.display());
    let default_path = default_tree.root.clone();
    assert!(default_path.exists());
    drop(default_tree);
    assert!(
        !default_path.exists(),
        "Default tree should be auto-deleted."
    );
    println!("Default tree auto-deleted successfully.");

    // 2. Custom root, various file types, and settings
    let custom_root_path = std::env::temp_dir().join("tree_fs_custom_example");
    // Clean up previous run if any, for idempotency of example
    if custom_root_path.exists() {
        let _ = fs::remove_dir_all(&custom_root_path);
    }

    let complex_tree = TreeBuilder::default()
        .root_folder(&custom_root_path) // Custom root
        .add_file("project/README.md", "# My Project")
        .add_empty_file("project/.gitignore")
        .add_directory("project/src")
        .add_file("project/src/main.rs", "fn main() { println!(\"Hello!\"); }")
        .add_directory("project/config")
        .add_file_with_settings(
            "project/config/prod.json",
            "{ \"api_key\": \"prod_secret\" }",
            Settings::new().readonly(true), // Read-only setting
        )
        .add_readonly_file("project/config/default.json", "{ \"timeout\": 5000 }")
        .override_file(true) // Allow overwriting if files exist (e.g. from previous run if not cleaned)
        .drop(false) // Do not auto-delete this tree
        .create()
        .expect("Failed to create complex tree");

    println!("Complex tree created at: {}", complex_tree.root.display());
    println!("  (This tree will NOT be auto-deleted)");

    // Verify read-only status
    let readonly_config_path = complex_tree.root.join("project/config/prod.json");
    match fs::metadata(&readonly_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "prod.json should be read-only"
            );
            println!("Verified: {} is read-only.", readonly_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            readonly_config_path.display(),
            e
        ),
    }

    // Verify another readonly file
    let default_config_path = complex_tree.root.join("project/config/default.json");
    match fs::metadata(&default_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "default.json should be read-only"
            );
            println!("Verified: {} is read-only.", default_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            default_config_path.display(),
            e
        ),
    }

    println!(
        "Example finished. To clean up, manually delete: {}",
        custom_root_path.display()
    );
}

pub fn add_empty<P: AsRef<Path>>(self, path: P) -> Self

Adds a file with a empty content.

pub fn add_empty_file<P: AsRef<Path>>(self, path: P) -> Self

Adds a file with a empty content.

Examples found in repository

examples/drop.rs (line 6)

fn main() {
    let tree = TreeBuilder::default()
        .add_file("temp_data/file.txt", "temporary content")
        .add_empty_file("temp_data/another.tmp")
        .drop(true)
        .create()
        .expect("create tree fs for drop example");

    println!("Temporary tree created at: {}", tree.root.display());

    let path_to_check = tree.root.clone();
    assert!(path_to_check.exists(), "Directory should exist before drop");

    drop(tree);
    assert!(
        !path_to_check.exists(),
        "Directory should be deleted after drop"
    );
    println!("Drop example: Temporary tree auto-deleted successfully.");
}

examples/builder.rs (line 32)

fn main() {
    println!("--- Comprehensive TreeBuilder Example ---");

    // 1. Default behavior: creates in a temporary directory, auto-drops
    let default_tree = TreeBuilder::default()
        .add_file("default_file.txt", "Content in default temp dir")
        .create()
        .expect("Failed to create default tree");
    println!("Default tree created in: {}", default_tree.root.display());
    let default_path = default_tree.root.clone();
    assert!(default_path.exists());
    drop(default_tree);
    assert!(
        !default_path.exists(),
        "Default tree should be auto-deleted."
    );
    println!("Default tree auto-deleted successfully.");

    // 2. Custom root, various file types, and settings
    let custom_root_path = std::env::temp_dir().join("tree_fs_custom_example");
    // Clean up previous run if any, for idempotency of example
    if custom_root_path.exists() {
        let _ = fs::remove_dir_all(&custom_root_path);
    }

    let complex_tree = TreeBuilder::default()
        .root_folder(&custom_root_path) // Custom root
        .add_file("project/README.md", "# My Project")
        .add_empty_file("project/.gitignore")
        .add_directory("project/src")
        .add_file("project/src/main.rs", "fn main() { println!(\"Hello!\"); }")
        .add_directory("project/config")
        .add_file_with_settings(
            "project/config/prod.json",
            "{ \"api_key\": \"prod_secret\" }",
            Settings::new().readonly(true), // Read-only setting
        )
        .add_readonly_file("project/config/default.json", "{ \"timeout\": 5000 }")
        .override_file(true) // Allow overwriting if files exist (e.g. from previous run if not cleaned)
        .drop(false) // Do not auto-delete this tree
        .create()
        .expect("Failed to create complex tree");

    println!("Complex tree created at: {}", complex_tree.root.display());
    println!("  (This tree will NOT be auto-deleted)");

    // Verify read-only status
    let readonly_config_path = complex_tree.root.join("project/config/prod.json");
    match fs::metadata(&readonly_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "prod.json should be read-only"
            );
            println!("Verified: {} is read-only.", readonly_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            readonly_config_path.display(),
            e
        ),
    }

    // Verify another readonly file
    let default_config_path = complex_tree.root.join("project/config/default.json");
    match fs::metadata(&default_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "default.json should be read-only"
            );
            println!("Verified: {} is read-only.", default_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            default_config_path.display(),
            e
        ),
    }

    println!(
        "Example finished. To clean up, manually delete: {}",
        custom_root_path.display()
    );
}

pub fn add_directory<P: AsRef<Path>>(self, path: P) -> Self

Adds a directory to the tree.

Examples found in repository

examples/builder.rs (line 33)

fn main() {
    println!("--- Comprehensive TreeBuilder Example ---");

    // 1. Default behavior: creates in a temporary directory, auto-drops
    let default_tree = TreeBuilder::default()
        .add_file("default_file.txt", "Content in default temp dir")
        .create()
        .expect("Failed to create default tree");
    println!("Default tree created in: {}", default_tree.root.display());
    let default_path = default_tree.root.clone();
    assert!(default_path.exists());
    drop(default_tree);
    assert!(
        !default_path.exists(),
        "Default tree should be auto-deleted."
    );
    println!("Default tree auto-deleted successfully.");

    // 2. Custom root, various file types, and settings
    let custom_root_path = std::env::temp_dir().join("tree_fs_custom_example");
    // Clean up previous run if any, for idempotency of example
    if custom_root_path.exists() {
        let _ = fs::remove_dir_all(&custom_root_path);
    }

    let complex_tree = TreeBuilder::default()
        .root_folder(&custom_root_path) // Custom root
        .add_file("project/README.md", "# My Project")
        .add_empty_file("project/.gitignore")
        .add_directory("project/src")
        .add_file("project/src/main.rs", "fn main() { println!(\"Hello!\"); }")
        .add_directory("project/config")
        .add_file_with_settings(
            "project/config/prod.json",
            "{ \"api_key\": \"prod_secret\" }",
            Settings::new().readonly(true), // Read-only setting
        )
        .add_readonly_file("project/config/default.json", "{ \"timeout\": 5000 }")
        .override_file(true) // Allow overwriting if files exist (e.g. from previous run if not cleaned)
        .drop(false) // Do not auto-delete this tree
        .create()
        .expect("Failed to create complex tree");

    println!("Complex tree created at: {}", complex_tree.root.display());
    println!("  (This tree will NOT be auto-deleted)");

    // Verify read-only status
    let readonly_config_path = complex_tree.root.join("project/config/prod.json");
    match fs::metadata(&readonly_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "prod.json should be read-only"
            );
            println!("Verified: {} is read-only.", readonly_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            readonly_config_path.display(),
            e
        ),
    }

    // Verify another readonly file
    let default_config_path = complex_tree.root.join("project/config/default.json");
    match fs::metadata(&default_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "default.json should be read-only"
            );
            println!("Verified: {} is read-only.", default_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            default_config_path.display(),
            e
        ),
    }

    println!(
        "Example finished. To clean up, manually delete: {}",
        custom_root_path.display()
    );
}

pub fn add_file_with_settings<P: AsRef<Path>>( self, path: P, content: &str, settings: Settings, ) -> Self

Adds a file with content and custom settings to the tree.

Examples found in repository

examples/builder.rs (lines 36-40)

fn main() {
    println!("--- Comprehensive TreeBuilder Example ---");

    // 1. Default behavior: creates in a temporary directory, auto-drops
    let default_tree = TreeBuilder::default()
        .add_file("default_file.txt", "Content in default temp dir")
        .create()
        .expect("Failed to create default tree");
    println!("Default tree created in: {}", default_tree.root.display());
    let default_path = default_tree.root.clone();
    assert!(default_path.exists());
    drop(default_tree);
    assert!(
        !default_path.exists(),
        "Default tree should be auto-deleted."
    );
    println!("Default tree auto-deleted successfully.");

    // 2. Custom root, various file types, and settings
    let custom_root_path = std::env::temp_dir().join("tree_fs_custom_example");
    // Clean up previous run if any, for idempotency of example
    if custom_root_path.exists() {
        let _ = fs::remove_dir_all(&custom_root_path);
    }

    let complex_tree = TreeBuilder::default()
        .root_folder(&custom_root_path) // Custom root
        .add_file("project/README.md", "# My Project")
        .add_empty_file("project/.gitignore")
        .add_directory("project/src")
        .add_file("project/src/main.rs", "fn main() { println!(\"Hello!\"); }")
        .add_directory("project/config")
        .add_file_with_settings(
            "project/config/prod.json",
            "{ \"api_key\": \"prod_secret\" }",
            Settings::new().readonly(true), // Read-only setting
        )
        .add_readonly_file("project/config/default.json", "{ \"timeout\": 5000 }")
        .override_file(true) // Allow overwriting if files exist (e.g. from previous run if not cleaned)
        .drop(false) // Do not auto-delete this tree
        .create()
        .expect("Failed to create complex tree");

    println!("Complex tree created at: {}", complex_tree.root.display());
    println!("  (This tree will NOT be auto-deleted)");

    // Verify read-only status
    let readonly_config_path = complex_tree.root.join("project/config/prod.json");
    match fs::metadata(&readonly_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "prod.json should be read-only"
            );
            println!("Verified: {} is read-only.", readonly_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            readonly_config_path.display(),
            e
        ),
    }

    // Verify another readonly file
    let default_config_path = complex_tree.root.join("project/config/default.json");
    match fs::metadata(&default_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "default.json should be read-only"
            );
            println!("Verified: {} is read-only.", default_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            default_config_path.display(),
            e
        ),
    }

    println!(
        "Example finished. To clean up, manually delete: {}",
        custom_root_path.display()
    );
}

pub fn add_empty_file_with_settings<P: AsRef<Path>>( self, path: P, settings: Settings, ) -> Self

Adds an empty file with custom settings to the tree.

pub fn add_directory_with_settings<P: AsRef<Path>>( self, path: P, settings: Settings, ) -> Self

Adds a directory with custom settings to the tree.

pub fn add_readonly_file<P: AsRef<Path>>(self, path: P, content: &str) -> Self

Convenience method for adding a read-only file.

Examples found in repository

examples/builder.rs (line 41)

fn main() {
    println!("--- Comprehensive TreeBuilder Example ---");

    // 1. Default behavior: creates in a temporary directory, auto-drops
    let default_tree = TreeBuilder::default()
        .add_file("default_file.txt", "Content in default temp dir")
        .create()
        .expect("Failed to create default tree");
    println!("Default tree created in: {}", default_tree.root.display());
    let default_path = default_tree.root.clone();
    assert!(default_path.exists());
    drop(default_tree);
    assert!(
        !default_path.exists(),
        "Default tree should be auto-deleted."
    );
    println!("Default tree auto-deleted successfully.");

    // 2. Custom root, various file types, and settings
    let custom_root_path = std::env::temp_dir().join("tree_fs_custom_example");
    // Clean up previous run if any, for idempotency of example
    if custom_root_path.exists() {
        let _ = fs::remove_dir_all(&custom_root_path);
    }

    let complex_tree = TreeBuilder::default()
        .root_folder(&custom_root_path) // Custom root
        .add_file("project/README.md", "# My Project")
        .add_empty_file("project/.gitignore")
        .add_directory("project/src")
        .add_file("project/src/main.rs", "fn main() { println!(\"Hello!\"); }")
        .add_directory("project/config")
        .add_file_with_settings(
            "project/config/prod.json",
            "{ \"api_key\": \"prod_secret\" }",
            Settings::new().readonly(true), // Read-only setting
        )
        .add_readonly_file("project/config/default.json", "{ \"timeout\": 5000 }")
        .override_file(true) // Allow overwriting if files exist (e.g. from previous run if not cleaned)
        .drop(false) // Do not auto-delete this tree
        .create()
        .expect("Failed to create complex tree");

    println!("Complex tree created at: {}", complex_tree.root.display());
    println!("  (This tree will NOT be auto-deleted)");

    // Verify read-only status
    let readonly_config_path = complex_tree.root.join("project/config/prod.json");
    match fs::metadata(&readonly_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "prod.json should be read-only"
            );
            println!("Verified: {} is read-only.", readonly_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            readonly_config_path.display(),
            e
        ),
    }

    // Verify another readonly file
    let default_config_path = complex_tree.root.join("project/config/default.json");
    match fs::metadata(&default_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "default.json should be read-only"
            );
            println!("Verified: {} is read-only.", default_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            default_config_path.display(),
            e
        ),
    }

    println!(
        "Example finished. To clean up, manually delete: {}",
        custom_root_path.display()
    );
}

pub fn add_readonly_empty_file<P: AsRef<Path>>(self, path: P) -> Self

Convenience method for adding a read-only empty file.

pub fn create(&self) -> Result<Tree>

Creates the file tree by generating files and directories based on the specified metadata.

Errors

Returns an std::io::Result indicating success or failure in creating the file tree.

Examples found in repository

examples/drop.rs (line 8)

fn main() {
    let tree = TreeBuilder::default()
        .add_file("temp_data/file.txt", "temporary content")
        .add_empty_file("temp_data/another.tmp")
        .drop(true)
        .create()
        .expect("create tree fs for drop example");

    println!("Temporary tree created at: {}", tree.root.display());

    let path_to_check = tree.root.clone();
    assert!(path_to_check.exists(), "Directory should exist before drop");

    drop(tree);
    assert!(
        !path_to_check.exists(),
        "Directory should be deleted after drop"
    );
    println!("Drop example: Temporary tree auto-deleted successfully.");
}

examples/builder.rs (line 10)

fn main() {
    println!("--- Comprehensive TreeBuilder Example ---");

    // 1. Default behavior: creates in a temporary directory, auto-drops
    let default_tree = TreeBuilder::default()
        .add_file("default_file.txt", "Content in default temp dir")
        .create()
        .expect("Failed to create default tree");
    println!("Default tree created in: {}", default_tree.root.display());
    let default_path = default_tree.root.clone();
    assert!(default_path.exists());
    drop(default_tree);
    assert!(
        !default_path.exists(),
        "Default tree should be auto-deleted."
    );
    println!("Default tree auto-deleted successfully.");

    // 2. Custom root, various file types, and settings
    let custom_root_path = std::env::temp_dir().join("tree_fs_custom_example");
    // Clean up previous run if any, for idempotency of example
    if custom_root_path.exists() {
        let _ = fs::remove_dir_all(&custom_root_path);
    }

    let complex_tree = TreeBuilder::default()
        .root_folder(&custom_root_path) // Custom root
        .add_file("project/README.md", "# My Project")
        .add_empty_file("project/.gitignore")
        .add_directory("project/src")
        .add_file("project/src/main.rs", "fn main() { println!(\"Hello!\"); }")
        .add_directory("project/config")
        .add_file_with_settings(
            "project/config/prod.json",
            "{ \"api_key\": \"prod_secret\" }",
            Settings::new().readonly(true), // Read-only setting
        )
        .add_readonly_file("project/config/default.json", "{ \"timeout\": 5000 }")
        .override_file(true) // Allow overwriting if files exist (e.g. from previous run if not cleaned)
        .drop(false) // Do not auto-delete this tree
        .create()
        .expect("Failed to create complex tree");

    println!("Complex tree created at: {}", complex_tree.root.display());
    println!("  (This tree will NOT be auto-deleted)");

    // Verify read-only status
    let readonly_config_path = complex_tree.root.join("project/config/prod.json");
    match fs::metadata(&readonly_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "prod.json should be read-only"
            );
            println!("Verified: {} is read-only.", readonly_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            readonly_config_path.display(),
            e
        ),
    }

    // Verify another readonly file
    let default_config_path = complex_tree.root.join("project/config/default.json");
    match fs::metadata(&default_config_path) {
        Ok(metadata) => {
            assert!(
                metadata.permissions().readonly(),
                "default.json should be read-only"
            );
            println!("Verified: {} is read-only.", default_config_path.display());
        }
        Err(e) => eprintln!(
            "Could not get metadata for {}: {}",
            default_config_path.display(),
            e
        ),
    }

    println!(
        "Example finished. To clean up, manually delete: {}",
        custom_root_path.display()
    );
}

Trait Implementations

impl Debug for TreeBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TreeBuilder

fn default() -> Self

Creates a default Tree instance with an empty file list,

impl<'de> Deserialize<'de> for TreeBuilder

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.