@spec append_file(t(), String.t(), binary()) :: {:ok, t()} | {:error, :eisdir}

Append content to a file, creating it if it doesn't exist.

@spec basename(String.t()) :: String.t()

Get the base name (file name) of a path.

Examples

iex> InMemoryFs.basename("/home/user/file.txt")
"file.txt"

@spec chmod(t(), String.t(), non_neg_integer()) :: {:ok, t()} | {:error, :enoent}

Change file/directory permissions.

@spec cp(t(), String.t(), String.t(), cp_opts()) ::
  {:ok, t()} | {:error, :enoent | :eisdir}

Copy a file or directory.

Options

• :recursive - copy directory contents recursively (required for directories)

Returns

• {:ok, updated_fs} on success
• {:error, :enoent} if source doesn't exist
• {:error, :eisdir} if source is directory and not recursive

@spec dirname(String.t()) :: String.t()

Get the directory name (parent path) of a path.

Examples

iex> InMemoryFs.dirname("/home/user/file.txt")
"/home/user"
iex> InMemoryFs.dirname("/file.txt")
"/"

@spec exists?(t(), String.t()) :: boolean()

Check if a path exists in the filesystem.

Examples

iex> fs = InMemoryFs.new(%{"/file.txt" => "hello"})
iex> InMemoryFs.exists?(fs, "/file.txt")
true
iex> InMemoryFs.exists?(fs, "/nonexistent")
false

@spec get_all_paths(t()) :: [String.t()]

Get all paths in the filesystem.

@spec link(t(), String.t(), String.t()) ::
  {:ok, t()} | {:error, :enoent | :eperm | :eexist}

Create a hard link.

@spec lstat(t(), String.t()) :: {:ok, stat_result()} | {:error, :enoent}

Get the stat information for a path (does NOT follow symlinks).

@spec mkdir(t(), String.t(), mkdir_opts()) :: {:ok, t()} | {:error, :eexist | :enoent}

Create a directory.

Options

• :recursive - create parent directories if needed (default: false)

Returns

• {:ok, updated_fs} on success
• {:error, :eexist} if path already exists (and not recursive with existing dir)
• {:error, :enoent} if parent doesn't exist (and not recursive)

@spec mv(t(), String.t(), String.t()) :: {:ok, t()} | {:error, :enoent}

Move/rename a file or directory.

@spec new(map()) :: t()

Create a new in-memory filesystem with optional initial files.

Options

Initial files can be provided as a map:

• Simple form: %{"/path/to/file" => "content"}
• Extended form: %{"/path/to/file" => %{content: "content", mode: 0o755, mtime: ~U[...]}}

Examples

iex> fs = InMemoryFs.new()
iex> fs = InMemoryFs.new(%{"/home/user/file.txt" => "hello"})
iex> fs = InMemoryFs.new(%{"/bin/script" => %{content: "#!/bin/bash", mode: 0o755}})

@spec normalize_path(String.t()) :: String.t()

Normalize a filesystem path.

Handles:

• Empty paths and "/" -> "/"
• Trailing slashes removal
• Resolving "." and ".." components
• Ensuring leading "/"

Examples

iex> InMemoryFs.normalize_path("/home/user/../user/./file")
"/home/user/file"

@spec read_file(t(), String.t()) ::
  {:ok, binary()} | {:error, :enoent | :eisdir | :eloop}

Read the contents of a file.

Returns

• {:ok, content} - binary content of the file
• {:error, :enoent} - file does not exist
• {:error, :eisdir} - path is a directory
• {:error, :eloop} - too many symlink levels

@spec readdir(t(), String.t()) :: {:ok, [String.t()]} | {:error, :enoent | :enotdir}

Read directory contents.

Returns

• {:ok, entries} - list of entry names (not full paths), sorted
• {:error, :enoent} - directory does not exist
• {:error, :enotdir} - path is not a directory

@spec readlink(t(), String.t()) :: {:ok, String.t()} | {:error, :enoent | :einval}

Read the target of a symbolic link.

@spec resolve_path(String.t(), String.t()) :: String.t()

Resolve a path relative to a base path.

Examples

iex> InMemoryFs.resolve_path("/home/user", "file.txt")
"/home/user/file.txt"
iex> InMemoryFs.resolve_path("/home/user", "/etc/passwd")
"/etc/passwd"

@spec rm(t(), String.t(), rm_opts()) :: {:ok, t()} | {:error, :enoent | :enotempty}

Remove a file or directory.

Options

• :recursive - remove directory contents recursively (default: false)
• :force - don't error if path doesn't exist (default: false)

Returns

• {:ok, updated_fs} on success
• {:error, :enoent} if path doesn't exist (and not force)
• {:error, :enotempty} if directory has contents (and not recursive)

@spec stat(t(), String.t()) :: {:ok, stat_result()} | {:error, :enoent}

Get the stat information for a path (follows symlinks).

Returns

{:ok, stat} with stat containing:

• :is_file - boolean
• :is_directory - boolean
• :is_symbolic_link - always false (stat follows symlinks)
• :mode - file permissions
• :size - byte size (0 for directories)
• :mtime - modification time

Errors

• {:error, :enoent} - path does not exist

@spec symlink(t(), String.t(), String.t()) :: {:ok, t()} | {:error, :eexist}

Create a symbolic link.

@spec write_file(t(), String.t(), binary(), write_opts()) ::
  {:ok, t()} | {:error, :eisdir}

Write content to a file, creating it if it doesn't exist.

Parent directories are created automatically.

Options

• :mode - file permissions (default: 0o644)
• :mtime - modification time (default: now)

Returns

• {:ok, updated_fs} on success
• {:error, :eisdir} if path is a directory