weavatrix-scan 0.4.6

Deterministic, safe repository scanner for code intelligence
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::report::{
    CompactScanReport, ScanCacheStats, ScanReport, ScanTermination, SkipKind, SkippedEntry,
};
use std::collections::BTreeMap;
use std::fmt;

/// Path-free aggregate scan output for logs, telemetry, and higher-level tools.
///
/// `recorded_skips` and `skipped_by_kind` describe retained evidence. They are
/// zero when the scan used [`crate::EvidenceMode::SelectedFiles`], even when
/// entries were excluded during selection.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ScanSummary {
    pub selected_files: usize,
    pub selected_bytes: u64,
    pub hashed_files: usize,
    pub binary_checked_files: usize,
    pub recorded_skips: usize,
    pub skipped_by_kind: BTreeMap<SkipKind, usize>,
    pub warnings: usize,
    pub ignore_sources: usize,
    pub complete: bool,
    pub termination: Option<ScanTermination>,
    pub portable: bool,
    pub cache: ScanCacheStats,
}

impl ScanSummary {
    #[allow(clippy::too_many_arguments)]
    fn from_parts(
        selected_files: usize,
        selected_bytes: impl Iterator<Item = u64>,
        hashed_files: usize,
        binary_checked_files: usize,
        skipped: &[SkippedEntry],
        warnings: usize,
        ignore_sources: usize,
        complete: bool,
        termination: Option<ScanTermination>,
        portable: bool,
        cache: ScanCacheStats,
    ) -> Self {
        let mut skipped_by_kind = BTreeMap::new();
        for entry in skipped {
            *skipped_by_kind.entry(entry.kind).or_default() += 1;
        }
        Self {
            selected_files,
            selected_bytes: selected_bytes.fold(0_u64, u64::saturating_add),
            hashed_files,
            binary_checked_files,
            recorded_skips: skipped.len(),
            skipped_by_kind,
            warnings,
            ignore_sources,
            complete,
            termination,
            portable,
            cache,
        }
    }
}

impl ScanReport {
    /// Aggregates this report without exposing repository paths.
    #[must_use]
    pub fn summary(&self) -> ScanSummary {
        ScanSummary::from_parts(
            self.files.len(),
            self.files.iter().map(|file| file.bytes),
            self.files
                .iter()
                .filter(|file| file.content_hash.is_some())
                .count(),
            self.files.iter().filter(|file| file.binary_checked).count(),
            &self.skipped,
            self.warnings.len(),
            self.ignore_sources.len(),
            self.complete,
            self.termination,
            self.portable,
            self.cache,
        )
    }
}

impl CompactScanReport {
    /// Aggregates this compact report without exposing repository paths.
    #[must_use]
    pub fn summary(&self) -> ScanSummary {
        ScanSummary::from_parts(
            self.files.len(),
            self.files.iter().map(|file| file.bytes),
            self.files
                .iter()
                .filter(|file| file.content_hash().is_some())
                .count(),
            self.files
                .iter()
                .filter(|file| {
                    file.content
                        .as_deref()
                        .is_some_and(|content| content.binary_checked)
                })
                .count(),
            &self.skipped,
            self.warnings.len(),
            self.ignore_sources.len(),
            self.complete,
            self.termination,
            self.portable,
            self.cache,
        )
    }
}

impl fmt::Display for ScanSummary {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            formatter,
            "files={} bytes={} hashed={} binary_checked={} skipped={} warnings={} \
             ignore_sources={} complete={} portable={}",
            self.selected_files,
            self.selected_bytes,
            self.hashed_files,
            self.binary_checked_files,
            self.recorded_skips,
            self.warnings,
            self.ignore_sources,
            self.complete,
            self.portable,
        )?;
        if let Some(termination) = self.termination {
            write!(formatter, " termination={termination:?}")?;
        }
        if self.cache != ScanCacheStats::default() {
            write!(
                formatter,
                " cache_reused_hashes={} cache_content_reads={} cache_fingerprint_reads={}",
                self.cache.reused_hashes, self.cache.content_reads, self.cache.fingerprint_reads,
            )?;
        }
        Ok(())
    }
}