Directory

// A directory is made, listed and removed through the `FileSystem` package, and this program does
// all three to a scratch directory it owns: `Bin/scratch`, inside this package's build folder.
//
// Listing is the interesting part. `ReadDirectory` returns a cursor, and its `Next` hands out one
// name at a time, because a directory can hold a great many and returning them all at once would
// mean holding them all at once. `Next` has the nested shape from the Errors part:
//
//     func Next(self: &var DirectoryIterator) -> OsString? ! IoError
//
// The outer failure means the directory could not be read. A success holds the next name, or
// `none` once every name has been handed out. So `listing.Next()? ?? break` passes a failure on,
// stops at the end, and otherwise binds a name. The names are `OsString`s, not text, for the
// reason the Path lesson gave; `.` and `..` are skipped. The order is whatever the filesystem
// keeps, so do not rely on it.
//
// Removal is strict. `MakeDirectory` fails if the name is taken, and `DeleteDirectory` refuses a
// directory that still has anything in it, so the files go first.
import Allocator::{ Allocator, SystemAllocator };
import FileSystem::{ DeleteDirectory, DeleteFile, File, MakeDirectory, OpenOptions, ReadDirectory };
import Io::{ IoError, PrintLine, WriteAll };
import Path::{ Join, OsString, Path };
import Text::TextError;

// Writes a small file called `name` inside `directory`.
func MakeFile(allocator: Allocator, directory: Path, name: char8[..]) -> ! IoError | TextError {
    var holder = OsString::FromText(allocator, name)?;
    let path = Join(allocator, directory, holder.View())?;
    var file = File::Open(allocator, path.AsPath(), OpenOptions::Writing())?;
    WriteAll(file, name)?;
    file.Close()?;
}

// Deletes the file called `name` inside `directory`.
func RemoveFile(allocator: Allocator, directory: Path, name: char8[..]) -> ! IoError | TextError {
    var holder = OsString::FromText(allocator, name)?;
    let path = Join(allocator, directory, holder.View())?;
    DeleteFile(allocator, path.AsPath())?;
}

func Main() -> ! IoError | TextError {
    var system = SystemAllocator();
    let allocator: Allocator = system;

    var holder = OsString::FromText(allocator, "Bin/scratch")?;
    let directory = Path::FromView(holder.View());
    MakeDirectory(allocator, directory)?;
    MakeFile(allocator, directory, "first.txt")?;
    MakeFile(allocator, directory, "second.txt")?;
    PrintLine("made {} with two files", directory);

    var listing = ReadDirectory(allocator, directory)?;
    var count = 0;
    loop {
        let name = listing.Next()? ?? break;
        PrintLine("  {}", name);
        count += 1;
    }
    // The cursor holds a system handle; `Release` gives it back now rather than at scope end.
    listing.Release();
    PrintLine("listed {} entries", count);

    // Removing it too early is refused, and this failure is handled rather than passed on.
    DeleteDirectory(allocator, directory) catch {
        else => {
            PrintLine("refused: the directory is not empty");
        }
    };

    RemoveFile(allocator, directory, "first.txt")?;
    RemoveFile(allocator, directory, "second.txt")?;
    DeleteDirectory(allocator, directory)?;
    PrintLine("removed {}", directory);
}