sley-core 0.10.0

Core Git primitives for the sley engine: object ids, errors, repo paths, and shared value types.
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

//! Repository/operation-owned Git ref namespace. Never reads process environment.

/// An expanded Git namespace. Construct once at the caller boundary and share
/// by reference across an operation's workers. Nested names retain Git's layout.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Namespace(String);

impl Namespace {
    pub fn new(raw: &str) -> Self {
        let mut prefix = String::new();
        for component in raw.split('/').filter(|part| !part.is_empty()) {
            prefix.push_str("refs/namespaces/");
            prefix.push_str(component);
            prefix.push('/');
        }
        Self(prefix)
    }

    pub fn prefix(&self) -> &str {
        &self.0
    }

    pub fn strip<'a>(&self, physical: &'a str) -> Option<&'a str> {
        physical.strip_prefix(self.prefix())
    }

    pub fn expand(&self, logical: &str) -> String {
        format!("{}{logical}", self.0)
    }

    pub fn is_active(&self) -> bool {
        !self.0.is_empty()
    }
}

/// Match `transfer.hideRefs` / `uploadpack.hideRefs` / `receive.hideRefs`
/// patterns against a ref, honoring git's full-vs-stripped subject rules:
/// - patterns without `^` match the logical (namespace-stripped) name
/// - patterns with a leading `^` match the full physical name
/// - leading `!` negates a match
///
/// Patterns are evaluated last-to-first; the first match wins.
pub fn ref_is_hidden(refname: Option<&str>, refname_full: &str, patterns: &[String]) -> bool {
    for pattern in patterns.iter().rev() {
        let mut match_pat = pattern.as_str();
        let mut negated = false;
        if let Some(rest) = match_pat.strip_prefix('!') {
            negated = true;
            match_pat = rest;
        }
        let subject = if let Some(rest) = match_pat.strip_prefix('^') {
            match_pat = rest;
            Some(refname_full)
        } else {
            refname
        };
        if let Some(subject) = subject
            && hidden_ref_pattern_matches(subject, match_pat)
        {
            return !negated;
        }
    }
    false
}

/// Trim trailing slashes from a hideRefs pattern value (git's
/// `parse_hide_refs_config`).
pub fn trim_hidden_ref_pattern(value: &str) -> String {
    value.trim_end_matches('/').to_string()
}

fn hidden_ref_pattern_matches(refname: &str, pattern: &str) -> bool {
    refname
        .strip_prefix(pattern)
        .is_some_and(|rest| rest.is_empty() || rest.starts_with('/'))
}

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

    #[test]
    fn empty_namespace_is_identity() {
        let ns = Namespace::default();
        assert_eq!(ns.prefix(), "");
        assert_eq!(ns.strip("refs/heads/main"), Some("refs/heads/main"));
        assert_eq!(ns.expand("refs/heads/main"), "refs/heads/main");
    }

    #[test]
    fn namespaces_expand_and_strip_independently() {
        let first = Namespace::new("namespace");
        let second = Namespace::new("a/b");
        assert_eq!(second.prefix(), "refs/namespaces/a/refs/namespaces/b/");
        assert_eq!(
            first.expand("refs/heads/main"),
            "refs/namespaces/namespace/refs/heads/main"
        );
        assert_eq!(
            first.strip("refs/namespaces/namespace/refs/heads/main"),
            Some("refs/heads/main")
        );
        assert_eq!(first.strip("refs/namespaces/other/refs/heads/main"), None);
    }

    #[test]
    fn hide_refs_caret_uses_full_name() {
        let ns = Namespace::new("namespace");
        let full = ns.expand("refs/tags/1");
        assert!(ref_is_hidden(
            ns.strip(&full),
            &full,
            &["^refs/namespaces/namespace/refs/tags".into()]
        ));
        assert!(!ref_is_hidden(
            ns.strip(&full),
            &full,
            &["refs/namespaces/namespace/refs/tags".into()]
        ));
        assert!(ref_is_hidden(ns.strip(&full), &full, &["refs/tags".into()]));
    }
}