fast-fs 0.2.1

High-speed async file system traversal library with batteries-included file browser component
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

//! Basic directory traversal example
//!
//! This example demonstrates the core directory reading functions.
//!
//! Run with: `cargo run --example basic_traversal`

use fast_fs::{read_dir, read_dir_recursive, read_dir_visible, TraversalOptions};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = std::env::args().nth(1).unwrap_or_else(|| ".".to_string());

    println!("=== Basic Directory Read ===");
    println!("Reading: {}\n", path);

    // Simple directory read (includes hidden files)
    let entries = read_dir(&path).await?;
    println!("Total entries: {}", entries.len());

    // Non-hidden files only
    let visible = read_dir_visible(&path).await?;
    println!("Visible entries: {}", visible.len());

    println!("\nFirst 10 entries:");
    for entry in entries.iter().take(10) {
        let kind = if entry.is_dir { "DIR " } else { "FILE" };
        let hidden = if entry.is_hidden { " (hidden)" } else { "" };
        println!("  {} {}{}", kind, entry.name, hidden);
    }

    println!("\n=== Recursive Traversal ===");

    // Recursive with options
    let options = TraversalOptions::default()
        .with_max_depth(2)
        .with_gitignore(true);

    let all_entries = read_dir_recursive(&path, options).await?;
    println!(
        "Total files (depth 2, respecting .gitignore): {}",
        all_entries.len()
    );

    // Filter by extension
    let options = TraversalOptions::default()
        .with_max_depth(3)
        .with_extensions(&["rs", "toml"]);

    let rust_files = read_dir_recursive(&path, options).await?;
    println!("Rust files (.rs, .toml): {}", rust_files.len());

    if !rust_files.is_empty() {
        println!("\nSample Rust files:");
        for entry in rust_files.iter().take(5) {
            println!("  {} ({} bytes)", entry.name, entry.size);
        }
    }

    Ok(())
}