mod disk;
mod memory;
mod overlay;
use std::path::{Path, PathBuf};
pub use disk::DiskVfs;
pub use memory::MemoryVfs;
pub use overlay::Overlay;
#[derive(Debug, thiserror::Error)]
pub enum VfsError {
#[error("file not found: {0}")]
NotFound(PathBuf),
#[error("destination already exists: {0}")]
Exists(PathBuf),
#[error("{path}: not valid UTF-8")]
InvalidUtf8 { path: PathBuf },
#[error("{path}: {source}")]
Io {
path: PathBuf,
#[source]
source: std::io::Error,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MoveState {
Unchanged,
DestinationLinked,
Moved,
Unknown,
}
#[derive(Debug, thiserror::Error)]
#[error("{source}")]
pub struct MoveError {
#[source]
pub source: VfsError,
pub state: MoveState,
}
impl MoveError {
pub fn new(source: VfsError, state: MoveState) -> Self {
Self { source, state }
}
pub fn into_source(self) -> VfsError {
self.source
}
}
#[derive(Debug)]
pub struct ParentCreation {
pub created: Vec<PathBuf>,
pub result: Result<(), VfsError>,
}
impl ParentCreation {
pub fn new(created: Vec<PathBuf>, result: Result<(), VfsError>) -> Self {
Self { created, result }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EntryKind {
File,
Directory,
Other,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Stamp {
modified: u128,
len: u64,
}
impl Stamp {
pub fn new(modified: u128, len: u64) -> Self {
Self { modified, len }
}
}
pub trait Vfs: Send + Sync {
fn read(&self, path: &Path) -> Result<String, VfsError>;
fn read_bytes(&self, path: &Path) -> Result<Vec<u8>, VfsError> {
self.read(path).map(String::into_bytes)
}
fn stamp(&self, path: &Path) -> Result<Stamp, VfsError>;
fn write(&self, path: &Path, contents: &str) -> Result<(), VfsError>;
fn exists(&self, path: &Path) -> bool;
fn entry_kind(&self, path: &Path) -> Result<Option<EntryKind>, VfsError>;
fn entry_path(&self, path: &Path) -> Result<Option<PathBuf>, VfsError> {
Ok(self.entry_kind(path)?.map(|_| path.to_path_buf()))
}
fn names_alias(&self, from: &Path, to: &Path) -> Result<bool, VfsError> {
Ok(from == to)
}
fn same_entry(&self, from: &Path, to: &Path) -> Result<bool, VfsError> {
let Some(from) = self.entry_path(from)? else {
return Ok(false);
};
Ok(self.entry_path(to)?.is_some_and(|to| from == to))
}
fn prepare_parent(&self, path: &Path) -> ParentCreation;
fn create_dir(&self, path: &Path) -> Result<(), VfsError> {
Err(VfsError::Io {
path: path.to_path_buf(),
source: std::io::Error::new(
std::io::ErrorKind::Unsupported,
"directory creation is not modeled by this file system",
),
})
}
fn remove_file(&self, path: &Path) -> Result<(), VfsError>;
fn remove_empty_dir(&self, path: &Path) -> Result<(), VfsError>;
fn move_if_absent(&self, from: &Path, to: &Path) -> Result<(), MoveError>;
fn walk(&self, root: &Path) -> Result<Vec<PathBuf>, VfsError>;
}