use std::collections::BTreeMap;
use super::{Entry, EntryKind, FileId, Opened, Tree};
use crate::error::TreeError;
use crate::path::RelPath;
#[derive(Debug, Clone, PartialEq, Eq)]
enum Fault {
Outside { key: String },
FileAsDirectory { key: String },
Duplicate { key: String },
}
impl Fault {
fn to_error(&self) -> TreeError {
match self {
Self::Outside { key } => TreeError::OutsideRoot { path: key.clone() },
Self::FileAsDirectory { key } => TreeError::NotRegular { path: key.clone() },
Self::Duplicate { key } => TreeError::DuplicatePath { path: key.clone() },
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct MemoryTree {
files: BTreeMap<String, String>,
fault: Option<Fault>,
}
fn collapse(path: &RelPath) -> String {
let mut kept: Vec<&str> = Vec::new();
for segment in path.segments() {
if segment == ".." {
kept.pop();
} else {
kept.push(segment);
}
}
kept.join("/")
}
impl MemoryTree {
pub fn create_new(&mut self, path: &RelPath, text: String) -> Result<(), TreeError> {
super::require_first_party(path)?;
self.check()?;
let key = collapse(path);
self.check_ancestors(&key)?;
if self.files.contains_key(&key) {
return Err(TreeError::DuplicatePath { path: key });
}
if self.is_directory(&key) {
return Err(TreeError::NotRegular { path: key });
}
self.files.insert(key, text);
Ok(())
}
fn check_ancestors(&self, key: &str) -> Result<(), TreeError> {
if !key.is_empty() && self.files.contains_key("") {
return Err(TreeError::NotRegular {
path: String::new(),
});
}
let mut ancestor = key;
while let Some((parent, _)) = ancestor.rsplit_once('/') {
if self.files.contains_key(parent) {
return Err(TreeError::NotRegular {
path: parent.to_owned(),
});
}
ancestor = parent;
}
Ok(())
}
pub fn replace(&mut self, path: &RelPath, text: String) -> Result<(), TreeError> {
super::require_first_party(path)?;
self.check()?;
let key = collapse(path);
self.check_ancestors(&key)?;
let Some(previous) = self.files.get_mut(&key) else {
return Err(if self.is_directory(&key) {
TreeError::NotRegular { path: key }
} else {
TreeError::NotFound { path: key }
});
};
*previous = text;
Ok(())
}
pub fn try_from_iter<I, K, V>(entries: I) -> Result<Self, TreeError>
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<str>,
V: Into<String>,
{
Self::build(entries).map_err(|fault| fault.to_error())
}
fn build<I, K, V>(entries: I) -> Result<Self, Fault>
where
I: IntoIterator<Item = (K, V)>,
K: AsRef<str>,
V: Into<String>,
{
let mut files = BTreeMap::new();
for (key, text) in entries {
let key = key.as_ref();
let path = RelPath::new(key).map_err(|_| Fault::Outside {
key: key.to_owned(),
})?;
if files.insert(collapse(&path), text.into()).is_some() {
return Err(Fault::Duplicate {
key: key.to_owned(),
});
}
}
for key in files.keys() {
let mut prefix = String::new();
for segment in key.split('/') {
if !prefix.is_empty() {
prefix.push('/');
}
prefix.push_str(segment);
if prefix != *key && files.contains_key(&prefix) {
return Err(Fault::FileAsDirectory { key: prefix });
}
}
}
Ok(Self { files, fault: None })
}
fn check(&self) -> Result<(), TreeError> {
self.fault
.as_ref()
.map_or(Ok(()), |fault| Err(fault.to_error()))
}
fn is_directory(&self, directory: &str) -> bool {
directory.is_empty() || self.keys_below(directory).next().is_some()
}
fn keys_below<'a>(&'a self, directory: &'a str) -> impl Iterator<Item = &'a str> {
self.files.keys().filter_map(move |key| {
if directory.is_empty() {
Some(key.as_str())
} else {
key.strip_prefix(directory)
.and_then(|rest| rest.strip_prefix('/'))
}
})
}
}
impl<K: AsRef<str>, V: Into<String>> FromIterator<(K, V)> for MemoryTree {
fn from_iter<I: IntoIterator<Item = (K, V)>>(entries: I) -> Self {
match Self::build(entries) {
Ok(tree) => tree,
Err(fault) => Self {
files: BTreeMap::new(),
fault: Some(fault),
},
}
}
}
impl<const N: usize> From<[(&str, &str); N]> for MemoryTree {
fn from(entries: [(&str, &str); N]) -> Self {
entries.into_iter().collect()
}
}
impl Tree for MemoryTree {
fn read(&self, path: &RelPath, max_bytes: u64) -> Result<String, TreeError> {
super::require_first_party(path)?;
self.check()?;
let key = collapse(path);
match self.files.get(&key) {
Some(text) => {
if u64::try_from(text.len()).map_or(true, |len| len > max_bytes) {
Err(TreeError::TooLarge {
path: path.to_string(),
limit: max_bytes,
})
} else {
Ok(text.clone())
}
}
None if self.is_directory(&key) => Err(TreeError::NotRegular {
path: path.to_string(),
}),
None => Err(TreeError::NotFound {
path: path.to_string(),
}),
}
}
fn read_bytes(&self, path: &RelPath, max_bytes: u64) -> Result<Vec<u8>, TreeError> {
self.read(path, max_bytes).map(String::into_bytes)
}
fn read_unseen(
&self,
path: &RelPath,
max_bytes: u64,
seen: &dyn Fn(&FileId) -> bool,
) -> Result<Opened, TreeError> {
super::require_first_party(path)?;
self.check()?;
let key = collapse(path);
if self.files.contains_key(&key) {
let id = FileId::from_key(&key);
if seen(&id) {
return Ok(Opened::Seen(id));
}
Ok(Opened::Read {
id,
text: self.read(path, max_bytes)?,
})
} else if self.is_directory(&key) {
Err(TreeError::NotRegular {
path: path.to_string(),
})
} else {
Err(TreeError::NotFound {
path: path.to_string(),
})
}
}
fn list(&self, path: &RelPath) -> Result<Vec<Entry>, TreeError> {
super::require_first_party(path)?;
self.check()?;
let key = collapse(path);
if self.files.contains_key(&key) {
return Err(TreeError::NotRegular {
path: path.to_string(),
});
}
if !self.is_directory(&key) {
return Err(TreeError::NotFound {
path: path.to_string(),
});
}
let mut found: BTreeMap<&str, EntryKind> = BTreeMap::new();
for rest in self.keys_below(&key) {
match rest.split_once('/') {
Some((name, _)) => found.insert(name, EntryKind::Dir),
None => found.insert(rest, EntryKind::File),
};
}
Ok(found
.into_iter()
.map(|(name, kind)| Entry {
name: name.to_owned(),
kind,
})
.collect())
}
fn entry(&self, path: &RelPath) -> Result<Option<EntryKind>, TreeError> {
super::require_first_party(path)?;
self.check()?;
let key = collapse(path);
if self.files.contains_key(&key) {
Ok(Some(EntryKind::File))
} else if self.is_directory(&key) {
Ok(Some(EntryKind::Dir))
} else {
Ok(None)
}
}
}