Day 3 · Two Jobs, Two Files — Alice in Userland

Story

Now Alice really uses her app, and using it teaches her what writing it did not. Some todos have to wait: she cannot ship the thing before the tests are written. So a todo keeps a list of the todos it waits for, and she says so when she writes it down. If she tries to finish a todo that is still waiting, the app says no, because a rule nobody checks is only a note.

Her eyes are the other problem. The list prints everything at once and the ones that matter hide in the middle, so now she can ask for less: the open ones, the finished ones, or all of them. And she can ask the question she asks most often and can never answer by looking: what am I allowed to start right now? She never writes that down. It is simply a todo that is not finished and waits for nothing, so the app works it out for her.

None of these are big changes on their own. But each one leaves a little more thinking in the same file, and when she reads it she sees two different jobs sitting side by side: understanding what she typed in the terminal, and knowing what a todo is. So she cuts the file in two. main.ts talks to the terminal, and todo.ts knows about todos. She only moves the code and changes nothing, so the printing travels with it, and the help text travels too, because it lists the commands and the commands live there now. When she is done, main.ts is a switch and nothing else, while todo.ts knows her words, her flags and every line on her screen. It looks tidy. She cannot yet see that she drew the line in the wrong place.

Alice's Notebook

Give every command its own function instead of writing its body inside the switch block.
Keep the code that reads the terminal apart from the code that knows what a todo is.

Files

2

Choose a file from the tree.

import { add, done, list, remove, usage } from "./todo.ts";

const [command, ...rest] = process.argv.slice(2);

switch (command) {
  case "add":
    add(rest);
    break;

  case "list":
    list(rest);
    break;

  case "done":
    done(rest);
    break;

  case "remove":
    remove(rest);
    break;

  default:
    usage();
}

import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
import { homedir } from "node:os";
import { join } from "node:path";

export type Todo = {
  id: string;
  title: string;
  done: boolean;
  needs: string[];
  createdAt: string;
};

const filters = ["all", "open", "done", "ready"];

const dir = join(homedir(), ".todos");
if (!existsSync(dir)) mkdirSync(dir);

export function add(args: string[]) {
  const words: string[] = [];
  const needs: string[] = [];

  for (let i = 0; i < args.length; i++) {
    if (args[i] === "--needs") {
      i = i + 1;
      needs.push(...(args[i] ?? "").split(",").filter((id) => id !== ""));
    } else {
      words.push(args[i]);
    }
  }

  const title = words.join(" ").trim();

  if (title === "") {
    console.error("a todo needs a title");
    process.exitCode = 1;
    return;
  }

  for (const id of needs) {
    if (!existsSync(join(dir, `${id}.json`))) {
      console.error(`there is no todo with id ${id}`);
      process.exitCode = 1;
      return;
    }
  }

  const todo: Todo = {
    id: Date.now().toString(36),
    title,
    done: false,
    needs,
    createdAt: new Date().toISOString(),
  };

  writeFileSync(join(dir, `${todo.id}.json`), JSON.stringify(todo, null, 2) + "\n");

  console.log(`added ${todo.id}  ${todo.title}`);
}

export function list(args: string[]) {
  const filter = args[0] ?? "all";

  if (!filters.includes(filter)) {
    console.error(`usage: list <${filters.join("|")}>`);
    process.exitCode = 1;
    return;
  }

  const todos = readAll();

  const shown = todos.filter((todo) => {
    if (filter === "open") return !todo.done;
    if (filter === "done") return todo.done;
    if (filter === "ready") return !todo.done && waitingFor(todo, todos).length === 0;
    return true;
  });

  if (shown.length === 0) {
    console.log("nothing to do");
    return;
  }

  for (const todo of shown) {
    const waiting = waitingFor(todo, todos);
    const mark = todo.done ? "[x]" : "[ ]";
    const tail = waiting.length === 0 ? "" : `  needs ${waiting.map((other) => other.id).join(" ")}`;

    console.log(`${mark} ${todo.id}  ${todo.title}${tail}`);
  }
}

export function done(args: string[]) {
  const id = args[0];
  const todos = readAll();
  const todo = todos.find((other) => other.id === id);

  if (todo === undefined) {
    console.error(`there is no todo with id ${id}`);
    process.exitCode = 1;
    return;
  }

  const waiting = waitingFor(todo, todos);

  if (waiting.length > 0) {
    console.error(`${todo.id} still waits for ${waiting.map((other) => other.id).join(" ")}`);
    process.exitCode = 1;
    return;
  }

  todo.done = true;
  writeFileSync(join(dir, `${todo.id}.json`), JSON.stringify(todo, null, 2) + "\n");

  console.log(`done ${todo.id}  ${todo.title}`);
}

export function remove(args: string[]) {
  const id = args[0];
  const file = join(dir, `${id}.json`);

  if (id === undefined || !existsSync(file)) {
    console.error(`there is no todo with id ${id}`);
    process.exitCode = 1;
    return;
  }

  rmSync(file);

  console.log(`removed ${id}`);
}

export function usage() {
  console.log("usage: todo <add|list|done|remove>");
  console.log("  add <title> [--needs <id>,<id>]");
  console.log(`  list [${filters.join("|")}]`);
  console.log("  done <id>");
  console.log("  remove <id>");
}

function readAll(): Todo[] {
  const todos: Todo[] = readdirSync(dir)
    .filter((file) => file.endsWith(".json"))
    .map((file) => JSON.parse(readFileSync(join(dir, file), "utf8")))
    .map((todo) => ({ ...todo, needs: todo.needs ?? [] }));

  todos.sort((a, b) => a.createdAt.localeCompare(b.createdAt));

  return todos;
}

function waitingFor(todo: Todo, todos: Todo[]): Todo[] {
  const waiting: Todo[] = [];

  for (const id of todo.needs) {
    const other = todos.find((candidate) => candidate.id === id);
    if (other !== undefined && !other.done) waiting.push(other);
  }

  return waiting;
}