weavatrix-scan 0.4.2

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
147
148
149
150

#[allow(dead_code)]
mod support;

use std::collections::BTreeSet;
use support::Fixture;
use weavatrix_scan::{
    RepositoryMatch, ScanOptions, Scanner, SelectionDisposition, SelectionMatcher, SkipKind, Walker,
};

#[test]
fn complete_selection_matcher_matches_scanner_manifest() {
    let fixture = Fixture::new("weavatrix-selection-parity");
    fixture.write(".gitignore", "ignored.rs\n");
    fixture.write("ignored.rs", "ignored");
    fixture.write(".hidden.rs", "hidden");
    fixture.write("src/lib.rs", "lib");
    fixture.write("src/readme.txt", "text");
    fixture.write("src/large.rs", "123456789");
    fixture.write("target/generated.rs", "generated");
    fixture.write("target/forced.txt", "forced");
    fixture.write(".private/secret.rs", "secret");
    fixture.write("nested/deep/more/file.rs", "deep");

    let mut options = ScanOptions::default()
        .with_extensions(["rs"])
        .with_override_rules(["target/", "target/forced.txt"])
        .with_skip_hidden(true)
        .with_max_depth(Some(3))
        .metadata_only();
    options.max_file_bytes = 8;

    let report = Scanner::new(&fixture.root)
        .options(options.clone())
        .scan()
        .unwrap();
    let expected = report
        .files
        .iter()
        .map(|file| file.relative.clone())
        .collect::<BTreeSet<_>>();

    let mut matcher = SelectionMatcher::with_options(&fixture.root, &options).unwrap();
    let mut walker = Walker::with_options(&fixture.root, options.walk.with_metadata(true)).unwrap();
    let mut actual = BTreeSet::new();
    while let Some(entry) = walker.next() {
        let entry = entry.unwrap();
        let decision = matcher.matched_entry(&entry).unwrap();
        if decision.is_selected() {
            actual.insert(
                entry
                    .relative_path()
                    .to_string_lossy()
                    .replace(std::path::MAIN_SEPARATOR, "/"),
            );
        }
        if matches!(decision.disposition(), SelectionDisposition::Skipped(_)) && entry.is_dir() {
            walker.skip_current_dir();
        }
    }
    assert_eq!(actual, expected);

    assert_eq!(
        matcher.matched("ignored.rs").unwrap().skip_kind(),
        Some(SkipKind::Override)
    );
    let forced = matcher.matched("target/forced.txt").unwrap();
    assert!(forced.is_selected());
    assert_eq!(forced.repository_match(), RepositoryMatch::OverrideInclude);
    assert!(
        matcher
            .clone()
            .matched("target/forced.txt")
            .unwrap()
            .is_selected()
    );
    assert_eq!(
        matcher
            .matched("nested/deep/more/file.rs")
            .unwrap()
            .skip_kind(),
        Some(SkipKind::MaxDepth)
    );
}

#[test]
fn standalone_matching_applies_ancestor_and_file_policies() {
    let fixture = Fixture::new("weavatrix-selection-standalone");
    fixture.write(".gitignore", "ignored.rs\n");
    fixture.write("ignored.rs", "ignored");
    fixture.write(".hidden.rs", "hidden");
    fixture.write("src/readme.txt", "text");
    fixture.write("src/large.rs", "123456789");
    fixture.write("target/generated.rs", "generated");
    fixture.write(".private/secret.rs", "secret");
    let mut path_options = ScanOptions::default()
        .with_extensions(["rs"])
        .with_skip_hidden(true)
        .with_max_depth(Some(3))
        .metadata_only();
    path_options.max_file_bytes = 8;
    let mut ignore_only = SelectionMatcher::with_options(&fixture.root, &path_options).unwrap();
    assert_eq!(
        ignore_only.matched("ignored.rs").unwrap().skip_kind(),
        Some(SkipKind::Ignored)
    );
    assert_eq!(
        ignore_only.matched(".hidden.rs").unwrap().skip_kind(),
        Some(SkipKind::Hidden)
    );
    assert_eq!(
        ignore_only.matched("src/readme.txt").unwrap().skip_kind(),
        Some(SkipKind::Extension)
    );
    assert_eq!(
        ignore_only.matched("src/large.rs").unwrap().skip_kind(),
        Some(SkipKind::Oversized)
    );
    assert_eq!(
        ignore_only
            .matched("target/generated.rs")
            .unwrap()
            .skip_kind(),
        Some(SkipKind::StandardDirectory)
    );
    assert_eq!(
        ignore_only
            .matched(".private/secret.rs")
            .unwrap()
            .skip_kind(),
        Some(SkipKind::Hidden)
    );
}

#[test]
fn matcher_normalization_is_lossless_and_rejects_escape() {
    let fixture = Fixture::new("weavatrix-selection-normalize");
    fixture.write("src/lib.rs", "lib");
    let repository = weavatrix_scan::RepositoryMatcher::new(&fixture.root).unwrap();

    assert_eq!(
        repository.normalize("src/lib.rs").unwrap(),
        std::path::PathBuf::from("src/lib.rs")
    );
    assert!(repository.normalize("../outside.rs").is_err());
    assert!(
        repository
            .normalize(fixture.root.join("..").join("outside.rs"))
            .is_err()
    );
}