use std::collections::BTreeSet;
use std::fmt;
use crate::name::{Name, NameError, display_bytes};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EntryKind {
Regular {
size: u64,
},
Directory,
Symlink,
Fifo,
Socket,
CharDevice,
BlockDevice,
Unknown,
}
impl fmt::Display for EntryKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Regular { .. } => "regular file",
Self::Directory => "directory",
Self::Symlink => "symbolic link",
Self::Fifo => "FIFO",
Self::Socket => "socket",
Self::CharDevice => "character device",
Self::BlockDevice => "block device",
Self::Unknown => "unknown file type",
})
}
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum RejectReason {
#[error("name fails allowlist: {0}")]
InvalidName(#[from] NameError),
#[error("not a regular file ({0})")]
NotRegularFile(EntryKind),
#[error("not a directory ({0})")]
NotDirectory(EntryKind),
#[error("file is not empty ({0} bytes)")]
NotEmpty(u64),
#[error("cannot inspect entry: {0}")]
Inaccessible(String),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Rejection {
pub display_name: String,
pub reason: RejectReason,
}
pub fn classify(file_name: &[u8], kind: Result<EntryKind, String>) -> Result<Name, Rejection> {
let reject = |reason| Rejection {
display_name: display_bytes(file_name),
reason,
};
let name = Name::from_bytes(file_name).map_err(|e| reject(e.into()))?;
match kind.map_err(|e| reject(RejectReason::Inaccessible(e)))? {
EntryKind::Regular { size: 0 } => Ok(name),
EntryKind::Regular { size } => Err(reject(RejectReason::NotEmpty(size))),
other => Err(reject(RejectReason::NotRegularFile(other))),
}
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct Membership {
pub members: BTreeSet<Name>,
pub rejected: Vec<Rejection>,
pub ignored: Vec<String>,
}
impl Membership {
pub fn from_entries<'a, I>(entries: I) -> Self
where
I: IntoIterator<Item = (&'a [u8], Result<EntryKind, String>)>,
{
let mut membership = Self::default();
for (file_name, kind) in entries {
if file_name == b"." || file_name == b".." {
continue;
}
if file_name.starts_with(b".") {
membership.ignored.push(display_bytes(file_name));
continue;
}
match classify(file_name, kind) {
Ok(name) => {
membership.members.insert(name);
}
Err(rejection) => membership.rejected.push(rejection),
}
}
membership
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accepts_empty_regular_file() {
assert_eq!(
classify(b"libcurl", Ok(EntryKind::Regular { size: 0 })).unwrap(),
Name::new("libcurl").unwrap()
);
}
#[test]
fn rejects_non_empty_file() {
let r = classify(b"libcurl", Ok(EntryKind::Regular { size: 3 })).unwrap_err();
assert_eq!(r.reason, RejectReason::NotEmpty(3));
assert_eq!(r.reason.to_string(), "file is not empty (3 bytes)");
}
#[test]
fn rejects_other_types() {
for kind in [
EntryKind::Directory,
EntryKind::Symlink,
EntryKind::Fifo,
EntryKind::Socket,
EntryKind::CharDevice,
EntryKind::BlockDevice,
EntryKind::Unknown,
] {
let r = classify(b"x", Ok(kind)).unwrap_err();
assert_eq!(r.reason, RejectReason::NotRegularFile(kind));
}
let r = classify(b"x", Ok(EntryKind::Symlink)).unwrap_err();
assert_eq!(r.reason.to_string(), "not a regular file (symbolic link)");
}
#[test]
fn name_checked_before_type() {
let r = classify(b".hidden", Ok(EntryKind::Regular { size: 0 })).unwrap_err();
assert_eq!(r.reason, RejectReason::InvalidName(NameError::LeadingDot));
assert_eq!(r.display_name, ".hidden");
let r = classify(b"bad\nname", Err("gone".into())).unwrap_err();
assert!(matches!(r.reason, RejectReason::InvalidName(_)));
assert_eq!(r.display_name, "bad\\nname");
}
#[test]
fn inaccessible_entry() {
let r = classify(b"x", Err("permission denied".into())).unwrap_err();
assert_eq!(
r.reason,
RejectReason::Inaccessible("permission denied".into())
);
}
#[test]
fn membership_from_entries() {
let entries: Vec<(&[u8], Result<EntryKind, String>)> = vec![
(b".", Ok(EntryKind::Directory)),
(b"..", Ok(EntryKind::Directory)),
(b"b", Ok(EntryKind::Regular { size: 0 })),
(b"a", Ok(EntryKind::Regular { size: 0 })),
(b"link", Ok(EntryKind::Symlink)),
(b".swp", Ok(EntryKind::Regular { size: 0 })),
(b"full", Ok(EntryKind::Regular { size: 1 })),
];
let m = Membership::from_entries(entries);
let names: Vec<_> = m.members.iter().map(Name::as_str).collect();
assert_eq!(names, ["a", "b"]);
let rejected: Vec<_> = m.rejected.iter().map(|r| r.display_name.as_str()).collect();
assert_eq!(rejected, ["link", "full"]);
assert_eq!(m.ignored, [".swp"]);
}
}