attributes.rs 95.9%

118 of 123 lines run, 22 of 42 functions · run #394 on proposal/151 · run missed

//! `.oxyattributes` (spec §19): per-path attributes in gitattributes syntax.
//! Each line is `pattern attr...` where an attribute is `binary`, `text`
//! (or `-binary`), `eol=lf`, `eol=crlf`, `nocompress`, `lockable`, or
//! `merge=union`. A
//! pattern without a slash matches a basename anywhere below the file's
//! directory; one with a slash is anchored to that directory. Later rules
//! override earlier ones per attribute.

use globset::{Glob, GlobMatcher};
use std::collections::BTreeMap;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Eol {
    Lf,
    Crlf,
}

/// The attributes in force for one path.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Attrs {
    /// `Some(true)` forces opaque, `Some(false)` forces text (absent NUL bytes).
    pub binary: Option<bool>,
    pub eol: Option<Eol>,
    pub nocompress: bool,
    pub lockable: bool,
    /// `merge=union` (oxygen#145): two changes adding lines at the same
    /// place keep both, without asking (`oxy resolve --both`, spec §9.5).
    pub union: bool,
}

struct Rule {
    matcher: GlobMatcher,
    attrs: Vec<(String, Option<String>)>,
}

#[derive(Default)]
pub struct Attributes {
    rules: Vec<Rule>,
}

impl Attributes {
    /// Add the rules of one `.oxyattributes` file living in `dir` (`""` for the root).
    pub fn add_file(&mut self, dir: &str, text: &str) {
        for line in text.lines() {
            let line = line.trim();
            if line.is_empty() || line.starts_with('#') {
                continue;
            }
            let mut parts = line.split_whitespace();
            let Some(pattern) = parts.next() else {
                continue;
            };
            let attrs: Vec<(String, Option<String>)> = parts
                .map(|a| match a.split_once('=') {
                    Some((k, v)) => (k.to_string(), Some(v.to_string())),
                    None => (a.to_string(), None),
                })
                .collect();
            let anchored = pattern.contains('/');
            let core = pattern.trim_start_matches('/');
            let full = match (dir.is_empty(), anchored) {
                (true, true) => core.to_string(),
                (true, false) => format!("**/{core}"),
                (false, true) => format!("{dir}/{core}"),
                (false, false) => format!("{dir}/**/{core}"),
            };
            if let Ok(g) = Glob::new(&full) {
                self.rules.push(Rule {
                    matcher: g.compile_matcher(),
                    attrs,
                });
            }
        }
    }

    /// Build from every `.oxyattributes` in `files` (path → content).
    pub fn from_files<'a>(files: impl IntoIterator<Item = (&'a str, &'a [u8])>) -> Attributes {
        let mut sorted: BTreeMap<&str, &[u8]> = BTreeMap::new();
        for (p, c) in files {
            if p == ".oxyattributes" || p.ends_with("/.oxyattributes") {
                sorted.insert(p, c);
            }
        }
        let mut out = Attributes::default();
        // Shallower files first so deeper ones override.
        let mut entries: Vec<(&str, &[u8])> = sorted.into_iter().collect();
        entries.sort_by_key(|(p, _)| p.matches('/').count());
        for (p, c) in entries {
            let dir = p
                .strip_suffix(".oxyattributes")
                .unwrap_or("")
                .trim_end_matches('/');
            out.add_file(dir, &String::from_utf8_lossy(c));
        }
        out
    }

    pub fn lookup(&self, path: &str) -> Attrs {
        let mut a = Attrs::default();
        for r in &self.rules {
            if !r.matcher.is_match(path) {
                continue;
            }
            for (k, v) in &r.attrs {
                match (k.as_str(), v.as_deref()) {
                    ("binary", None) => a.binary = Some(true),
                    ("-binary", None) | ("text", None) => a.binary = Some(false),
                    ("eol", Some("lf")) => a.eol = Some(Eol::Lf),
                    ("eol", Some("crlf")) => a.eol = Some(Eol::Crlf),
                    ("-eol", None) => a.eol = None,
                    ("nocompress", None) => a.nocompress = true,
                    ("-nocompress", None) => a.nocompress = false,
                    ("lockable", None) => a.lockable = true,
                    ("-lockable", None) => a.lockable = false,
                    ("merge", Some("union")) => a.union = true,
                    ("merge", Some(_)) | ("-merge", None) => a.union = false,
                    _ => {}
                }
            }
        }
        a
    }

    pub fn is_empty(&self) -> bool {
        self.rules.is_empty()
    }
}

