weavatrix-scan 0.5.3

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

use crate::config::ScanOptions;
use crate::ignore::{IgnoreRules, RepositoryMatch, RepositoryMatcher};
use crate::path::normalized_relative_path;
use crate::scan_match::skip_kind_for_match;
use crate::walk_types::WalkEntry;

pub(super) enum PathAction {
    Continue,
    SkipDir,
    File(String),
}

pub(super) fn decide_path(
    entry: &WalkEntry,
    options: &ScanOptions,
    matcher: &RepositoryMatcher,
    prepared_rules: Option<&IgnoreRules>,
) -> PathAction {
    if entry.depth() == 0 {
        return PathAction::Continue;
    }
    if entry.skip_reason().is_some() {
        return if entry.is_dir() {
            PathAction::SkipDir
        } else {
            PathAction::Continue
        };
    }
    if entry.is_symlink() && !options.walk.follow_links {
        return PathAction::Continue;
    }
    if entry.depth() < options.effective_min_depth() && !entry.is_dir() {
        return PathAction::Continue;
    }
    let relative = normalized_relative_path(entry.relative_path());
    if entry.is_dir() {
        return decide_directory(entry, &relative, options, matcher, prepared_rules);
    }
    if entry.is_file() {
        decide_file(entry, relative, options, matcher, prepared_rules)
    } else {
        PathAction::Continue
    }
}

fn decide_directory(
    entry: &WalkEntry,
    relative: &str,
    options: &ScanOptions,
    matcher: &RepositoryMatcher,
    prepared_rules: Option<&IgnoreRules>,
) -> PathAction {
    let decision = match_entry(entry, relative, true, matcher, prepared_rules);
    if skip_kind_for_match(decision).is_some() {
        return PathAction::SkipDir;
    }
    if decision != RepositoryMatch::OverrideInclude
        && options.should_skip_directory(entry.file_name())
    {
        return PathAction::SkipDir;
    }
    PathAction::Continue
}

fn decide_file(
    entry: &WalkEntry,
    relative: String,
    options: &ScanOptions,
    matcher: &RepositoryMatcher,
    prepared_rules: Option<&IgnoreRules>,
) -> PathAction {
    let decision = match_entry(entry, &relative, false, matcher, prepared_rules);
    if skip_kind_for_match(decision).is_some() {
        return PathAction::Continue;
    }
    if decision != RepositoryMatch::OverrideInclude
        && !options.accepts_extension(entry.path(), &relative)
    {
        return PathAction::Continue;
    }
    PathAction::File(relative)
}

fn match_entry(
    entry: &WalkEntry,
    relative: &str,
    is_directory: bool,
    matcher: &RepositoryMatcher,
    prepared_rules: Option<&IgnoreRules>,
) -> RepositoryMatch {
    let parent = entry.path().parent().unwrap_or(entry.path());
    prepared_rules.map_or_else(
        || {
            matcher.matched_prepared(
                relative,
                parent,
                entry.path(),
                is_directory,
                entry.hidden(),
                true,
            )
        },
        |rules| {
            matcher.matched_with_rules(
                relative,
                entry.path(),
                is_directory,
                entry.hidden(),
                rules,
                true,
            )
        },
    )
}