1use std::sync::Arc;
49
50use crate::limits::{ChargeError, Meter, MeteredVec};
51use crate::raw::RawStr;
52use crate::tables::{is_case_ignorable, is_sigma_cased, lower_exception, nd_digit};
53
54const CAPITAL_SIGMA: char = '\u{3A3}';
57
58fn lower_pieces(s: &[u8], mut emit: impl FnMut(&[u8]) -> bool) -> bool {
62 for chunk in s.utf8_chunks() {
63 let run = chunk.valid();
64 if !run.is_empty() && !lower_run(run, &mut emit) {
65 return false;
66 }
67 let bad = chunk.invalid();
68 if !bad.is_empty() && !emit(bad) {
70 return false;
71 }
72 }
73 true
74}
75
76fn lower_run(run: &str, emit: &mut impl FnMut(&[u8]) -> bool) -> bool {
78 let mut buf = [0u8; 12];
79 for (i, c) in run.char_indices() {
80 let piece: &[u8] = if c == CAPITAL_SIGMA {
81 sigma_form(run, i).encode_utf8(&mut buf).as_bytes()
82 } else if let Some(py) = lower_exception(c) {
83 py.as_bytes()
84 } else {
85 let mut n = 0;
86 for l in c.to_lowercase() {
87 n += l.encode_utf8(buf.get_mut(n..).unwrap_or_default()).len();
88 }
89 buf.get(..n).unwrap_or_default()
90 };
91 if !emit(piece) {
92 return false;
93 }
94 }
95 true
96}
97
98fn sigma_form(run: &str, at: usize) -> char {
103 let before = run.get(..at).unwrap_or_default();
104 let after = run.get(at + CAPITAL_SIGMA.len_utf8()..).unwrap_or_default();
105 let mut back = before.chars().rev().filter(|&c| !is_case_ignorable(c));
106 let mut ahead = after.chars().filter(|&c| !is_case_ignorable(c));
107 let fin = back.next().is_some_and(is_sigma_cased) && !ahead.next().is_some_and(is_sigma_cased);
108 if fin { '\u{3C2}' } else { '\u{3C3}' }
109}
110
111fn lower_within(whole: &RawStr, sub: &[u8], meter: &Arc<Meter>) -> Result<RawStr, ChargeError> {
115 let mut len = 0usize;
116 let mut same = true;
117 lower_pieces(sub, |piece| {
118 let end = len.saturating_add(piece.len());
119 same = same && sub.get(len..end) == Some(piece);
120 len = end;
121 true
122 });
123 if same && len == sub.len() {
124 return Ok(slice_of(whole, sub));
125 }
126 let mut out = MeteredVec::with_capacity(meter, len)?;
127 let mut failed = None;
128 lower_pieces(sub, |piece| match out.extend_from_slice(piece) {
129 Ok(()) => true,
130 Err(e) => {
131 failed = Some(e);
132 false
133 }
134 });
135 if let Some(e) = failed {
136 return Err(e);
137 }
138 RawStr::from_metered(out, meter)
139}
140
141fn slice_of(whole: &RawStr, sub: &[u8]) -> RawStr {
143 if sub.is_empty() {
144 return RawStr::default();
145 }
146 whole.slice_ref(sub)
147}
148
149pub fn py_lower(s: &RawStr, meter: &Arc<Meter>) -> Result<RawStr, ChargeError> {
151 lower_within(s, s.as_bytes(), meter)
152}
153
154#[must_use]
158pub fn lower_eq(a: &[u8], lowered: &[u8]) -> bool {
159 let mut at = 0usize;
160 let all = lower_pieces(a, |piece| {
161 let end = at.saturating_add(piece.len());
162 let same = lowered.get(at..end) == Some(piece);
163 at = end;
164 same
165 });
166 all && at == lowered.len()
167}
168
169fn first_char_len(p: &[u8]) -> usize {
172 p.utf8_chunks()
173 .next()
174 .map_or(0, |c| c.valid().chars().next().map_or(1, char::len_utf8))
175}
176
177fn splitdrive(p: &[u8]) -> (&[u8], &[u8]) {
182 let is_sep = |b: &u8| *b == b'\\' || *b == b'/';
183 if p.first().is_some_and(is_sep) && p.get(1).is_some_and(is_sep) {
185 let unc = p.get(..8).is_some_and(|head| {
189 head.iter().zip(b"\\\\?\\UNC\\").all(|(&b, &want)| {
190 let b = if b == b'/' { b'\\' } else { b };
191 b.to_ascii_uppercase() == want
192 })
193 });
194 let start = if unc { 8 } else { 2 };
195 let find = |from: usize| {
196 p.get(from..)
197 .and_then(|t| t.iter().position(is_sep))
198 .map(|i| i + from)
199 };
200 let Some(index) = find(start) else {
201 return (p, &[]);
202 };
203 let Some(index2) = find(index + 1) else {
204 return (p, &[]);
205 };
206 return p.split_at(index2);
207 }
208 let first = first_char_len(p);
210 if first > 0 && p.get(first) == Some(&b':') {
211 return p.split_at(first + 1);
212 }
213 (&[], p)
214}
215
216#[must_use]
218pub fn ntpath_basename(p: &[u8]) -> &[u8] {
219 let (_, rest) = splitdrive(p);
220 let start = rest
221 .iter()
222 .rposition(|&b| b == b'\\' || b == b'/')
223 .map_or(0, |i| i + 1);
224 rest.get(start..).unwrap_or_default()
225}
226
227#[must_use]
229pub fn ntpath_splitext(p: &[u8]) -> (&[u8], &[u8]) {
230 let sep = p.iter().rposition(|&b| b == b'\\' || b == b'/');
232 let Some(dot) = p.iter().rposition(|&b| b == b'.') else {
233 return (p, &[]);
234 };
235 if sep.is_none_or(|s| dot > s) {
236 let name = sep.map_or(0, |s| s + 1);
237 if p.get(name..dot)
239 .is_some_and(|lead| lead.iter().any(|&b| b != b'.'))
240 {
241 return p.split_at(dot);
242 }
243 }
244 (p, &[])
245}
246
247pub fn simplify_name_vec(
250 name: &[u8],
251 meter: &Arc<Meter>,
252) -> Result<crate::limits::MeteredVec<u8>, ChargeError> {
253 let name = ntpath_basename(name);
254 let mut len = 0usize;
255 lower_pieces(name, |piece| {
256 len = len.saturating_add(piece.len());
257 true
258 });
259 let mut out = crate::limits::MeteredVec::with_capacity(meter, len)?;
260 let mut error = None;
261 lower_pieces(name, |piece| match out.extend_from_slice(piece) {
262 Ok(()) => true,
263 Err(e) => {
264 error = Some(e);
265 false
266 }
267 });
268 match error {
269 Some(e) => Err(e),
270 None => Ok(out),
271 }
272}
273
274pub fn simplify_name(name: &RawStr, meter: &Arc<Meter>) -> Result<RawStr, ChargeError> {
277 lower_within(name, ntpath_basename(name.as_bytes()), meter)
279}
280
281pub fn clean_external_path(path: &RawStr, meter: &Arc<Meter>) -> Result<RawStr, ChargeError> {
285 let mut p = path.as_bytes();
287 if let Some(rest) = p.strip_prefix(b"archive:/") {
288 p = rest;
289 }
290 if let Some(rest) = p.strip_prefix(b"assets/") {
291 p = rest;
292 }
293 let start = p.iter().rposition(|&b| b == b'/').map_or(0, |i| i + 1);
295 lower_within(path, p.get(start..).unwrap_or_default(), meter)
296}
297
298#[must_use]
311pub fn is_split_path(path: &[u8]) -> bool {
312 const SPLIT: &[u8] = b".split";
313 let mut first_newline = None;
314 let mut last_sep = None;
315 for (i, &b) in path.iter().enumerate() {
316 if path.get(i..).is_some_and(|rest| rest.starts_with(SPLIT))
317 && i > 0
318 && path.get(i - 1).is_some_and(|&p| p != b'/' && p != b'\\')
319 && first_newline.is_none_or(|n| last_sep.is_none_or(|s| n > s))
320 && path
321 .get(i + SPLIT.len()..)
322 .and_then(|rest| rest.utf8_chunks().next())
323 .and_then(|c| c.valid().chars().next())
324 .is_some_and(|c| nd_digit(c).is_some())
325 {
326 return true;
327 }
328 match b {
329 b'\n' if first_newline.is_none() => first_newline = Some(i),
330 b'/' | b'\\' => last_sep = Some(i),
331 _ => {}
332 }
333 }
334 false
335}
336
337#[cfg(test)]
338mod tests {
339 use std::sync::Arc;
340
341 use super::{
342 clean_external_path, lower_eq, ntpath_basename, ntpath_splitext, py_lower, simplify_name,
343 splitdrive,
344 };
345 use crate::budget::{OWNER_COST, Reservation, Unbounded};
346 use crate::limits::{Meter, heap_cost};
347 use crate::raw::RawStr;
348
349 fn meter() -> Arc<Meter> {
350 Meter::new(1 << 30, Arc::new(Unbounded), Reservation::Input)
351 }
352
353 fn lower(s: &[u8]) -> Vec<u8> {
354 py_lower(&RawStr::from(s), &meter())
355 .unwrap()
356 .as_bytes()
357 .to_vec()
358 }
359
360 #[test]
361 fn an_unchanged_name_is_its_own_bytes_and_charges_nothing() {
362 let m = meter();
363 let name = RawStr::from_shared(bytes::Bytes::from(b"dir/cab-0123".to_vec()));
364 let key = simplify_name(&name, &m).unwrap();
365 assert_eq!(key.as_bytes(), b"cab-0123");
366 assert_eq!(
367 key.as_bytes().as_ptr(),
368 name.as_bytes()[4..].as_ptr(),
369 "a slice of the name"
370 );
371 let same = py_lower(&name, &m).unwrap();
372 assert_eq!(same.as_bytes().as_ptr(), name.as_bytes().as_ptr());
373 assert_eq!(m.used(), 0);
374 }
375
376 #[test]
377 fn a_lowered_name_is_charged_and_returns_its_charge() {
378 let m = meter();
379 let key = simplify_name(&RawStr::from("a\\CAB-ABC"), &m).unwrap();
380 assert_eq!(key.as_bytes(), b"cab-abc");
381 assert_eq!(m.used(), heap_cost(7) + OWNER_COST);
382 drop(key);
383 assert_eq!(m.used(), 0);
384 let full = Meter::new(OWNER_COST, Arc::new(Unbounded), Reservation::Input);
385 assert!(py_lower(&RawStr::from("ABC"), &full).is_err());
386 assert_eq!(full.used(), 0);
387 }
388
389 #[test]
390 fn invalid_bytes_pass_through_and_valid_runs_lower() {
391 assert_eq!(
392 lower(b"A\xffB\xc3\x84\xed\xa0\x80Z"),
393 b"a\xffb\xc3\xa4\xed\xa0\x80z"
394 );
395 assert_eq!(lower("\u{130}".as_bytes()), "i\u{307}".as_bytes());
397 }
398
399 #[test]
400 fn a_final_sigma_lowers_by_context() {
401 assert_eq!(lower("ΑΣ".as_bytes()), "ας".as_bytes());
405 assert_eq!(lower("ΑΣΑ".as_bytes()), "ασα".as_bytes());
406 assert_eq!(lower("Σ".as_bytes()), "σ".as_bytes());
407 assert_eq!(lower("ΑΣ.txt".as_bytes()), "ασ.txt".as_bytes());
408 assert_eq!(lower("ΑΣ.".as_bytes()), "ας.".as_bytes());
409 let mut b = "ΑΣ".as_bytes().to_vec();
410 b.push(0xff);
411 b.extend_from_slice("Α".as_bytes());
412 let mut want = "ας".as_bytes().to_vec();
413 want.push(0xff);
414 want.extend_from_slice("α".as_bytes());
415 assert_eq!(lower(&b), want);
416 assert_eq!(lower("\u{A7CB}Σ".as_bytes()), "\u{A7CB}σ".as_bytes());
420 assert_eq!(lower("Α\u{1E030}Σ".as_bytes()), "α\u{1E030}σ".as_bytes());
421 assert_eq!(lower("ΑΣ\u{1E030}".as_bytes()), "ας\u{1E030}".as_bytes());
422 let m = meter();
424 let s = py_lower(&RawStr::from("ΑΣ"), &m).unwrap();
425 assert_eq!(m.used(), heap_cost(4) + OWNER_COST);
426 drop(s);
427 assert_eq!(m.used(), 0);
428 }
429
430 #[test]
431 fn lower_eq_compares_without_building() {
432 assert!(lower_eq(b"CAB-Abc", b"cab-abc"));
433 assert!(!lower_eq(b"CAB-Abc", b"cab-ab"));
434 assert!(!lower_eq(b"CAB-Ab", b"cab-abc"));
435 assert!(lower_eq("ΑΣ".as_bytes(), "ας".as_bytes()));
436 assert!(!lower_eq("ΑΣ".as_bytes(), "ασ".as_bytes()));
437 assert!(lower_eq(b"", b""));
438 }
439
440 #[test]
441 fn splitdrive_and_basename_follow_ntpath() {
442 let sd = |p: &str| {
443 let (a, b) = splitdrive(p.as_bytes());
444 (
445 String::from_utf8(a.to_vec()).unwrap(),
446 String::from_utf8(b.to_vec()).unwrap(),
447 )
448 };
449 let s = |a: &str, b: &str| (a.to_owned(), b.to_owned());
450 assert_eq!(sd("c:x/y"), s("c:", "x/y"));
452 assert_eq!(sd("//a/b/c"), s("//a/b", "/c"));
453 assert_eq!(sd("//a/b"), s("//a/b", ""));
454 assert_eq!(sd("///a/b"), s("///a", "/b"));
455 assert_eq!(sd("//"), s("//", ""));
456 assert_eq!(sd("é:foo"), s("é:", "foo"));
457 assert_eq!(sd(":"), s("", ":"));
458 assert_eq!(sd("\\\\?\\UNC\\s\\sh\\x"), s("\\\\?\\UNC\\s\\sh", "\\x"));
459 assert_eq!(sd("//?/unc/s/sh/x"), s("//?/unc/s/sh", "/x"));
460 assert_eq!(ntpath_basename(b"a/b\\c"), b"c");
461 assert_eq!(ntpath_basename(b"c:x"), b"x");
462 assert_eq!(ntpath_basename(b"//srv/share"), b"");
463 assert_eq!(ntpath_basename(b"dir/"), b"");
464 }
465
466 #[test]
467 fn splitext_keeps_leading_dots() {
468 assert_eq!(ntpath_splitext(b"a.b.c"), (&b"a.b"[..], &b".c"[..]));
469 assert_eq!(ntpath_splitext(b".resS"), (&b".resS"[..], &b""[..]));
470 assert_eq!(ntpath_splitext(b"..x"), (&b"..x"[..], &b""[..]));
471 assert_eq!(ntpath_splitext(b"..x.y"), (&b"..x"[..], &b".y"[..]));
472 assert_eq!(ntpath_splitext(b"a.d/b"), (&b"a.d/b"[..], &b""[..]));
473 assert_eq!(ntpath_splitext(b"x."), (&b"x"[..], &b"."[..]));
474 }
475
476 #[test]
477 fn an_external_path_is_cleaned_as_pptr_does() {
478 let m = meter();
479 let c = |p: &str| clean_external_path(&RawStr::from(p), &m).unwrap();
480 assert_eq!(c("archive:/CAB-X/CAB-Y").as_bytes(), b"cab-y");
481 assert_eq!(c("assets/Foo/Bar.asset").as_bytes(), b"bar.asset");
482 assert_eq!(c("archive:/assets/x").as_bytes(), b"x");
483 assert_eq!(c("Library/a\\B").as_bytes(), b"a\\b");
484 assert_eq!(c("").as_bytes(), b"");
485 }
486}