/// `\r\n` → `\n`, as stored for `eol=` files.
pub fn normalize_eol(bytes: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(bytes.len());
    let mut i = 0;
    while i < bytes.len() {
        if bytes[i] == b'\r' && bytes.get(i + 1) == Some(&b'\n') {
            i += 1;
            continue;
        }
        out.push(bytes[i]);
        i += 1;
    }
    out
}

/// `\n` → `\r\n` (lines already ending in `\r\n` are left alone).
pub fn to_crlf(bytes: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(bytes.len() + bytes.len() / 16);
    let mut prev = 0u8;
    for &b in bytes {
        if b == b'\n' && prev != b'\r' {
            out.push(b'\r');
        }
        out.push(b);
        prev = b;
    }
    out
}

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

    #[test]
    fn parsing_and_precedence() {
        let a = Attributes::from_files([
            (".oxyattributes", &b"*.png binary nocompress\n*.txt eol=lf\ndocs/*.txt eol=crlf\nmodels/** lockable\n"[..]),
            ("src/.oxyattributes", &b"*.dat binary\ngen.txt -eol\n"[..]),
            ("README.md", &b"not attributes"[..]),
        ]);
        assert_eq!(
            a.lookup("a/b/logo.png"),
            Attrs {
                binary: Some(true),
                eol: None,
                nocompress: true,
                lockable: false,
                union: false
            }
        );
        assert_eq!(a.lookup("notes.txt").eol, Some(Eol::Lf));
        assert_eq!(a.lookup("docs/notes.txt").eol, Some(Eol::Crlf));
        assert!(a.lookup("models/x/y.bin").lockable);
        let u = Attributes::from_files([(".oxyattributes", &b"CHANGELOG.md merge=union\n"[..])]);
        assert!(u.lookup("CHANGELOG.md").union);
        assert!(u.lookup("docs/CHANGELOG.md").union);
        assert!(!u.lookup("README.md").union);
        assert_eq!(a.lookup("src/deep/x.dat").binary, Some(true));
        assert_eq!(a.lookup("other/x.dat").binary, None);
        assert_eq!(a.lookup("src/gen.txt").eol, None, "deeper file overrides");
        assert_eq!(a.lookup("src/other.txt").eol, Some(Eol::Lf));
        assert_eq!(a.lookup("plain"), Attrs::default());
    }

    #[test]
    fn eol_conversions() {
        assert_eq!(normalize_eol(b"a\r\nb\nc\r\n"), b"a\nb\nc\n");
        assert_eq!(to_crlf(b"a\nb\r\nc\n"), b"a\r\nb\r\nc\r\n");
        assert_eq!(normalize_eol(&to_crlf(b"x\ny\n")), b"x\ny\n");
    }
}

