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
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

use std::path::PathBuf;

/// Controls every supported source of repository selection rules.
///
/// The default is repository-local and reproducible. Use [`Self::git_compatible`]
/// when matching the current machine's Git configuration is more important
/// than producing a portable manifest.
#[derive(Debug, Clone, PartialEq, Eq)]
#[allow(clippy::struct_excessive_bools)]
pub struct IgnorePolicy {
    pub parent_rules: bool,
    pub git_ignore: bool,
    pub dot_ignore: bool,
    pub custom_ignore: bool,
    pub git_exclude: bool,
    pub git_global: bool,
    /// Apply Git-specific sources only when a repository root is present.
    pub require_git: bool,
    pub explicit_files: Vec<PathBuf>,
}

impl Default for IgnorePolicy {
    fn default() -> Self {
        Self::repository()
    }
}

impl IgnorePolicy {
    #[must_use]
    pub const fn repository() -> Self {
        Self {
            parent_rules: false,
            git_ignore: true,
            dot_ignore: true,
            custom_ignore: true,
            git_exclude: false,
            git_global: false,
            require_git: false,
            explicit_files: Vec::new(),
        }
    }

    /// Disable every ignore source, including repository `.gitignore` files.
    ///
    /// Use this when a consumer must see generated directories that a
    /// repository-local ignore list would otherwise hide.
    #[must_use]
    pub const fn none() -> Self {
        Self {
            parent_rules: false,
            git_ignore: false,
            dot_ignore: false,
            custom_ignore: false,
            git_exclude: false,
            git_global: false,
            require_git: false,
            explicit_files: Vec::new(),
        }
    }

    #[must_use]
    pub const fn git_compatible() -> Self {
        Self {
            parent_rules: true,
            git_ignore: true,
            dot_ignore: true,
            custom_ignore: true,
            git_exclude: true,
            git_global: true,
            require_git: true,
            explicit_files: Vec::new(),
        }
    }

    #[must_use]
    pub const fn with_parent_rules(mut self, enabled: bool) -> Self {
        self.parent_rules = enabled;
        self
    }

    #[must_use]
    pub const fn with_git_ignore(mut self, enabled: bool) -> Self {
        self.git_ignore = enabled;
        self
    }

    #[must_use]
    pub const fn with_dot_ignore(mut self, enabled: bool) -> Self {
        self.dot_ignore = enabled;
        self
    }

    #[must_use]
    pub const fn with_custom_ignore(mut self, enabled: bool) -> Self {
        self.custom_ignore = enabled;
        self
    }

    #[must_use]
    pub const fn with_git_exclude(mut self, enabled: bool) -> Self {
        self.git_exclude = enabled;
        self
    }

    #[must_use]
    pub const fn with_git_global(mut self, enabled: bool) -> Self {
        self.git_global = enabled;
        self
    }

    #[must_use]
    pub const fn with_require_git(mut self, enabled: bool) -> Self {
        self.require_git = enabled;
        self
    }

    #[must_use]
    pub fn with_explicit_file(mut self, path: impl Into<PathBuf>) -> Self {
        self.explicit_files.push(path.into());
        self
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn none_disables_every_ignore_source() {
        let policy = IgnorePolicy::none();
        assert!(!policy.parent_rules);
        assert!(!policy.git_ignore);
        assert!(!policy.dot_ignore);
        assert!(!policy.custom_ignore);
        assert!(!policy.git_exclude);
        assert!(!policy.git_global);
        assert!(policy.explicit_files.is_empty());
    }
}