continue moving logic into classes

hsh.ts

···
 import type { Config } from "./config.ts";
 import { getEntryPath, getNotebookRoot } from "./paths.ts";
 import type { EventHandler } from "./plugins/plugins.ts";
-import { NamedNotebookPath, Notebook } from "./notebook.ts";
+import { NamedNotebookPath, Notebook, NotebookPath } from "./notebook.ts";
 import { join } from "@std/path/join";
 import { initRepo } from "./git.ts";
 
···
     for (const handler of this._handlers) {
       await handler.handleNotebookChanged?.(notebook, message);
     }
+  }
+
+  parse(path: string): NotebookPath {
+    let notebook: Notebook;
+
+    if (path.includes(":")) {
+      let name: string;
+      [name, path] = path.split(":", 2);
+      if (!path) path = "";
+      notebook = this.getNotebook(name);
+    } else {
+      notebook = this.currentNotebook();
+    }
+
+    let folders;
+    let entry: string | undefined;
+    const components = path.split("/").filter((e) => e != "");
+    if (path.endsWith("/")) {
+      folders = components;
+    } else {
+      entry = components.pop();
+      folders = components;
+    }
+
+    return { notebook, folders, entry };
   }
 
   // FIXME(bmps): This should leave this class once the whole Notebook/NotebookPath

notebook.ts

···
   entry?: string;
 }
 
+export class NotebookPath {
+  notebook: Notebook;
+  folders: string[];
+  entry?: string;
+
+  constructor(notebook: Notebook, folders: string[], entry?: string) {
+    this.notebook = notebook;
+    this.folders = folders;
+    this.entry = entry;
+  }
+
+  toString(): string {
+    return `${this.folders.join("/")}${this.folders.length > 0 ? "/" : ""}${
+      this.entry ?? ""
+    }}`;
+  }
+}
+
 export interface RelativePath {
   folders: string[];
   entry?: string;
···
 
   return { notebook, folders, entry };
 }
-
-export function unparse(path: NamedNotebookPath): string {
-  return `${path.folders.join("/")}${path.folders.length > 0 ? "/" : ""}${
-    path.entry ?? ""
-  }}`;
-}

plugins/todo.ts

···
 import { print } from "../utils.ts";
 import { relativeNotePath } from "../paths.ts";
 import { Hsh } from "../hsh.ts";
-import { NamedNotebookPath, Notebook, unparse } from "../notebook.ts";
+import { NamedNotebookPath, Notebook, NotebookPath } from "../notebook.ts";
 
-async function showTodos(notebooks: Notebook[], status?: TodoStatus) {
+async function showTodos(hsh: Hsh, notebooks: Notebook[], status?: TodoStatus) {
   const todos = await listTodos(notebooks, status);
   for (
     const items of Object.values(
       Object.groupBy(
         todos,
         (t) =>
-          unparse({
-            notebook: t.entry.notebook,
-            folders: t.entry.folders,
-            entry: t.entry.filename,
-          }),
+          (new NotebookPath(
+            hsh.getNotebook(t.entry.notebook),
+            t.entry.folders,
+            t.entry.filename,
+          )).toString(),
       ),
     )
   ) {
···
 function getTodoCommands(hsh: Hsh) {
   return new Command()
     .description("list and harvest todos")
-    .action(async () => await showTodos([hsh.currentNotebook()], "open"))
+    .action(async () => await showTodos(hsh, [hsh.currentNotebook()], "open"))
     .command("list", "list todos")
     .alias("ls")
     .arguments("[status:string]")
···
         status = maybeStatus;
       }
       const notebooks = all ? hsh.allNotebooks() : [hsh.currentNotebook()];
-      await showTodos(notebooks, status);
+      await showTodos(hsh, notebooks, status);
     })
     .command("do", "complete a todo")
     .arguments("<path:string> [line:number]")