Method run

src/folder.rs:172–240

(self, control: &ControlToken<Self::Status>)

    type Status = (PathBuf, FolderSummary);

    fn run(self, control: &ControlToken<Self::Status>) -> Self::Output {
        let FolderScan { path, excludes } = self;
        let mut ds = FolderInfo::new(&path);
        let incompressible = pathdb();
        let mut incompressible = incompressible.write().unwrap();
        let _ = incompressible.load();

        let mut last_status = Instant::now();

        // 1. Handle excludes separately for directories to allow pruning, while
        //    still recording accurate sizes for files.
        // 2. Ignore errors - consider recording them somewhere in future.
        // 3. Only process files.
        // 4. Grab metadata - should be infallible on Windows, it comes with the
        //    DirEntry.
        // 5. GetCompressedFileSizeW() or skip.
        let walker = WalkDir::new(&path)
            .into_iter()
            .filter_entry(|e| e.file_type().is_file() || !excludes.is_match(e.path()))
            .filter_map(|e| e.map_err(|e| eprintln!("Error: {:?}", e)).ok())
            .filter(|e| e.file_type().is_file())
            .filter_map(|e| e.metadata().map(|md| (e, md)).ok())
            .filter_map(|(e, md)| e.path().size_on_disk().map(|s| (e, md, s)).ok())
            .enumerate();

        for (count, (entry, metadata, physical)) in walker {
            let shortname = entry
                .path()
                .strip_prefix(&path)
                .unwrap_or_else(|_e| entry.path())
                .to_path_buf();

            let fi = FileInfo {
                path: shortname,
                logical_size: metadata.len().max(physical),
                physical_size: physical,
            };

            if count % 8 == 0 {
                if control.is_cancelled_with_pause() {
                    return Err(ds);
                }

                if last_status.elapsed() >= Duration::from_millis(50) {
                    last_status = Instant::now();
                    control.set_status((fi.path.clone(), ds.summary()));
                }
            }

            if fi.physical_size < fi.logical_size {
                ds.push(FileKind::Compressed, fi);
            } else if fi.logical_size <= 4096
                || metadata.file_attributes()
                    & (FILE_ATTRIBUTE_READONLY
                        | FILE_ATTRIBUTE_SYSTEM
                        | FILE_ATTRIBUTE_TEMPORARY
                        | FILE_ATTRIBUTE_COMPRESSED)
                    != 0