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