1		//! `.oxyattributes` (spec §19): per-path attributes in gitattributes syntax.
2		//! Each line is `pattern attr...` where an attribute is `binary`, `text`
3		//! (or `-binary`), `eol=lf`, `eol=crlf`, `nocompress`, `lockable`, or
4		//! `merge=union`. A
5		//! pattern without a slash matches a basename anywhere below the file's
6		//! directory; one with a slash is anchored to that directory. Later rules
7		//! override earlier ones per attribute.
8
9		use globset::{Glob, GlobMatcher};
10		use std::collections::BTreeMap;
11
12		#[derive(Clone, Copy, Debug, PartialEq, Eq)]
13		pub enum Eol {
14		Lf,
15		Crlf,
16		}
17
18		/// The attributes in force for one path.
19		#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
20		pub struct Attrs {
21		/// `Some(true)` forces opaque, `Some(false)` forces text (absent NUL bytes).
22		pub binary: Option<bool>,
23		pub eol: Option<Eol>,
24		pub nocompress: bool,
25		pub lockable: bool,
26		/// `merge=union` (oxygen#145): two changes adding lines at the same
27		/// place keep both, without asking (`oxy resolve --both`, spec §9.5).
28		pub union: bool,
29		}
30
31		struct Rule {
32		matcher: GlobMatcher,
33		attrs: Vec<(String, Option<String>)>,
34		}
35
36		#[derive(Default)]
37		pub struct Attributes {
38		rules: Vec<Rule>,
39		}
40
41		impl Attributes {
42		/// Add the rules of one `.oxyattributes` file living in `dir` (`""` for the root).
43	66×	pub fn add_file(&mut self, dir: &str, text: &str) {
44	100×	for line in text.lines() {
45	100×	let line = line.trim();
46	100×	if line.is_empty() \|\| line.starts_with('#') {
47	0×	continue;
48	100×	}
49	100×	let mut parts = line.split_whitespace();
50	100×	let Some(pattern) = parts.next() else {
51	0×	continue;
52		};
53	100×	let attrs: Vec<(String, Option<String>)> = parts
54	116×	.map(\|a\| match a.split_once('=') {
55	52×	Some((k, v)) => (k.to_string(), Some(v.to_string())),
56	64×	None => (a.to_string(), None),
57	116×	})
58	100×	.collect();
59	100×	let anchored = pattern.contains('/');
60	100×	let core = pattern.trim_start_matches('/');
61	100×	let full = match (dir.is_empty(), anchored) {
62	17×	(true, true) => core.to_string(),
63	81×	(true, false) => format!("**/{core}"),
64	0×	(false, true) => format!("{dir}/{core}"),
65	2×	(false, false) => format!("{dir}/**/{core}"),
66		};
67	100×	if let Ok(g) = Glob::new(&full) {
68	100×	self.rules.push(Rule {
69	100×	matcher: g.compile_matcher(),
70	100×	attrs,
71	100×	});
72	100×	}
73		}
74	66×	}
75
76		/// Build from every `.oxyattributes` in `files` (path → content).
77	4254×	pub fn from_files<'a>(files: impl IntoIterator<Item = (&'a str, &'a [u8])>) -> Attributes {
78	4254×	let mut sorted: BTreeMap<&str, &[u8]> = BTreeMap::new();
79	4254×	for (p, c) in files {
80	67×	if p == ".oxyattributes" \|\| p.ends_with("/.oxyattributes") {
81	66×	sorted.insert(p, c);
82	66×	}
83		}
84	4254×	let mut out = Attributes::default();
85		// Shallower files first so deeper ones override.
86	4254×	let mut entries: Vec<(&str, &[u8])> = sorted.into_iter().collect();
87	4254×	entries.sort_by_key(\|(p, _)\| p.matches('/').count());
88	4254×	for (p, c) in entries {
89	66×	let dir = p
90	66×	.strip_suffix(".oxyattributes")
91	66×	.unwrap_or("")
92	66×	.trim_end_matches('/');
93	66×	out.add_file(dir, &String::from_utf8_lossy(c));
94	66×	}
95	4254×	out
96	4254×	}
97
98	86007×	pub fn lookup(&self, path: &str) -> Attrs {
99	86007×	let mut a = Attrs::default();
100	86007×	for r in &self.rules {
101	721×	if !r.matcher.is_match(path) {
102	505×	continue;
103	216×	}
104	244×	for (k, v) in &r.attrs {
105	244×	match (k.as_str(), v.as_deref()) {
106	244×	("binary", None) => a.binary = Some(true),
107	215×	("-binary", None) \| ("text", None) => a.binary = Some(false),
108	215×	("eol", Some("lf")) => a.eol = Some(Eol::Lf),
109	26×	("eol", Some("crlf")) => a.eol = Some(Eol::Crlf),
110	177×	("-eol", None) => a.eol = None,
111	176×	("nocompress", None) => a.nocompress = true,
112	148×	("-nocompress", None) => a.nocompress = false,
113	148×	("lockable", None) => a.lockable = true,
114	120×	("-lockable", None) => a.lockable = false,
115	120×	("merge", Some("union")) => a.union = true,
116	0×	("merge", Some(_)) \| ("-merge", None) => a.union = false,
117	0×	_ => {}
118		}
119		}
120		}
121	86007×	a
122	86007×	}
123
124	1×	pub fn is_empty(&self) -> bool {
125	1×	self.rules.is_empty()
126	1×	}
127		}
128
129		/// `\r\n` → `\n`, as stored for `eol=` files.
130	9×	pub fn normalize_eol(bytes: &[u8]) -> Vec<u8> {
131	9×	let mut out = Vec::with_capacity(bytes.len());
132	9×	let mut i = 0;
133	85×	while i < bytes.len() {
134	76×	if bytes[i] == b'\r' && bytes.get(i + 1) == Some(&b'\n') {
135	16×	i += 1;
136	16×	continue;
137	60×	}
138	60×	out.push(bytes[i]);
139	60×	i += 1;
140		}
141	9×	out
142	9×	}
143
144		/// `\n` → `\r\n` (lines already ending in `\r\n` are left alone).
145	4×	pub fn to_crlf(bytes: &[u8]) -> Vec<u8> {
146	4×	let mut out = Vec::with_capacity(bytes.len() + bytes.len() / 16);
147	4×	let mut prev = 0u8;
148	27×	for &b in bytes {
149	27×	if b == b'\n' && prev != b'\r' {
150	8×	out.push(b'\r');
151	19×	}
152	27×	out.push(b);
153	27×	prev = b;
154		}
155	4×	out
156	4×	}
157
158		#[cfg(test)]
159		mod tests {
160		use super::*;
161
162		#[test]
163	1×	fn parsing_and_precedence() {
164	1×	let a = Attributes::from_files([
165	1×	(".oxyattributes", &b".png binary nocompress\n.txt eol=lf\ndocs/.txt eol=crlf\nmodels/* lockable\n"[..]),
166	1×	("src/.oxyattributes", &b"*.dat binary\ngen.txt -eol\n"[..]),
167	1×	("README.md", &b"not attributes"[..]),
168	1×	]);
169	1×	assert_eq!(
170	1×	a.lookup("a/b/logo.png"),
171		Attrs {
172		binary: Some(true),
173		eol: None,
174		nocompress: true,
175		lockable: false,
176		union: false
177		}
178		);
179	1×	assert_eq!(a.lookup("notes.txt").eol, Some(Eol::Lf));
180	1×	assert_eq!(a.lookup("docs/notes.txt").eol, Some(Eol::Crlf));
181	1×	assert!(a.lookup("models/x/y.bin").lockable);
182	1×	let u = Attributes::from_files([(".oxyattributes", &b"CHANGELOG.md merge=union\n"[..])]);
183	1×	assert!(u.lookup("CHANGELOG.md").union);
184	1×	assert!(u.lookup("docs/CHANGELOG.md").union);
185	1×	assert!(!u.lookup("README.md").union);
186	1×	assert_eq!(a.lookup("src/deep/x.dat").binary, Some(true));
187	1×	assert_eq!(a.lookup("other/x.dat").binary, None);
188	1×	assert_eq!(a.lookup("src/gen.txt").eol, None, "deeper file overrides");
189	1×	assert_eq!(a.lookup("src/other.txt").eol, Some(Eol::Lf));
190	1×	assert_eq!(a.lookup("plain"), Attrs::default());
191	1×	}
192
193		#[test]
194	1×	fn eol_conversions() {
195	1×	assert_eq!(normalize_eol(b"a\r\nb\nc\r\n"), b"a\nb\nc\n");
196	1×	assert_eq!(to_crlf(b"a\nb\r\nc\n"), b"a\r\nb\r\nc\r\n");
197	1×	assert_eq!(normalize_eol(&to_crlf(b"x\ny\n")), b"x\ny\n");
198	1×	}
199		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/oxy-core/src/attributes.rs 95.9%

Keyboard