1use std::collections::HashMap;
5use std::env;
6use std::io::IsTerminal;
7use std::path::Path;
8use std::sync::Mutex;
9use std::time::Instant;
10
11use env_logger::Env;
12use indicatif::{MultiProgress, ProgressBar, ProgressDrawTarget, ProgressStyle};
13use indicatif_log_bridge::LogWrapper;
14use log::LevelFilter;
15
16use crate::cli::ProcessMode;
17use crate::models::{DiagnosticSeverity, FileInfo, FileType, Header, ScanDiagnostic};
18
19#[derive(Clone, Copy, Debug, PartialEq, Eq)]
20pub enum ProgressMode {
21 Quiet,
22 Default,
23 Verbose,
24}
25
26#[derive(Debug, Default, Clone)]
27pub struct ScanStats {
28 pub processes: ProcessMode,
29 pub scan_names: String,
30 pub initial_files: usize,
31 pub initial_dirs: usize,
32 pub initial_size: u64,
33 pub excluded_count: usize,
34 pub final_files: usize,
35 pub final_dirs: usize,
36 pub final_size: u64,
37 pub error_count: usize,
38 pub warning_count: usize,
39 pub total_bytes_scanned: u64,
40 pub packages_assembled: usize,
41 pub manifests_seen: usize,
42 pub top_level_timings: Vec<(String, f64)>,
43 pub detail_timings: Vec<(String, f64)>,
44 pub incremental_reused: usize,
45}
46
47pub struct ScanProgress {
48 mode: ProgressMode,
49 multi: MultiProgress,
50 scan_bar: ProgressBar,
51 stats: Mutex<ScanStats>,
52 phase_starts: Mutex<HashMap<&'static str, Instant>>,
53 phase_spinner: Mutex<Option<ProgressBar>>,
54 stderr_is_tty: bool,
55}
56
57impl ScanProgress {
58 pub fn new(mode: ProgressMode) -> Self {
59 let stderr_is_tty = std::io::stderr().is_terminal();
60 let multi = match mode {
61 ProgressMode::Quiet => MultiProgress::with_draw_target(ProgressDrawTarget::hidden()),
62 ProgressMode::Default if stderr_is_tty => {
63 MultiProgress::with_draw_target(ProgressDrawTarget::stderr_with_hz(15))
64 }
65 ProgressMode::Default | ProgressMode::Verbose => {
66 MultiProgress::with_draw_target(ProgressDrawTarget::hidden())
67 }
68 };
69
70 let scan_bar = if mode == ProgressMode::Default && stderr_is_tty {
71 multi.add(ProgressBar::new(0))
72 } else {
73 ProgressBar::hidden()
74 };
75
76 scan_bar.set_style(
77 ProgressStyle::default_bar()
78 .template(
79 "{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {pos}/{len} files ({per_sec}) ({eta})",
80 )
81 .expect("Failed to create progress bar style")
82 .progress_chars("#>-"),
83 );
84
85 Self {
86 mode,
87 multi,
88 scan_bar,
89 stats: Mutex::new(ScanStats::default()),
90 phase_starts: Mutex::new(HashMap::new()),
91 phase_spinner: Mutex::new(None),
92 stderr_is_tty,
93 }
94 }
95
96 pub fn start_setup(&self) {
97 self.start_phase("setup");
98 }
99
100 pub fn finish_setup(&self) {
101 self.finish_top_level_phase("setup");
102 }
103
104 pub fn set_processes(&self, processes: ProcessMode) {
105 let mut stats = self.stats.lock().expect("stats lock poisoned");
106 stats.processes = processes;
107 }
108
109 pub fn set_scan_names(&self, scan_names: String) {
110 let mut stats = self.stats.lock().expect("stats lock poisoned");
111 stats.scan_names = scan_names;
112 }
113
114 pub fn init_logging_bridge(&self) {
115 if self.mode == ProgressMode::Quiet {
116 return;
117 }
118
119 let logger = build_env_logger();
120 let level = logger.filter();
121 if LogWrapper::new(self.multi.clone(), logger)
122 .try_init()
123 .is_ok()
124 {
125 log::set_max_level(level);
126 }
127 }
128
129 pub fn start_discovery(&self) {
130 self.start_phase("inventory");
131 match self.mode {
132 ProgressMode::Quiet => {}
133 ProgressMode::Default => {
134 self.start_spinner("Collecting files...");
135 }
136 ProgressMode::Verbose => {
137 self.message("Collecting files...");
138 }
139 }
140 }
141
142 pub fn finish_discovery(&self, files: usize, dirs: usize, size: u64, excluded: usize) {
143 self.finish_spinner();
144 self.finish_top_level_phase("inventory");
145 let mut stats = self.stats.lock().expect("stats lock poisoned");
146 stats.initial_files = files;
147 stats.initial_dirs = dirs;
148 stats.initial_size = size;
149 stats.excluded_count = excluded;
150 }
151
152 pub fn start_license_detection_engine_creation(&self) {
153 self.start_phase("license_detection_engine_creation");
154 self.message("Loading SPDX data, this may take a while...");
155 }
156
157 pub fn finish_license_detection_engine_creation(&self, detail_name: impl Into<String>) {
158 self.finish_detail_phase(detail_name.into(), "license_detection_engine_creation");
159 }
160
161 pub fn start_scan(&self, total_files: usize) {
162 self.start_phase("scan");
163 self.scan_bar.set_length(total_files as u64);
164 self.scan_bar.set_position(0);
165
166 if matches!(self.mode, ProgressMode::Default | ProgressMode::Verbose) && !self.stderr_is_tty
167 {
168 self.message(&format!(
169 "Scanning {total_files} {}...",
170 pluralize_files(total_files)
171 ));
172 }
173 }
174
175 pub fn file_completed(&self, path: &Path, bytes: u64, scan_diagnostics: &[ScanDiagnostic]) {
176 self.scan_bar.inc(1);
177 let mut stats = self.stats.lock().expect("stats lock poisoned");
178 stats.total_bytes_scanned += bytes;
179
180 let (errors, warnings) = partition_scan_diagnostics(scan_diagnostics);
181
182 if !errors.is_empty() {
183 stats.error_count += 1;
184 } else if !warnings.is_empty() {
185 stats.warning_count += 1;
186 }
187 drop(stats);
188
189 match self.mode {
190 ProgressMode::Quiet => {}
191 ProgressMode::Default => {
192 if let Some(formatted) =
193 format_default_scan_error_from_diagnostics(path, scan_diagnostics)
194 {
195 self.error(&formatted);
196 } else if let Some(formatted) =
197 format_default_scan_warning_from_list(path, &warnings)
198 {
199 self.message(&format!("Warning: {formatted}"));
200 }
201 }
202 ProgressMode::Verbose => {
203 if self.stderr_is_tty || !errors.is_empty() || !warnings.is_empty() {
204 self.message(&path.to_string_lossy());
205 }
206 for err in &errors {
207 for line in err.lines() {
208 self.error(&format!(" {line}"));
209 }
210 }
211 for warning in &warnings {
212 for line in warning.lines() {
213 self.message(&format!(" warning: {line}"));
214 }
215 }
216 }
217 }
218 }
219
220 pub fn record_runtime_error(&self, path: &Path, err: &str) {
221 let mut stats = self.stats.lock().expect("stats lock poisoned");
222 stats.error_count += 1;
223 drop(stats);
224
225 match self.mode {
226 ProgressMode::Quiet => {}
227 ProgressMode::Default => self.error(&format_default_scan_error(path, err)),
228 ProgressMode::Verbose => {
229 self.error(&format!("Path: {}", path.to_string_lossy()));
230 for line in err.lines() {
231 self.error(&format!(" {line}"));
232 }
233 }
234 }
235 }
236
237 pub fn record_additional_error(&self, err: &str) {
238 let mut stats = self.stats.lock().expect("stats lock poisoned");
239 stats.error_count += 1;
240 drop(stats);
241
242 if self.mode != ProgressMode::Quiet {
243 self.error(err);
244 }
245 }
246
247 pub fn finish_scan(&self) {
248 self.finish_top_level_phase("scan");
249 if self.mode == ProgressMode::Default && self.stderr_is_tty {
250 self.scan_bar.finish_with_message("Scan complete!");
251 } else {
252 self.scan_bar.finish_and_clear();
253 if matches!(self.mode, ProgressMode::Default)
254 || (self.mode == ProgressMode::Verbose && !self.stderr_is_tty)
255 {
256 self.message("Scan complete.");
257 }
258 }
259 }
260
261 pub fn record_incremental_reused(&self, count: usize) {
262 let mut stats = self.stats.lock().expect("stats lock poisoned");
263 stats.incremental_reused += count;
264 }
265
266 pub fn start_assembly(&self) {
267 self.start_phase("assembly");
268 match self.mode {
269 ProgressMode::Quiet => {}
270 ProgressMode::Default => self.start_spinner("Assembling packages..."),
271 ProgressMode::Verbose => self.message("Assembling packages..."),
272 }
273 }
274
275 pub fn assembly_step(&self, step: &str) {
276 if self.mode == ProgressMode::Verbose {
277 self.message(&format!(" {step}"));
278 }
279 }
280
281 pub fn finish_assembly(&self, packages_assembled: usize, manifests_seen: usize) {
282 self.finish_spinner();
283 self.finish_top_level_phase("assembly");
284 let mut stats = self.stats.lock().expect("stats lock poisoned");
285 stats.packages_assembled = packages_assembled;
286 stats.manifests_seen = manifests_seen;
287 }
288
289 pub fn start_output(&self) {
290 self.start_phase("output");
291 match self.mode {
292 ProgressMode::Quiet => {}
293 ProgressMode::Default => self.start_spinner("Writing output..."),
294 ProgressMode::Verbose => self.message("Writing output..."),
295 }
296 }
297
298 pub fn output_written(&self, text: &str) {
299 self.message(text);
300 }
301
302 pub fn finish_output(&self) {
303 self.finish_spinner();
304 self.finish_top_level_phase("output");
305 }
306
307 pub fn start_post_scan(&self) {
308 self.start_phase("post-scan");
309 if self.mode == ProgressMode::Verbose {
310 self.message("Post-processing scan results...");
311 }
312 }
313
314 pub fn post_scan_step(&self, step: &str) {
315 if self.mode == ProgressMode::Verbose {
316 self.message(&format!(" {step}"));
317 }
318 }
319
320 pub fn finish_post_scan(&self) {
321 self.finish_top_level_phase("post-scan");
322 }
323
324 pub fn start_finalize(&self) {
325 self.start_phase("finalize");
326 if self.mode == ProgressMode::Verbose {
327 self.message("Finalizing scan results...");
328 }
329 }
330
331 pub fn finalize_step(&self, step: &str) {
332 if self.mode == ProgressMode::Verbose {
333 self.message(&format!(" {step}"));
334 }
335 }
336
337 pub fn finish_finalize(&self) {
338 self.finish_top_level_phase("finalize");
339 }
340
341 pub fn record_detail_timing(&self, name: impl Into<String>, duration: f64) {
342 let mut stats = self.stats.lock().expect("stats lock poisoned");
343 accumulate_timing(&mut stats.detail_timings, name.into(), duration);
344 }
345
346 pub fn record_final_counts(&self, files: &[FileInfo]) {
347 let mut stats = self.stats.lock().expect("stats lock poisoned");
348 stats.final_files = files
349 .iter()
350 .filter(|f| f.file_type == FileType::File)
351 .count();
352 stats.final_dirs = files
353 .iter()
354 .filter(|f| f.file_type == FileType::Directory)
355 .count();
356 stats.final_size = files
357 .iter()
358 .filter(|f| f.file_type == FileType::File)
359 .map(|f| f.size)
360 .sum();
361 }
362
363 pub fn record_final_header_counts(&self, headers: &[Header]) {
364 let mut stats = self.stats.lock().expect("stats lock poisoned");
365 let header_error_count: usize = headers.iter().map(|header| header.errors.len()).sum();
366 let header_warning_count: usize = headers.iter().map(|header| header.warnings.len()).sum();
367
368 stats.error_count = stats.error_count.max(header_error_count);
369 stats.warning_count = stats.warning_count.max(header_warning_count);
370 }
371
372 pub fn display_summary(&self, scan_start: &str, scan_end: &str) {
373 if self.mode == ProgressMode::Quiet {
374 return;
375 }
376
377 let stats = self.stats.lock().expect("stats lock poisoned");
378
379 if stats.error_count > 0 {
380 self.error("Some files failed to scan properly:");
381 } else if stats.warning_count > 0 {
382 self.message("Some files reported recoverable scan warnings:");
383 }
384 for line in build_summary_messages(&stats, scan_start, scan_end) {
385 self.message(&line);
386 }
387 if stats.incremental_reused > 0 {
388 self.message(&format!(
389 "Incremental: {} unchanged file(s) reused",
390 stats.incremental_reused
391 ));
392 }
393 }
394
395 fn message(&self, msg: &str) {
396 if self.mode == ProgressMode::Quiet {
397 return;
398 }
399
400 if self.mode == ProgressMode::Default && self.stderr_is_tty {
401 let _ = self.multi.println(msg);
402 } else {
403 eprintln!("{msg}");
404 }
405 }
406
407 fn error(&self, msg: &str) {
408 if self.mode == ProgressMode::Quiet {
409 return;
410 }
411
412 if supports_color(self.stderr_is_tty) {
413 self.message(&format!("\u{1b}[31m{msg}\u{1b}[0m"));
414 } else {
415 self.message(msg);
416 }
417 }
418
419 fn start_phase(&self, phase: &'static str) {
420 self.phase_starts
421 .lock()
422 .expect("phase lock poisoned")
423 .insert(phase, Instant::now());
424 }
425
426 fn finish_top_level_phase(&self, phase: &'static str) {
427 let start = self
428 .phase_starts
429 .lock()
430 .expect("phase lock poisoned")
431 .remove(phase);
432 if let Some(start) = start {
433 let mut stats = self.stats.lock().expect("stats lock poisoned");
434 accumulate_timing(
435 &mut stats.top_level_timings,
436 phase.to_string(),
437 start.elapsed().as_secs_f64(),
438 );
439 }
440 }
441
442 fn finish_detail_phase(&self, name: String, phase: &'static str) {
443 let start = self
444 .phase_starts
445 .lock()
446 .expect("phase lock poisoned")
447 .remove(phase);
448 if let Some(start) = start {
449 let mut stats = self.stats.lock().expect("stats lock poisoned");
450 accumulate_timing(
451 &mut stats.detail_timings,
452 name,
453 start.elapsed().as_secs_f64(),
454 );
455 }
456 }
457
458 fn start_spinner(&self, message: &str) {
459 if self.mode != ProgressMode::Default || !self.stderr_is_tty {
460 self.message(message);
461 return;
462 }
463
464 let spinner = self.multi.add(ProgressBar::new_spinner());
465 spinner.set_style(
466 ProgressStyle::default_spinner()
467 .template("{spinner:.green} {msg}")
468 .expect("Failed to create spinner style"),
469 );
470 spinner.enable_steady_tick(std::time::Duration::from_millis(80));
471 spinner.set_message(message.to_string());
472 *self
473 .phase_spinner
474 .lock()
475 .expect("phase spinner lock poisoned") = Some(spinner);
476 }
477
478 fn finish_spinner(&self) {
479 if let Some(spinner) = self
480 .phase_spinner
481 .lock()
482 .expect("phase spinner lock poisoned")
483 .take()
484 {
485 spinner.finish_and_clear();
486 }
487 }
488}
489
490fn build_env_logger() -> env_logger::Logger {
491 let mut builder = env_logger::Builder::from_env(Env::default().default_filter_or("warn"));
492 apply_default_log_filters(&mut builder);
493 builder.build()
494}
495
496fn apply_default_log_filters(builder: &mut env_logger::Builder) {
497 apply_default_log_filters_from(builder, env::var("RUST_LOG").ok().as_deref());
498}
499
500fn apply_default_log_filters_from(builder: &mut env_logger::Builder, rust_log: Option<&str>) {
501 if let Some(level) = pdf_oxide_default_log_filter_from(rust_log) {
502 builder.filter_module("pdf_oxide", level);
503 }
504}
505
506pub(crate) fn format_default_scan_error(path: &Path, err: &str) -> String {
507 let reason = concise_scan_error_reason(err);
508 format!("{reason}: {}", path.to_string_lossy())
509}
510
511pub(crate) fn format_default_scan_error_from_diagnostics(
512 path: &Path,
513 scan_diagnostics: &[ScanDiagnostic],
514) -> Option<String> {
515 let errors: Vec<&ScanDiagnostic> = scan_diagnostics
516 .iter()
517 .filter(|d| {
518 d.severity == DiagnosticSeverity::Error || d.severity == DiagnosticSeverity::Timeout
519 })
520 .collect();
521
522 errors
523 .iter()
524 .find(|d| d.is_timeout())
525 .or_else(|| errors.first())
526 .map(|d| format_default_scan_error(path, &d.message))
527}
528
529pub(crate) fn format_default_scan_warning_from_list(
530 path: &Path,
531 scan_warnings: &[String],
532) -> Option<String> {
533 scan_warnings
534 .first()
535 .map(|warning| format_default_scan_error(path, warning))
536}
537
538pub(crate) fn partition_scan_diagnostics(
539 scan_diagnostics: &[ScanDiagnostic],
540) -> (Vec<String>, Vec<String>) {
541 let mut errors = Vec::new();
542 let mut warnings = Vec::new();
543
544 for diagnostic in scan_diagnostics {
545 match diagnostic.severity {
546 DiagnosticSeverity::Error | DiagnosticSeverity::Timeout => {
547 errors.push(diagnostic.message.clone())
548 }
549 DiagnosticSeverity::Warning => warnings.push(diagnostic.message.clone()),
550 }
551 }
552
553 (errors, warnings)
554}
555
556fn concise_scan_error_reason(err: &str) -> String {
557 let first_line = err
558 .lines()
559 .find(|line| !line.trim().is_empty())
560 .map(str::trim)
561 .unwrap_or("Scan failed");
562
563 if let Some((prefix, _)) = first_line.split_once(" at ")
564 && is_structured_error_prefix(prefix)
565 {
566 return prefix.to_string();
567 }
568
569 if let Some((prefix, _)) = first_line.split_once(": ")
570 && is_structured_error_prefix(prefix)
571 {
572 return prefix.to_string();
573 }
574
575 first_line.to_string()
576}
577
578fn is_structured_error_prefix(prefix: &str) -> bool {
579 let lowercase = prefix.to_ascii_lowercase();
580 lowercase.starts_with("failed to ")
581 || lowercase.ends_with(" failed")
582 || lowercase.starts_with("timeout ")
583 || lowercase.starts_with("processing interrupted")
584}
585
586fn pluralize_files(count: usize) -> &'static str {
587 if count == 1 { "file" } else { "files" }
588}
589
590fn pdf_oxide_default_log_filter_from(rust_log: Option<&str>) -> Option<LevelFilter> {
591 should_filter_pdf_oxide_default_warnings_from(rust_log).then_some(LevelFilter::Off)
592}
593
594fn should_filter_pdf_oxide_default_warnings_from(rust_log: Option<&str>) -> bool {
595 rust_log.is_none_or(|value| !value.contains("pdf_oxide"))
596}
597
598fn accumulate_timing(timings: &mut Vec<(String, f64)>, name: String, duration: f64) {
599 if let Some((_, existing)) = timings
600 .iter_mut()
601 .find(|(existing_name, _)| *existing_name == name)
602 {
603 *existing += duration;
604 } else {
605 timings.push((name, duration));
606 }
607}
608
609fn supports_color(stderr_is_tty: bool) -> bool {
610 if !stderr_is_tty {
611 return false;
612 }
613 if env::var_os("NO_COLOR").is_some() {
614 return false;
615 }
616 !matches!(env::var("TERM"), Ok(term) if term == "dumb")
617}
618
619fn build_summary_messages(stats: &ScanStats, scan_start: &str, scan_end: &str) -> Vec<String> {
620 let total = stats
621 .top_level_timings
622 .iter()
623 .map(|(_, value)| *value)
624 .sum::<f64>()
625 .max(0.0);
626 let scan_time = stats
627 .top_level_timings
628 .iter()
629 .find_map(|(name, value)| (name == "scan").then_some(*value))
630 .unwrap_or(0.0);
631
632 let speed_files = if scan_time > 0.0 {
633 stats.final_files as f64 / scan_time
634 } else {
635 0.0
636 };
637 let speed_bytes = if scan_time > 0.0 {
638 stats.total_bytes_scanned as f64 / scan_time
639 } else {
640 0.0
641 };
642
643 let scan_names = if stats.scan_names.is_empty() {
644 "scan".to_string()
645 } else {
646 stats.scan_names.clone()
647 };
648
649 let mut lines = vec![
650 format!(
651 "Summary: {scan_names} with {} process(es)",
652 stats.processes.to_i32()
653 ),
654 format!("Errors count: {}", stats.error_count),
655 format!("Warnings count: {}", stats.warning_count),
656 format!(
657 "Scan Speed: {speed_files:.2} files/sec. {}/sec.",
658 format_size(speed_bytes)
659 ),
660 format!(
661 "Initial counts: {} resource(s): {} file(s) and {} directorie(s) for {}",
662 stats.initial_files + stats.initial_dirs,
663 stats.initial_files,
664 stats.initial_dirs,
665 format_size(stats.initial_size as f64)
666 ),
667 format!(
668 "Final counts: {} resource(s): {} file(s) and {} directorie(s) for {}",
669 stats.final_files + stats.final_dirs,
670 stats.final_files,
671 stats.final_dirs,
672 format_size(stats.final_size as f64)
673 ),
674 format!("Excluded count: {}", stats.excluded_count),
675 format!(
676 "Packages: {} assembled from {} manifests",
677 stats.packages_assembled, stats.manifests_seen
678 ),
679 "Timings:".to_string(),
680 format!(" scan_start: {scan_start}"),
681 format!(" scan_end: {scan_end}"),
682 ];
683
684 for (name, value) in &stats.top_level_timings {
685 lines.push(format!(" {name}: {value:.2}s"));
686
687 let detail_timings = stats
688 .detail_timings
689 .iter()
690 .filter(|(detail_name, _)| detail_parent_phase(detail_name) == Some(name.as_str()));
691
692 if name == "scan" {
693 let scan_breakdown: Vec<_> = detail_timings.collect();
694 if !scan_breakdown.is_empty() {
695 lines.push(" scan breakdown (cumulative worker time):".to_string());
696 lines.extend(
697 scan_breakdown
698 .into_iter()
699 .map(|(detail_name, detail_value)| {
700 format!(" {detail_name}: {detail_value:.2}s")
701 }),
702 );
703 }
704 } else {
705 lines.extend(detail_timings.map(|(detail_name, detail_value)| {
706 format!(" {detail_name}: {detail_value:.2}s")
707 }));
708 }
709 }
710 lines.push(format!(" total: {total:.2}s"));
711
712 lines
713}
714
715fn detail_parent_phase(detail_name: &str) -> Option<&'static str> {
716 if detail_name.starts_with("setup:") || detail_name.starts_with("setup_scan:") {
717 Some("setup")
718 } else if detail_name.starts_with("scan:") {
719 Some("scan")
720 } else if detail_name.starts_with("post-scan:") || detail_name.starts_with("output-filter:") {
721 Some("post-scan")
722 } else if detail_name.starts_with("assembly:") {
723 Some("assembly")
724 } else if detail_name.starts_with("finalize:") {
725 Some("finalize")
726 } else if detail_name.starts_with("output:") {
727 Some("output")
728 } else {
729 None
730 }
731}
732
733pub fn format_size(bytes: f64) -> String {
734 if bytes < 1.0 {
735 return "0 Bytes".to_string();
736 }
737 if bytes == 1.0 {
738 return "1 Byte".to_string();
739 }
740
741 let mut size = bytes;
742 let units = ["Bytes", "KB", "MB", "GB", "TB"];
743 let mut idx = 0;
744 while size >= 1024.0 && idx < units.len() - 1 {
745 size /= 1024.0;
746 idx += 1;
747 }
748
749 if idx == 0 {
750 format!("{:.0} {}", size, units[idx])
751 } else {
752 format!("{size:.2} {}", units[idx])
753 }
754}
755
756#[cfg(test)]
757mod tests {
758 use super::{
759 ProgressMode, ScanProgress, ScanStats, apply_default_log_filters_from,
760 build_summary_messages, concise_scan_error_reason, format_default_scan_error, format_size,
761 pdf_oxide_default_log_filter_from, pluralize_files,
762 should_filter_pdf_oxide_default_warnings_from,
763 };
764 use crate::cli::ProcessMode;
765 use crate::models::ScanDiagnostic;
766
767 use std::path::Path;
768
769 use log::{Level, LevelFilter, Log, MetadataBuilder};
770
771 #[test]
772 fn format_size_matches_expected_shape() {
773 assert_eq!(format_size(0.0), "0 Bytes");
774 assert_eq!(format_size(1.0), "1 Byte");
775 assert_eq!(format_size(1024.0), "1.00 KB");
776 assert_eq!(format_size(2_567_000.0), "2.45 MB");
777 }
778
779 #[test]
780 fn summary_messages_render_detail_timings_hierarchically() {
781 let stats = ScanStats {
782 processes: ProcessMode::Parallel(4),
783 scan_names: "licenses, packages".to_string(),
784 initial_files: 10,
785 initial_dirs: 2,
786 initial_size: 2_048,
787 excluded_count: 1,
788 final_files: 8,
789 final_dirs: 1,
790 final_size: 1_024,
791 error_count: 0,
792 warning_count: 0,
793 total_bytes_scanned: 800,
794 packages_assembled: 3,
795 manifests_seen: 5,
796 incremental_reused: 0,
797 top_level_timings: vec![
798 ("setup".to_string(), 1.0),
799 ("inventory".to_string(), 2.0),
800 ("scan".to_string(), 3.0),
801 ("post-scan".to_string(), 4.0),
802 ("assembly".to_string(), 5.0),
803 ("finalize".to_string(), 6.0),
804 ("output".to_string(), 7.0),
805 ],
806 detail_timings: vec![
807 ("setup_scan:licenses".to_string(), 0.5),
808 ("scan:packages".to_string(), 1.25),
809 ("output-filter:only-findings".to_string(), 1.5),
810 ("finalize:output-prepare".to_string(), 2.0),
811 ],
812 };
813
814 let lines = build_summary_messages(&stats, "start", "end");
815 let line_index = |needle: &str| {
816 lines
817 .iter()
818 .position(|line| line == needle)
819 .unwrap_or_else(|| panic!("missing line: {needle}"))
820 };
821
822 assert!(lines.contains(&" total: 28.00s".to_string()));
823 assert!(lines.contains(&" setup_scan:licenses: 0.50s".to_string()));
824 assert!(lines.contains(&" scan breakdown (cumulative worker time):".to_string()));
825 assert!(lines.contains(&" scan:packages: 1.25s".to_string()));
826 assert!(lines.contains(&" output-filter:only-findings: 1.50s".to_string()));
827 assert!(lines.contains(&" finalize:output-prepare: 2.00s".to_string()));
828 assert!(line_index(" setup: 1.00s") < line_index(" setup_scan:licenses: 0.50s"));
829 assert!(
830 line_index(" scan: 3.00s") < line_index(" scan breakdown (cumulative worker time):")
831 );
832 assert!(
833 line_index(" scan breakdown (cumulative worker time):")
834 < line_index(" scan:packages: 1.25s")
835 );
836 assert!(
837 line_index(" post-scan: 4.00s") < line_index(" output-filter:only-findings: 1.50s")
838 );
839 assert!(line_index(" finalize: 6.00s") < line_index(" finalize:output-prepare: 2.00s"));
840 }
841
842 #[test]
843 fn summary_messages_use_scan_time_for_scan_speed() {
844 let stats = ScanStats {
845 final_files: 20,
846 total_bytes_scanned: 2_048,
847 top_level_timings: vec![("scan".to_string(), 4.0)],
848 ..ScanStats::default()
849 };
850
851 let lines = build_summary_messages(&stats, "start", "end");
852
853 assert!(lines.contains(&"Scan Speed: 5.00 files/sec. 512 Bytes/sec.".to_string()));
854 }
855
856 #[test]
857 fn default_pdf_oxide_warnings_are_suppressed() {
858 assert_eq!(
859 pdf_oxide_default_log_filter_from(None),
860 Some(LevelFilter::Off)
861 );
862 assert!(should_filter_pdf_oxide_default_warnings_from(None));
863 }
864
865 #[test]
866 fn explicit_pdf_oxide_rust_log_override_disables_default_filter() {
867 assert!(!should_filter_pdf_oxide_default_warnings_from(Some(
868 "pdf_oxide::fonts::font_dict=warn"
869 )));
870 }
871
872 #[test]
873 fn default_pdf_oxide_filter_covers_unlisted_submodules() {
874 let mut builder = env_logger::Builder::new();
875 builder.filter_level(LevelFilter::Warn);
876 apply_default_log_filters_from(&mut builder, None);
877 let logger = builder.build();
878 let warn_metadata = MetadataBuilder::new()
879 .target("pdf_oxide::content::parser")
880 .level(Level::Warn)
881 .build();
882 let error_metadata = MetadataBuilder::new()
883 .target("pdf_oxide::content::parser")
884 .level(Level::Error)
885 .build();
886
887 assert!(!logger.enabled(&warn_metadata));
888 assert!(!logger.enabled(&error_metadata));
889 }
890
891 #[test]
892 fn concise_scan_error_reason_keeps_high_level_failure_context() {
893 assert_eq!(
894 concise_scan_error_reason(
895 "Failed to read or parse package.json at \"fixtures/package.json\": key must be a string at line 1 column 3"
896 ),
897 "Failed to read or parse package.json"
898 );
899 assert_eq!(
900 concise_scan_error_reason("License detection failed: missing query token"),
901 "License detection failed"
902 );
903 assert_eq!(
904 concise_scan_error_reason("Processing interrupted due to timeout after 2.00 seconds"),
905 "Processing interrupted due to timeout after 2.00 seconds"
906 );
907 }
908
909 #[test]
910 fn default_scan_error_format_includes_reason_and_path() {
911 let formatted = format_default_scan_error(
912 Path::new("fixtures/package.json"),
913 "Failed to read or parse package.json at \"fixtures/package.json\": key must be a string at line 1 column 3",
914 );
915
916 assert_eq!(
917 formatted,
918 "Failed to read or parse package.json: fixtures/package.json"
919 );
920 }
921
922 #[test]
923 fn pluralize_files_uses_expected_labels() {
924 assert_eq!(pluralize_files(1), "file");
925 assert_eq!(pluralize_files(2), "files");
926 }
927
928 #[test]
929 fn file_completed_counts_warning_diagnostics_without_prefix_heuristics() {
930 let progress = ScanProgress::new(ProgressMode::Quiet);
931
932 progress.file_completed(
933 Path::new("project/custom.txt"),
934 42,
935 &[ScanDiagnostic::warning("custom recoverable warning")],
936 );
937
938 let stats = progress.stats.lock().expect("stats lock poisoned");
939 assert_eq!(stats.warning_count, 1);
940 assert_eq!(stats.error_count, 0);
941 }
942
943 #[test]
944 fn final_header_counts_raise_summary_warning_count() {
945 let progress = ScanProgress::new(ProgressMode::Quiet);
946
947 progress.record_final_header_counts(&[crate::models::Header {
948 tool_name: "provenant".to_string(),
949 tool_version: "0.0.0-test".to_string(),
950 options: serde_json::Map::new(),
951 notice: "test".to_string(),
952 start_timestamp: "start".to_string(),
953 end_timestamp: "end".to_string(),
954 output_format_version: "4.1.0".to_string(),
955 duration: 0.0,
956 errors: vec![],
957 warnings: vec!["custom replay warning".to_string()],
958 extra_data: crate::models::ExtraData {
959 system_environment: crate::models::SystemEnvironment {
960 operating_system: "linux".to_string(),
961 cpu_architecture: "x86_64".to_string(),
962 platform: "linux".to_string(),
963 platform_version: "test".to_string(),
964 rust_version: "1.0.0".to_string(),
965 },
966 spdx_license_list_version: "test".to_string(),
967 files_count: 0,
968 directories_count: 0,
969 excluded_count: 0,
970 license_index_provenance: None,
971 },
972 }]);
973
974 let stats = progress.stats.lock().expect("stats lock poisoned");
975 assert_eq!(stats.warning_count, 1);
976 assert_eq!(stats.error_count, 0);
977 }
978}