use std::{
io::{self, Write},
path::{Path, PathBuf},
};
use super::api::{Metadata, TempDir};
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
use std::fs as platform_fs;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
use webfs::fs as platform_fs;
pub fn invalid_path_error(message: &str) -> io::Error {
io::Error::new(io::ErrorKind::InvalidInput, message.to_owned())
}
pub(crate) fn metadata_parts(metadata: platform_fs::Metadata) -> Metadata {
Metadata::from_parts(
metadata.len(),
metadata.is_file(),
metadata.is_dir(),
metadata.file_type().is_symlink(),
)
}
pub(crate) fn path_string(path: PathBuf) -> io::Result<String> {
path.into_os_string()
.into_string()
.map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "path is not valid UTF-8"))
}
pub fn normalize_path(path: &str) -> io::Result<String> {
let mut parts = Vec::new();
let rooted = Path::new(path).has_root();
for component in Path::new(path).components() {
match component {
std::path::Component::CurDir | std::path::Component::RootDir => {}
std::path::Component::ParentDir if parts.last().is_some_and(|part| *part != "..") => {
parts.pop();
}
std::path::Component::ParentDir if !rooted => parts.push(".."),
std::path::Component::Normal(part) => parts.push(
part.to_str()
.ok_or_else(|| invalid_path_error("path is not valid UTF-8"))?,
),
_ => {}
}
}
let joined = parts.join("/");
Ok(if rooted {
format!("/{joined}")
} else if joined.is_empty() {
".".to_owned()
} else {
joined
})
}
pub fn glob_to_regex(pattern: &str) -> io::Result<String> {
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
glob::Pattern::new(pattern).map_err(|error| invalid_path_error(&error.to_string()))?;
let mut result = String::from("^");
let mut chars = pattern.chars().peekable();
while let Some(character) = chars.next() {
match character {
'*' if chars.peek() == Some(&'*') => {
chars.next();
if chars.peek() == Some(&'/') {
chars.next();
result.push_str("(?:.*/)?");
} else {
result.push_str(".*");
}
}
'*' => result.push_str("[^/]*"),
'?' => result.push_str("[^/]"),
'[' => {
result.push('[');
if chars.peek() == Some(&'!') {
chars.next();
result.push('^');
}
for item in chars.by_ref() {
result.push(item);
if item == ']' {
break;
}
}
}
'.' | '+' | '(' | ')' | '$' | '^' | '|' | '{' | '}' | '\\' => {
result.push('\\');
result.push(character);
}
_ => result.push(character),
}
}
result.push('$');
Ok(result)
}
pub fn exists_sync(path: &str) -> io::Result<bool> {
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
{
platform_fs::try_exists(path)
}
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
{
Path::new(path).try_exists()
}
}
pub(crate) fn check_access(metadata: &platform_fs::Metadata, mode: u32) -> io::Result<()> {
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let permissions = metadata.permissions().mode();
for (requested, available) in [(4, 0o444), (2, 0o222), (1, 0o111)] {
if mode & requested != 0 && permissions & available == 0 {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"requested access is not permitted",
));
}
}
}
#[cfg(not(unix))]
{
if mode & 2 != 0 && metadata.permissions().readonly() {
return Err(io::Error::new(
io::ErrorKind::PermissionDenied,
"write access is not permitted",
));
}
}
Ok(())
}
pub fn access_sync(path: &str, mode: u32) -> io::Result<()> {
check_access(&platform_fs::metadata(path)?, mode)
}
pub fn read_text(path: &str) -> io::Result<String> {
platform_fs::read_to_string(path)
}
pub fn write_text(path: &str, contents: &str) -> io::Result<()> {
platform_fs::write(path, contents)
}
pub fn append_text(path: &str, contents: &str) -> io::Result<()> {
platform_fs::OpenOptions::new()
.create(true)
.append(true)
.open(path)?
.write_all(contents.as_bytes())
}
pub fn append_file_sync(path: &str, contents: &[u8]) -> io::Result<()> {
platform_fs::OpenOptions::new()
.create(true)
.append(true)
.open(path)?
.write_all(contents)
}
pub fn read_file_sync(path: &str) -> io::Result<Vec<u8>> {
platform_fs::read(path)
}
pub fn write_file_sync(path: &str, contents: &[u8]) -> io::Result<()> {
platform_fs::write(path, contents)
}
pub fn copy_file_sync(from: &str, to: &str) -> io::Result<()> {
platform_fs::copy(from, to).map(|_| ())
}
#[cfg(unix)]
fn create_symlink(from: &Path, to: &Path) -> io::Result<()> {
std::os::unix::fs::symlink(platform_fs::read_link(from)?, to)
}
#[cfg(windows)]
fn create_symlink(from: &Path, to: &Path) -> io::Result<()> {
let target = platform_fs::read_link(from)?;
if platform_fs::metadata(from)?.is_dir() {
std::os::windows::fs::symlink_dir(target, to)
} else {
std::os::windows::fs::symlink_file(target, to)
}
}
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
fn create_symlink(_from: &Path, _to: &Path) -> io::Result<()> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"symbolic links are not supported by webfs",
))
}
#[cfg(not(any(unix, windows, all(target_family = "wasm", not(target_os = "wasi")))))]
fn create_symlink(_from: &Path, _to: &Path) -> io::Result<()> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"copying symbolic links is unsupported on this platform",
))
}
pub fn cp_sync(from: &str, to: &str) -> io::Result<()> {
fn copy_path(from: &Path, to: &Path) -> io::Result<()> {
let metadata = platform_fs::symlink_metadata(from)?;
if metadata.is_dir() {
platform_fs::create_dir_all(to)?;
for entry in platform_fs::read_dir(from)? {
let entry = entry?;
copy_path(&entry.path(), &to.join(entry.file_name()))?;
}
platform_fs::set_permissions(to, metadata.permissions())
} else if metadata.is_file() {
platform_fs::copy(from, to).map(|_| ())
} else if metadata.file_type().is_symlink() {
create_symlink(from, to)
} else {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"copying this filesystem entry type is unsupported",
))
}
}
copy_path(Path::new(from), Path::new(to))
}
pub fn create_dir(path: &str) -> io::Result<()> {
platform_fs::create_dir(path)
}
pub fn create_dir_all(path: &str) -> io::Result<()> {
platform_fs::create_dir_all(path)
}
pub fn read_dir(path: &str) -> io::Result<Vec<String>> {
platform_fs::read_dir(path)?
.map(|entry| {
entry?.file_name().into_string().map_err(|_| {
io::Error::new(
io::ErrorKind::InvalidData,
"directory entry name is not valid UTF-8",
)
})
})
.collect()
}
pub fn mkdir_sync(path: &str, recursive: bool) -> io::Result<()> {
if recursive {
create_dir_all(path)
} else {
create_dir(path)
}
}
pub fn readdir_sync(path: &str) -> io::Result<Vec<String>> {
read_dir(path)
}
pub fn rmdir_sync(path: &str) -> io::Result<()> {
platform_fs::remove_dir(path)
}
pub fn rm_sync(path: &str, recursive: bool, force: bool) -> io::Result<()> {
let result = match platform_fs::symlink_metadata(path) {
Ok(metadata) if metadata.is_dir() => {
if recursive {
platform_fs::remove_dir_all(path)
} else {
platform_fs::remove_dir(path)
}
}
Ok(_) => platform_fs::remove_file(path),
Err(error) => Err(error),
};
if force
&& result
.as_ref()
.is_err_and(|error| error.kind() == io::ErrorKind::NotFound)
{
Ok(())
} else {
result
}
}
pub fn realpath_sync(path: &str) -> io::Result<String> {
path_string(platform_fs::canonicalize(path)?)
}
pub fn remove_file(path: &str) -> io::Result<()> {
platform_fs::remove_file(path)
}
pub fn rename_sync(from: &str, to: &str) -> io::Result<()> {
platform_fs::rename(from, to)
}
pub fn link_sync(original: &str, link: &str) -> io::Result<()> {
platform_fs::hard_link(original, link)
}
pub fn symlink_sync(target: &str, link: &str) -> io::Result<()> {
#[cfg(unix)]
{
std::os::unix::fs::symlink(target, link)
}
#[cfg(windows)]
{
let target_at_link = Path::new(link)
.parent()
.unwrap_or(Path::new("."))
.join(target);
if platform_fs::metadata(target_at_link).is_ok_and(|metadata| metadata.is_dir()) {
std::os::windows::fs::symlink_dir(target, link)
} else {
std::os::windows::fs::symlink_file(target, link)
}
}
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
{
let _ = (target, link);
Err(io::Error::new(
io::ErrorKind::Unsupported,
"symbolic links are not supported by webfs",
))
}
#[cfg(not(any(unix, windows, all(target_family = "wasm", not(target_os = "wasi")))))]
{
let _ = (target, link);
Err(io::Error::new(
io::ErrorKind::Unsupported,
"symbolic links are unsupported on this platform",
))
}
}
pub fn readlink_sync(path: &str) -> io::Result<String> {
path_string(platform_fs::read_link(path)?)
}
pub fn unlink_sync(path: &str) -> io::Result<()> {
platform_fs::remove_file(path)
}
pub fn truncate_sync(path: &str, len: u64) -> io::Result<()> {
platform_fs::OpenOptions::new()
.write(true)
.open(path)?
.set_len(len)
}
pub fn stat_sync(path: &str) -> io::Result<Metadata> {
platform_fs::metadata(path).map(metadata_parts)
}
pub fn lstat_sync(path: &str) -> io::Result<Metadata> {
platform_fs::symlink_metadata(path).map(metadata_parts)
}
pub fn app_dir(name: &str) -> io::Result<String> {
validate_app_name(name)?;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
let base = dirs::data_local_dir().ok_or_else(|| {
io::Error::new(
io::ErrorKind::NotFound,
"could not determine the application data directory",
)
})?;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
let base = PathBuf::from("/");
let path = base.join(name);
platform_fs::create_dir_all(&path)?;
path_string(path)
}
fn validate_app_name(name: &str) -> io::Result<()> {
let name_path = Path::new(name);
if name.contains('/')
|| name.contains('\\')
|| !matches!(
name_path.components().next(),
Some(std::path::Component::Normal(_))
)
|| name_path.components().count() != 1
{
return Err(invalid_path_error(
"application name must be a single path component",
));
}
Ok(())
}
pub fn mkdtemp_disposable_sync(prefix: &str) -> io::Result<TempDir> {
Ok(TempDir {
path: mkdtemp_sync(prefix)?,
})
}
pub fn mkdtemp_sync(prefix: &str) -> io::Result<String> {
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
{
let path = Path::new(prefix);
let parent = path
.parent()
.filter(|parent| !parent.as_os_str().is_empty())
.unwrap_or(Path::new("."));
let name = path
.file_name()
.ok_or_else(|| invalid_path_error("temporary directory prefix must include a name"))?;
path_string(
tempfile::Builder::new()
.prefix(name)
.tempdir_in(parent)?
.keep(),
)
}
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
{
use std::sync::atomic::{AtomicU64, Ordering};
static NEXT_ID: AtomicU64 = AtomicU64::new(1);
let base = Path::new(prefix);
let name = base
.file_name()
.ok_or_else(|| invalid_path_error("temporary directory prefix must include a name"))?
.to_string_lossy();
let parent = base.parent().unwrap_or(Path::new("/"));
for _ in 0..100 {
let suffix = NEXT_ID.fetch_add(1, Ordering::Relaxed);
let candidate = parent.join(format!("{name}{suffix:x}"));
match platform_fs::create_dir(&candidate) {
Ok(()) => return path_string(candidate),
Err(error) if error.kind() == io::ErrorKind::AlreadyExists => continue,
Err(error) => return Err(error),
}
}
Err(io::Error::new(
io::ErrorKind::AlreadyExists,
"could not allocate a unique temporary directory",
))
}
}
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[path = "webfs.rs"]
mod webfs_impl;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
pub use webfs_impl::*;
#[cfg(all(test, not(all(target_family = "wasm", not(target_os = "wasi")))))]
mod tests {
use super::*;
#[test]
fn path_normalization_and_glob_conversion_are_shared() {
assert_eq!(normalize_path("/a/./b/../c").unwrap(), "/a/c");
assert_eq!(normalize_path("a/../../b").unwrap(), "../b");
assert_eq!(glob_to_regex("**/*.rs").unwrap(), "^(?:.*/)?[^/]*\\.rs$");
}
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[test]
fn app_directory_name_validation_is_shared() {
assert!(validate_app_name("example-app").is_ok());
assert_eq!(
validate_app_name("../outside").unwrap_err().kind(),
io::ErrorKind::InvalidInput
);
}
}