swdir 0.9.0

Swiftly traverse and scan directories recursively. Sway 🪭, swing 🎷 or swim 🪼 in directories.
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use rayon::{
    ThreadPoolBuilder,
    iter::{IntoParallelIterator, ParallelIterator},
};

use std::fs;
use std::path::Path;

use crate::helpers::file::is_hidden;

use super::DirNode;
use super::Swdir;

impl Swdir {
    /// scan to build tree with concurrency of specified process number
    pub(super) fn walk_parallel(&self) -> DirNode {
        // thread pool
        let pool = ThreadPoolBuilder::new()
            .num_threads(self.max_threads)
            .build()
            .expect("failed to build rayon thread pool");

        // scan in the pool
        pool.install(|| self.scan_node(self.root_path.as_path().as_ref(), self.recurse.depth_limit))
    }

    /// scan node to build subtree
    fn scan_node(&self, dir_path: &Path, depth_limit: Option<usize>) -> DirNode {
        let mut files = Vec::new();
        // condition to scan sud directories: only when recurse.enabled is true and depth_limit has capacity
        let scan_sub_dir_enabled =
            self.recurse.enabled && (depth_limit.is_none() || depth_limit.is_some_and(|x| 1 <= x));
        let mut sub_dir_paths = if scan_sub_dir_enabled {
            Some(Vec::new())
        } else {
            None
        };

        // scan current directory
        let entries = match fs::read_dir(dir_path) {
            Ok(x) => x,
            Err(err) => {
                // todo: error handling
                eprintln!(
                    "⚠️ Access denied or error: {} ({})",
                    dir_path.display(),
                    err,
                );

                return DirNode {
                    path: dir_path.to_path_buf(),
                    sub_dirs: vec![],
                    files: vec![],
                };
            }
        };

        for entry in entries.filter_map(Result::ok) {
            let path = entry.path();

            if !self.include_hidden && is_hidden(&entry) {
                continue;
            }

            if path.is_dir() {
                if let Some(sub_dir_paths) = sub_dir_paths.as_mut() {
                    sub_dir_paths.push(path);
                }
                continue;
            }

            let should_push = if let Some(extension_allowlist) = &self.extension_allowlist {
                if let Some(extension) = path.extension() {
                    let extension = extension.to_string_lossy();
                    extension_allowlist.iter().any(|x| **x == extension)
                } else {
                    false
                }
            } else if let Some(extension_denylist) = &self.extension_denylist {
                if let Some(extension) = path.extension() {
                    let extension = extension.to_string_lossy();
                    extension_denylist.iter().all(|x| **x != extension)
                } else {
                    self.include_hidden || !is_hidden(&entry)
                }
            } else {
                true
            };

            if should_push {
                files.push(path);
            }
        }

        // scan subdirectories recursively
        let mut sub_dirs = if let Some(sub_dir_paths) = &sub_dir_paths {
            sub_dir_paths
                .into_par_iter()
                .map(|path| {
                    let depth_limit = if let Some(depth_limit) = depth_limit {
                        Some(depth_limit - 1)
                    } else {
                        None
                    };
                    // recursion
                    self.scan_node(&path, depth_limit)
                })
                .collect()
        } else {
            Vec::new()
        };

        sub_dirs.sort();
        files.sort();

        DirNode {
            path: dir_path.to_path_buf(),
            sub_dirs,
            files,
        }
    }
}