use std::sync::Arc;
use crate::limits::{ChargeError, Meter, MeteredVec};
use crate::raw::RawStr;
use crate::tables::{is_case_ignorable, is_sigma_cased, lower_exception, nd_digit};
const CAPITAL_SIGMA: char = '\u{3A3}';
fn lower_pieces(s: &[u8], mut emit: impl FnMut(&[u8]) -> bool) -> bool {
for chunk in s.utf8_chunks() {
let run = chunk.valid();
if !run.is_empty() && !lower_run(run, &mut emit) {
return false;
}
let bad = chunk.invalid();
if !bad.is_empty() && !emit(bad) {
return false;
}
}
true
}
fn lower_run(run: &str, emit: &mut impl FnMut(&[u8]) -> bool) -> bool {
let mut buf = [0u8; 12];
for (i, c) in run.char_indices() {
let piece: &[u8] = if c == CAPITAL_SIGMA {
sigma_form(run, i).encode_utf8(&mut buf).as_bytes()
} else if let Some(py) = lower_exception(c) {
py.as_bytes()
} else {
let mut n = 0;
for l in c.to_lowercase() {
n += l.encode_utf8(buf.get_mut(n..).unwrap_or_default()).len();
}
buf.get(..n).unwrap_or_default()
};
if !emit(piece) {
return false;
}
}
true
}
fn sigma_form(run: &str, at: usize) -> char {
let before = run.get(..at).unwrap_or_default();
let after = run.get(at + CAPITAL_SIGMA.len_utf8()..).unwrap_or_default();
let mut back = before.chars().rev().filter(|&c| !is_case_ignorable(c));
let mut ahead = after.chars().filter(|&c| !is_case_ignorable(c));
let fin = back.next().is_some_and(is_sigma_cased) && !ahead.next().is_some_and(is_sigma_cased);
if fin { '\u{3C2}' } else { '\u{3C3}' }
}
fn lower_within(whole: &RawStr, sub: &[u8], meter: &Arc<Meter>) -> Result<RawStr, ChargeError> {
let mut len = 0usize;
let mut same = true;
lower_pieces(sub, |piece| {
let end = len.saturating_add(piece.len());
same = same && sub.get(len..end) == Some(piece);
len = end;
true
});
if same && len == sub.len() {
return Ok(slice_of(whole, sub));
}
let mut out = MeteredVec::with_capacity(meter, len)?;
let mut failed = None;
lower_pieces(sub, |piece| match out.extend_from_slice(piece) {
Ok(()) => true,
Err(e) => {
failed = Some(e);
false
}
});
if let Some(e) = failed {
return Err(e);
}
RawStr::from_metered(out, meter)
}
fn slice_of(whole: &RawStr, sub: &[u8]) -> RawStr {
if sub.is_empty() {
return RawStr::default();
}
whole.slice_ref(sub)
}
pub fn py_lower(s: &RawStr, meter: &Arc<Meter>) -> Result<RawStr, ChargeError> {
lower_within(s, s.as_bytes(), meter)
}
#[must_use]
pub fn lower_eq(a: &[u8], lowered: &[u8]) -> bool {
let mut at = 0usize;
let all = lower_pieces(a, |piece| {
let end = at.saturating_add(piece.len());
let same = lowered.get(at..end) == Some(piece);
at = end;
same
});
all && at == lowered.len()
}
fn first_char_len(p: &[u8]) -> usize {
p.utf8_chunks()
.next()
.map_or(0, |c| c.valid().chars().next().map_or(1, char::len_utf8))
}
fn splitdrive(p: &[u8]) -> (&[u8], &[u8]) {
let is_sep = |b: &u8| *b == b'\\' || *b == b'/';
if p.first().is_some_and(is_sep) && p.get(1).is_some_and(is_sep) {
let unc = p.get(..8).is_some_and(|head| {
head.iter().zip(b"\\\\?\\UNC\\").all(|(&b, &want)| {
let b = if b == b'/' { b'\\' } else { b };
b.to_ascii_uppercase() == want
})
});
let start = if unc { 8 } else { 2 };
let find = |from: usize| {
p.get(from..)
.and_then(|t| t.iter().position(is_sep))
.map(|i| i + from)
};
let Some(index) = find(start) else {
return (p, &[]);
};
let Some(index2) = find(index + 1) else {
return (p, &[]);
};
return p.split_at(index2);
}
let first = first_char_len(p);
if first > 0 && p.get(first) == Some(&b':') {
return p.split_at(first + 1);
}
(&[], p)
}
#[must_use]
pub fn ntpath_basename(p: &[u8]) -> &[u8] {
let (_, rest) = splitdrive(p);
let start = rest
.iter()
.rposition(|&b| b == b'\\' || b == b'/')
.map_or(0, |i| i + 1);
rest.get(start..).unwrap_or_default()
}
#[must_use]
pub fn ntpath_splitext(p: &[u8]) -> (&[u8], &[u8]) {
let sep = p.iter().rposition(|&b| b == b'\\' || b == b'/');
let Some(dot) = p.iter().rposition(|&b| b == b'.') else {
return (p, &[]);
};
if sep.is_none_or(|s| dot > s) {
let name = sep.map_or(0, |s| s + 1);
if p.get(name..dot)
.is_some_and(|lead| lead.iter().any(|&b| b != b'.'))
{
return p.split_at(dot);
}
}
(p, &[])
}
pub fn simplify_name_vec(
name: &[u8],
meter: &Arc<Meter>,
) -> Result<crate::limits::MeteredVec<u8>, ChargeError> {
let name = ntpath_basename(name);
let mut len = 0usize;
lower_pieces(name, |piece| {
len = len.saturating_add(piece.len());
true
});
let mut out = crate::limits::MeteredVec::with_capacity(meter, len)?;
let mut error = None;
lower_pieces(name, |piece| match out.extend_from_slice(piece) {
Ok(()) => true,
Err(e) => {
error = Some(e);
false
}
});
match error {
Some(e) => Err(e),
None => Ok(out),
}
}
pub fn simplify_name(name: &RawStr, meter: &Arc<Meter>) -> Result<RawStr, ChargeError> {
lower_within(name, ntpath_basename(name.as_bytes()), meter)
}
pub fn clean_external_path(path: &RawStr, meter: &Arc<Meter>) -> Result<RawStr, ChargeError> {
let mut p = path.as_bytes();
if let Some(rest) = p.strip_prefix(b"archive:/") {
p = rest;
}
if let Some(rest) = p.strip_prefix(b"assets/") {
p = rest;
}
let start = p.iter().rposition(|&b| b == b'/').map_or(0, |i| i + 1);
lower_within(path, p.get(start..).unwrap_or_default(), meter)
}
#[must_use]
pub fn is_split_path(path: &[u8]) -> bool {
const SPLIT: &[u8] = b".split";
let mut first_newline = None;
let mut last_sep = None;
for (i, &b) in path.iter().enumerate() {
if path.get(i..).is_some_and(|rest| rest.starts_with(SPLIT))
&& i > 0
&& path.get(i - 1).is_some_and(|&p| p != b'/' && p != b'\\')
&& first_newline.is_none_or(|n| last_sep.is_none_or(|s| n > s))
&& path
.get(i + SPLIT.len()..)
.and_then(|rest| rest.utf8_chunks().next())
.and_then(|c| c.valid().chars().next())
.is_some_and(|c| nd_digit(c).is_some())
{
return true;
}
match b {
b'\n' if first_newline.is_none() => first_newline = Some(i),
b'/' | b'\\' => last_sep = Some(i),
_ => {}
}
}
false
}
#[cfg(test)]
mod tests {
use std::sync::Arc;
use super::{
clean_external_path, lower_eq, ntpath_basename, ntpath_splitext, py_lower, simplify_name,
splitdrive,
};
use crate::budget::{OWNER_COST, Reservation, Unbounded};
use crate::limits::{Meter, heap_cost};
use crate::raw::RawStr;
fn meter() -> Arc<Meter> {
Meter::new(1 << 30, Arc::new(Unbounded), Reservation::Input)
}
fn lower(s: &[u8]) -> Vec<u8> {
py_lower(&RawStr::from(s), &meter())
.unwrap()
.as_bytes()
.to_vec()
}
#[test]
fn an_unchanged_name_is_its_own_bytes_and_charges_nothing() {
let m = meter();
let name = RawStr::from_shared(bytes::Bytes::from(b"dir/cab-0123".to_vec()));
let key = simplify_name(&name, &m).unwrap();
assert_eq!(key.as_bytes(), b"cab-0123");
assert_eq!(
key.as_bytes().as_ptr(),
name.as_bytes()[4..].as_ptr(),
"a slice of the name"
);
let same = py_lower(&name, &m).unwrap();
assert_eq!(same.as_bytes().as_ptr(), name.as_bytes().as_ptr());
assert_eq!(m.used(), 0);
}
#[test]
fn a_lowered_name_is_charged_and_returns_its_charge() {
let m = meter();
let key = simplify_name(&RawStr::from("a\\CAB-ABC"), &m).unwrap();
assert_eq!(key.as_bytes(), b"cab-abc");
assert_eq!(m.used(), heap_cost(7) + OWNER_COST);
drop(key);
assert_eq!(m.used(), 0);
let full = Meter::new(OWNER_COST, Arc::new(Unbounded), Reservation::Input);
assert!(py_lower(&RawStr::from("ABC"), &full).is_err());
assert_eq!(full.used(), 0);
}
#[test]
fn invalid_bytes_pass_through_and_valid_runs_lower() {
assert_eq!(
lower(b"A\xffB\xc3\x84\xed\xa0\x80Z"),
b"a\xffb\xc3\xa4\xed\xa0\x80z"
);
assert_eq!(lower("\u{130}".as_bytes()), "i\u{307}".as_bytes());
}
#[test]
fn a_final_sigma_lowers_by_context() {
assert_eq!(lower("ΑΣ".as_bytes()), "ας".as_bytes());
assert_eq!(lower("ΑΣΑ".as_bytes()), "ασα".as_bytes());
assert_eq!(lower("Σ".as_bytes()), "σ".as_bytes());
assert_eq!(lower("ΑΣ.txt".as_bytes()), "ασ.txt".as_bytes());
assert_eq!(lower("ΑΣ.".as_bytes()), "ας.".as_bytes());
let mut b = "ΑΣ".as_bytes().to_vec();
b.push(0xff);
b.extend_from_slice("Α".as_bytes());
let mut want = "ας".as_bytes().to_vec();
want.push(0xff);
want.extend_from_slice("α".as_bytes());
assert_eq!(lower(&b), want);
assert_eq!(lower("\u{A7CB}Σ".as_bytes()), "\u{A7CB}σ".as_bytes());
assert_eq!(lower("Α\u{1E030}Σ".as_bytes()), "α\u{1E030}σ".as_bytes());
assert_eq!(lower("ΑΣ\u{1E030}".as_bytes()), "ας\u{1E030}".as_bytes());
let m = meter();
let s = py_lower(&RawStr::from("ΑΣ"), &m).unwrap();
assert_eq!(m.used(), heap_cost(4) + OWNER_COST);
drop(s);
assert_eq!(m.used(), 0);
}
#[test]
fn lower_eq_compares_without_building() {
assert!(lower_eq(b"CAB-Abc", b"cab-abc"));
assert!(!lower_eq(b"CAB-Abc", b"cab-ab"));
assert!(!lower_eq(b"CAB-Ab", b"cab-abc"));
assert!(lower_eq("ΑΣ".as_bytes(), "ας".as_bytes()));
assert!(!lower_eq("ΑΣ".as_bytes(), "ασ".as_bytes()));
assert!(lower_eq(b"", b""));
}
#[test]
fn splitdrive_and_basename_follow_ntpath() {
let sd = |p: &str| {
let (a, b) = splitdrive(p.as_bytes());
(
String::from_utf8(a.to_vec()).unwrap(),
String::from_utf8(b.to_vec()).unwrap(),
)
};
let s = |a: &str, b: &str| (a.to_owned(), b.to_owned());
assert_eq!(sd("c:x/y"), s("c:", "x/y"));
assert_eq!(sd("//a/b/c"), s("//a/b", "/c"));
assert_eq!(sd("//a/b"), s("//a/b", ""));
assert_eq!(sd("///a/b"), s("///a", "/b"));
assert_eq!(sd("//"), s("//", ""));
assert_eq!(sd("é:foo"), s("é:", "foo"));
assert_eq!(sd(":"), s("", ":"));
assert_eq!(sd("\\\\?\\UNC\\s\\sh\\x"), s("\\\\?\\UNC\\s\\sh", "\\x"));
assert_eq!(sd("//?/unc/s/sh/x"), s("//?/unc/s/sh", "/x"));
assert_eq!(ntpath_basename(b"a/b\\c"), b"c");
assert_eq!(ntpath_basename(b"c:x"), b"x");
assert_eq!(ntpath_basename(b"//srv/share"), b"");
assert_eq!(ntpath_basename(b"dir/"), b"");
}
#[test]
fn splitext_keeps_leading_dots() {
assert_eq!(ntpath_splitext(b"a.b.c"), (&b"a.b"[..], &b".c"[..]));
assert_eq!(ntpath_splitext(b".resS"), (&b".resS"[..], &b""[..]));
assert_eq!(ntpath_splitext(b"..x"), (&b"..x"[..], &b""[..]));
assert_eq!(ntpath_splitext(b"..x.y"), (&b"..x"[..], &b".y"[..]));
assert_eq!(ntpath_splitext(b"a.d/b"), (&b"a.d/b"[..], &b""[..]));
assert_eq!(ntpath_splitext(b"x."), (&b"x"[..], &b"."[..]));
}
#[test]
fn an_external_path_is_cleaned_as_pptr_does() {
let m = meter();
let c = |p: &str| clean_external_path(&RawStr::from(p), &m).unwrap();
assert_eq!(c("archive:/CAB-X/CAB-Y").as_bytes(), b"cab-y");
assert_eq!(c("assets/Foo/Bar.asset").as_bytes(), b"bar.asset");
assert_eq!(c("archive:/assets/x").as_bytes(), b"x");
assert_eq!(c("Library/a\\B").as_bytes(), b"a\\b");
assert_eq!(c("").as_bytes(), b"");
}
}