Method extract_files

src/extraction_worker.rs:217–280

Process every entry in `files`, calling `on_progress(n, total, path)` once per file. Returns one tuple per successfully-processed file; files whose worker crashed or that had no extractor / read error are silently skipped (logged to stderr).

(
        self,
        files: Vec<String>,
        on_progress: F,
        per_file_timeout: Duration,
    )

    /// files whose worker crashed or that had no extractor / read error are
    /// silently skipped (logged to stderr).
    pub fn extract_files<F>(
        self,
        files: Vec<String>,
        on_progress: F,
        per_file_timeout: Duration,
    ) -> ExtractFilesOutcome
    where
        F: Fn(usize, usize, &str) + Send + Sync + 'static,
    {
        let total = files.len();
        let queue: Arc<Mutex<VecDeque<String>>> = Arc::new(Mutex::new(files.into_iter().collect()));
        let results: Arc<Mutex<Vec<ExtractTuple>>> =
            Arc::new(Mutex::new(Vec::with_capacity(total)));
        let skipped: Arc<Mutex<Vec<(String, String)>>> = Arc::new(Mutex::new(Vec::new()));
        let progress_count = Arc::new(AtomicUsize::new(0));
        let on_progress = Arc::new(on_progress);

        let handles: Vec<_> = self
            .workers
            .into_iter()
            .map(|worker| {
                let queue = queue.clone();
                let results = results.clone();
                let skipped = skipped.clone();
                let progress_count = progress_count.clone();
                let on_progress = on_progress.clone();
                let project_root = self.project_root.clone();
                let self_path = self.self_path.clone();
                let token = self.token;

                std::thread::spawn(move || {
                    worker_thread(
                        worker,
                        queue,
                        results,
                        skipped,
                        progress_count,
                        on_progress,
                        project_root,
                        self_path,
                        token,
                        total,
                        per_file_timeout,
                    );
                })
            })
            .collect();

        for h in handles {
            let _ = h.join();
        }

        // All worker threads have joined, so we hold the only Arc strong
        // reference. `into_inner` returns `Some` in that case; if it ever
        // returns `None` (concurrent leak), prefer an empty result over a
        // panic — the sync continues and the user just sees zero changes.
        let results = Arc::into_inner(results)
            .and_then(|m| m.into_inner().ok())