Struct InMemoryFs 

pub struct InMemoryFs { /* private fields */ }

An in-memory, clone-shared Storage backend.

Content lives behind Arc<RwLock<_>>, so cloning an InMemoryFs is cheap and every clone sees the same files — the same relationship an Arc<StdFs> has to the one real filesystem it names, but without needing the Arc wrapper, since it’s built into the type. std::sync::RwLock (not a runtime’s async lock) is deliberate: every method here runs to completion without ever awaiting inside the critical section, so there is nothing for an async lock to buy, and a plain std::sync primitive is the one that’s guaranteed to exist — and to compile — on wasm32-unknown-unknown, which has no threads and no async-runtime assumption to lean on.

Text and binary content are stored separately (a write picks one store based on whether the bytes are valid UTF-8) so that a round-trip through export_entries — text only — stays plain strings, the shape a JS/WASM caller wants. Directories are tracked explicitly (in a HashSet) rather than inferred from file paths, so an empty directory create_dir_all created still shows up in read_dir.

Symlinks may be added with add_symlink: reading or getting metadata of the link resolves to the target’s content, matching ReadStorage::metadata’s documented “follows symlinks” contract. Resolution is a single hop, not a followed chain — a symlink to a symlink is not resolved further — which is all the coherence a test double needs; a real filesystem’s chain-following and cycle detection isn’t reproduced here.

Implementations

impl InMemoryFs

pub fn new() -> Self

An empty in-memory filesystem.

pub fn with_files(entries: Vec<(PathBuf, String)>) -> Self

A filesystem pre-populated with text files (and the directories that contain them).

pub fn load_from_entries(entries: Vec<(String, String)>) -> Self

Load files from (path_string, content) pairs — convenience for a caller (JS/WASM interop) that only has strings, not PathBufs.

pub fn export_entries(&self) -> Vec<(String, String)>

Every text file, as (path_string, content) pairs — the counterpart to load_from_entries, for persisting a session’s edits back out.

pub fn export_binary_entries(&self) -> Vec<(String, Vec<u8>)>

Every binary file, as (path_string, content_bytes) pairs.

pub fn load_binary_entries(&self, entries: Vec<(String, Vec<u8>)>)

Load binary files from (path_string, content_bytes) pairs.

pub fn list_all_files(&self) -> Vec<PathBuf>

Every text-file path currently stored.

pub fn clear(&self)

Remove every file, directory, and symlink — resetting the filesystem to empty without needing a fresh InMemoryFs (and its own, separately shared, clones).

pub fn add_symlink(&self, link: &Path, target: &Path)

Add a symlink from link to target. Reading link (or its metadata) resolves to target’s content; link’s entry in its parent’s read_dir reports FileType::SYMLINK — the un-followed type a caller needs in order to recognize and skip it, since metadata itself only ever reports the followed, resolved type.

Trait Implementations

impl Clone for InMemoryFs

fn clone(&self) -> InMemoryFs

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InMemoryFs

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for InMemoryFs

fn default() -> InMemoryFs

Returns the “default value” for a type.

impl ReadStorage for InMemoryFs

async fn read(&self, path: &Path) -> Result<Vec<u8>>

Read the entire contents of a file as bytes. Mirrors std::fs::read.

async fn read_to_string(&self, path: &Path) -> Result<String>

Read the entire contents of a file as a string. Mirrors std::fs::read_to_string.

async fn read_dir(&self, path: &Path) -> Result<Vec<DirEntry>>

Return the entries in a directory (non-recursive). Mirrors std::fs::read_dir, but yields a Vec since async iterators are not yet stable.

async fn metadata(&self, path: &Path) -> Result<Metadata>

Return metadata about the entry at path. Mirrors std::fs::metadata; follows symlinks.

fn try_exists(&self, path: &Path) -> impl Future<Output = Result<bool, Error>>

Returns Ok(true) if the path exists, Ok(false) if it does not, and Err(_) if the check itself failed. Mirrors std::fs::try_exists.

impl Storage for InMemoryFs

async fn write(&self, path: &Path, contents: &[u8]) -> Result<()>

Write a file, replacing it if it already exists. Mirrors std::fs::write.

async fn create_dir_all(&self, path: &Path) -> Result<()>

Create a directory and all missing parents. Mirrors std::fs::create_dir_all.

async fn remove_file(&self, path: &Path) -> Result<()>

Remove a regular file. Mirrors std::fs::remove_file.

async fn remove_dir_all(&self, path: &Path) -> Result<()>

Recursively remove a directory and its contents. Mirrors std::fs::remove_dir_all.

async fn rename(&self, from: &Path, to: &Path) -> Result<()>

Rename or move a file or directory. Mirrors std::fs::rename.

fn capabilities(&self) -> Capabilities

What durability guarantees this backend can make. Defaults to Capabilities::NONE — a backend promises a guarantee only by saying so, so an adapter that forgets to override this degrades to the most defensive path rather than to a false promise.

async fn write_atomic(&self, path: &Path, contents: &[u8]) -> Result<()>

Replace path’s contents with contents atomically and durably: no observer — concurrent reader or post-crash survivor — ever sees a splice of old and new bytes, and once this returns the new contents outlive a power loss.

fn sync( &self, path: &Path, need: Durability, ) -> impl Future<Output = Result<()>>

Flush path — and nothing else — to the strength need asks for.