rebecca-core 0.3.0

Core planning, safety, scanning, and history models for Rebecca.
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

use std::path::Path;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum PathRelation {
    Same,
    Ancestor,
    Descendant,
    Unrelated,
}

pub(crate) fn paths_overlap(left: &Path, right: &Path) -> bool {
    !matches!(path_relation(left, right), PathRelation::Unrelated)
}

pub(crate) fn path_is_same_or_child(parent: &Path, child: &Path) -> bool {
    matches!(
        path_relation(child, parent),
        PathRelation::Same | PathRelation::Descendant
    )
}

pub(crate) fn path_relation(left: &Path, right: &Path) -> PathRelation {
    let left = comparable_components(left);
    let right = comparable_components(right);

    if left.is_empty() || right.is_empty() {
        return PathRelation::Unrelated;
    }

    if left == right {
        return PathRelation::Same;
    }

    if right.len() > left.len() && right.starts_with(&left) {
        return PathRelation::Ancestor;
    }

    if left.len() > right.len() && left.starts_with(&right) {
        return PathRelation::Descendant;
    }

    PathRelation::Unrelated
}

fn comparable_components(path: &Path) -> Vec<String> {
    let raw = path.as_os_str().to_string_lossy();
    let windows_like = cfg!(windows) || raw.contains('\\') || has_drive_prefix(&raw);
    let normalized = raw.replace('\\', "/");
    let mut cursor = normalized.as_str();
    let mut components = Vec::new();

    if has_drive_prefix(cursor) {
        components.push(cursor[..2].to_string());
        cursor = &cursor[2..];
    }

    if cursor.starts_with('/') {
        components.push("/".to_string());
        cursor = cursor.trim_start_matches('/');
    }

    components.extend(cursor.split('/').filter_map(|component| match component {
        "" | "." => None,
        value => Some(value.to_string()),
    }));

    if windows_like {
        components
            .into_iter()
            .map(|component| component.to_ascii_lowercase())
            .collect()
    } else {
        components
    }
}

fn has_drive_prefix(value: &str) -> bool {
    let bytes = value.as_bytes();
    bytes.len() >= 2 && bytes[1] == b':' && bytes[0].is_ascii_alphabetic()
}

#[cfg(test)]
mod tests {
    use std::path::Path;

    use super::{PathRelation, path_relation, paths_overlap};

    #[test]
    fn detects_same_child_and_parent_paths() {
        let temp = tempfile::tempdir().unwrap();
        let root = temp.path().join("Rebecca");
        let child = root.join("cache").join("scan");

        assert!(paths_overlap(&root, &root));
        assert!(paths_overlap(&root, &child));
        assert!(paths_overlap(&child, &root));
        assert!(!paths_overlap(&root, &temp.path().join("Other")));
    }

    #[test]
    fn reports_directional_path_relation() {
        let temp = tempfile::tempdir().unwrap();
        let root = temp.path().join("root");
        let child = root.join("cache");

        assert_eq!(path_relation(&root, &root), PathRelation::Same);
        assert_eq!(path_relation(&root, &child), PathRelation::Ancestor);
        assert_eq!(path_relation(&child, &root), PathRelation::Descendant);
        assert_eq!(
            path_relation(&root, &temp.path().join("other")),
            PathRelation::Unrelated
        );
    }

    #[test]
    fn compares_windows_like_paths_case_insensitively() {
        assert!(paths_overlap(
            Path::new(r"C:\Users\Alice\AppData\Local\Rebecca"),
            Path::new(r"c:\users\alice\appdata\local\rebecca\cache"),
        ));
    }
}