hoard 0.6.1

Hoard backups of files across your filesystem into one location.
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

/// Provides a [`Filter`] based on glob ignore patterns.
///
/// To use this filter, add an list of glob patterns to `ignore` under `config`. For example:
///
/// ```ignore
/// [config]
///     ignore = ["some*glob"]
/// ```
///
/// This can be put under global, hoard, or pile scope.
use glob::Pattern;

use crate::hoard::PileConfig;
use crate::paths::{RelativePath, SystemPath};

use super::Filter;

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub(crate) struct IgnoreFilter {
    globs: Vec<Pattern>,
}

impl Filter for IgnoreFilter {
    fn new(pile_config: &PileConfig) -> Self {
        IgnoreFilter {
            globs: pile_config.ignore.clone(),
        }
    }

    #[tracing::instrument(name = "run_ignore_filter", skip(self, _prefix))]
    fn keep(&self, _prefix: &SystemPath, rel_path: &RelativePath) -> bool {
        self.globs.iter().all(|glob| {
            let matches = glob.matches_path(&rel_path.to_path_buf());
            tracing::trace!(
                "{:?} {} glob {:?}",
                rel_path,
                if matches { "matches" } else { "does not match" },
                glob
            );
            !matches
        })
    }
}

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

    #[test]
    fn test_filter_derives() {
        let filter = {
            let config = PileConfig {
                ignore: vec![Pattern::new("testing/**").unwrap()],
                ..PileConfig::default()
            };
            IgnoreFilter::new(&config)
        };
        let other = {
            let config = PileConfig {
                ignore: vec![Pattern::new("test/**").unwrap()],
                ..PileConfig::default()
            };
            IgnoreFilter::new(&config)
        };
        assert!(format!("{filter:?}").contains("IgnoreFilter"));
        assert_eq!(filter, filter.clone());
        assert_ne!(filter, other);
    }
}