@tanishqkancharla/diffmap 0.1.5 → 0.3.0

package/src/gist/GistApp.tsx

@@ -4,10 +4,16 @@ import { style, useStyles } from "purse-styles";
 import { init } from "md4x/standalone";
 import { parseViewerDocument } from "../parseViewer.ts";
 import type { ViewerDocument } from "../parseViewer.ts";
+import { WORKING } from "../changes.ts";
+import {
+  ChangesLoaderContext,
+  type ChangesLoader,
+} from "../viewer/changesSource.ts";
 import { ViewerApp } from "../viewer/ViewerApp.tsx";
 import { loadGistMarkdown, type GistDocument } from "./fetchGist.ts";
 import { GistPinContext } from "./pin.ts";
 import { HostHome } from "../host/HostHome.tsx";
+import { HostFilesContext } from "../host/files.ts";
 import { GistLoading, GistStatus } from "./GistStatus.tsx";
 import {
   gistPath,
@@ -41,6 +47,7 @@ type GistView =
       gist: GistDocument;
       file: string;
       document: ViewerDocument;
+      loadChanges: ChangesLoader;
     };
 
 export function GistApp() {
@@ -160,24 +167,28 @@ export function GistApp() {
         htmlUrl: view.gist.htmlUrl,
       }}
     >
-      <ViewerApp
-        key={`${view.gist.id}:${view.file}`}
-        document={view.document}
-        mode="gist"
-        headerActions={
-          <GistHeader
-            gistId={view.gist.id}
-            htmlUrl={view.gist.htmlUrl}
-            files={view.gist.files}
-            current={view.file}
-            onSelect={(file) => {
-              const next = gistPath(view.gist.id, file);
-              window.history.pushState({}, "", next);
-              setRoute(parseGistPath(next));
-            }}
+      <HostFilesContext.Provider value={view.gist.sourceFiles}>
+        <ChangesLoaderContext.Provider value={view.loadChanges}>
+          <ViewerApp
+            key={`${view.gist.id}:${view.file}`}
+            document={view.document}
+            mode="gist"
+            headerActions={
+              <GistHeader
+                gistId={view.gist.id}
+                htmlUrl={view.gist.htmlUrl}
+                files={view.gist.files}
+                current={view.file}
+                onSelect={(file) => {
+                  const next = gistPath(view.gist.id, file);
+                  window.history.pushState({}, "", next);
+                  setRoute(parseGistPath(next));
+                }}
+              />
+            }
           />
-        }
-      />
+        </ChangesLoaderContext.Provider>
+      </HostFilesContext.Provider>
     </GistPinContext.Provider>
   );
 }
@@ -218,11 +229,21 @@ async function loadView(
       message: parsed.message,
     };
   }
+  const snapshot = loaded.gist.changes;
   return {
     kind: "ready",
     gist: loaded.gist,
     file: loaded.gist.chosen.name,
     document: parsed,
+    loadChanges: (rev) =>
+      Promise.resolve(
+        snapshot[rev] ??
+          new Error(
+            rev === WORKING
+              ? "Uncommitted changes are only available in a local viewer."
+              : `This gist has no snapshot of ${rev}. Share the spec again with diffmap share.`,
+          ),
+      ),
   };
 }
 

package/src/gist/fetchGist.ts

@@ -1,3 +1,10 @@
+import {
+  GIST_CHANGES_FILE,
+  GIST_FILES_FILE,
+  type Changes,
+  type Rev,
+} from "../changes.ts";
+import type { HostFiles } from "../host/files.ts";
 import { githubGistUrl, markdownFileNames, pickMarkdownFile } from "./route.ts";
 
 export type GistMarkdownFile = {
@@ -10,6 +17,10 @@ export type GistDocument = {
   htmlUrl: string;
   files: GistMarkdownFile[];
   chosen: GistMarkdownFile;
+  /** Snapshot `diffmap share` saved for each commit and changes card the spec references. */
+  changes: Record<Rev, Changes>;
+  /** Files excerpts and references without a commit read, as they were when shared. */
+  sourceFiles: HostFiles;
 };
 
 export type GistLoadResult =
@@ -95,6 +106,23 @@ export async function loadGistMarkdown(
     return { status: "missing-file", htmlUrl, files };
   }
 
+  // SAFETY: diffmap share writes this file from readDocumentChanges.
+  const changes = (await readSnapshot(apiFiles, GIST_CHANGES_FILE, signal)) as
+    | Record<Rev, Changes>
+    | Error;
+  if (changes instanceof Error) {
+    return { status: "error", message: changes.message };
+  }
+  // SAFETY: diffmap share writes this file as path to contents.
+  const sourceFiles = (await readSnapshot(
+    apiFiles,
+    GIST_FILES_FILE,
+    signal,
+  )) as HostFiles | Error;
+  if (sourceFiles instanceof Error) {
+    return { status: "error", message: sourceFiles.message };
+  }
+
   return {
     status: "ok",
     gist: {
@@ -102,10 +130,29 @@ export async function loadGistMarkdown(
       htmlUrl,
       files,
       chosen,
+      changes,
+      sourceFiles,
     },
   };
 }
 
+/** A JSON file `diffmap share` wrote, or `{}` when the gist predates it. */
+async function readSnapshot(
+  apiFiles: Record<string, GistApiFile>,
+  name: string,
+  signal?: AbortSignal,
+): Promise<unknown> {
+  const file = apiFiles[name];
+  if (file === undefined) return {};
+  const text = await readGistFile(file, signal);
+  if (text instanceof Error) return text;
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return new Error(`${name} is not valid JSON.`);
+  }
+}
+
 async function readGistFile(file: GistApiFile, signal?: AbortSignal) {
   const name = file.filename ?? "file";
   if (file.truncated !== true && typeof file.content === "string") {

package/src/git.test.ts

@@ -0,0 +1,402 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import test from "node:test";
+import {
+  changedFileItem,
+  revWindow,
+  windowRev,
+  type Changes,
+  type DeltaWindow,
+} from "./changes.js";
+import { listDeltas, readChanges, readDocumentChanges } from "./git.js";
+
+const execFileAsync = promisify(execFile);
+
+async function withRepo(
+  run: (
+    root: string,
+    git: (...args: string[]) => Promise<string>,
+  ) => Promise<void>,
+) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "diffmap-git-"));
+  const git = async (...args: string[]) =>
+    (await execFileAsync("git", args, { cwd: root })).stdout.trim();
+  const write = (file: string, contents: string) =>
+    fs.writeFile(path.join(root, file), contents);
+  try {
+    await git("init", "-q");
+    await git("config", "user.email", "test@example.com");
+    await git("config", "user.name", "Test");
+    await write("keep.ts", "one\ntwo\nthree\n");
+    await write("old-name.ts", "export const a = 1;\nexport const b = 2;\n");
+    await write("gone.ts", "bye\n");
+    await git("add", ".");
+    await git("commit", "-qm", "Initial");
+    await run(root, git);
+  } finally {
+    await fs.rm(root, { recursive: true, force: true });
+  }
+}
+
+/** Compares what the viewer receives over JSON. */
+function summary(changes: Changes) {
+  return (JSON.parse(JSON.stringify(changes)) as Changes).files
+    .map((file) => ({
+      path: file.path,
+      prevPath: file.prevPath,
+      status: file.status,
+      additions: file.additions,
+      deletions: file.deletions,
+      contents: file.contents,
+    }))
+    .toSorted((a, b) => a.path.localeCompare(b.path));
+}
+
+test("readChanges reads a commit's added, modified, renamed, and deleted files", async () => {
+  await withRepo(async (root, git) => {
+    const initial = await git("rev-parse", "HEAD");
+    await fs.writeFile(path.join(root, "keep.ts"), "one\nTWO\nthree\nfour\n");
+    await git("mv", "old-name.ts", "new-name.ts");
+    await git("rm", "-q", "gone.ts");
+    await fs.writeFile(path.join(root, "added.ts"), "new\n");
+    await git("add", ".");
+    await git("commit", "-qm", "Change things");
+    const head = await git("rev-parse", "HEAD");
+
+    const changes = await readChanges(root, head.slice(0, 7));
+    assert.equal(changes instanceof Error, false);
+    if (changes instanceof Error) return;
+    assert.equal(changes.title, "Change things");
+    assert.deepEqual(summary(changes), [
+      {
+        path: "added.ts",
+        prevPath: undefined,
+        status: "added",
+        additions: 1,
+        deletions: 0,
+        contents: { new: "new\n" },
+      },
+      {
+        path: "gone.ts",
+        prevPath: undefined,
+        status: "deleted",
+        additions: 0,
+        deletions: 1,
+        contents: { old: "bye\n" },
+      },
+      {
+        path: "keep.ts",
+        prevPath: undefined,
+        status: "modified",
+        additions: 2,
+        deletions: 1,
+        contents: { old: "one\ntwo\nthree\n", new: "one\nTWO\nthree\nfour\n" },
+      },
+      {
+        path: "new-name.ts",
+        prevPath: "old-name.ts",
+        status: "renamed",
+        additions: 0,
+        deletions: 0,
+        contents: {
+          old: "export const a = 1;\nexport const b = 2;\n",
+          new: "export const a = 1;\nexport const b = 2;\n",
+        },
+      },
+    ]);
+
+    // The root commit diffs against the empty tree.
+    const rootCommit = await readChanges(root, initial);
+    assert.equal(rootCommit instanceof Error, false);
+    if (rootCommit instanceof Error) return;
+    assert.deepEqual(
+      summary(rootCommit).map((file) => [file.path, file.status]),
+      [
+        ["gone.ts", "added"],
+        ["keep.ts", "added"],
+        ["old-name.ts", "added"],
+      ],
+    );
+
+    const range = await readChanges(
+      root,
+      `${initial.slice(0, 7)}..${head.slice(0, 7)}`,
+    );
+    assert.equal(range instanceof Error, false);
+    if (range instanceof Error) return;
+    assert.equal(
+      range.title,
+      `${initial.slice(0, 7)}..${head.slice(0, 7)} · 1 commit`,
+    );
+    assert.equal(range.files.length, 4);
+
+    assert.equal((await readChanges(root, "abcdef1")) instanceof Error, true);
+    assert.equal((await readChanges(root, "HEAD")) instanceof Error, true);
+  });
+});
+
+test("readChanges working includes staged, unstaged, deleted, and untracked files", async () => {
+  await withRepo(async (root, git) => {
+    await fs.writeFile(path.join(root, "keep.ts"), "one\ntwo\nthree\nstaged\n");
+    await git("add", "keep.ts");
+    await fs.writeFile(
+      path.join(root, "keep.ts"),
+      "one\ntwo\nthree\nstaged\nunstaged\n",
+    );
+    await fs.rm(path.join(root, "gone.ts"));
+    await fs.writeFile(path.join(root, "fresh.ts"), "a\nb\n");
+
+    const changes = await readChanges(root, "working");
+    assert.equal(changes instanceof Error, false);
+    if (changes instanceof Error) return;
+    assert.equal(changes.title, "Uncommitted changes");
+    assert.deepEqual(
+      summary(changes).map((file) => [
+        file.path,
+        file.status,
+        file.additions,
+        file.deletions,
+        file.contents?.new,
+      ]),
+      [
+        ["fresh.ts", "added", 2, 0, "a\nb\n"],
+        ["gone.ts", "deleted", 0, 1, undefined],
+        ["keep.ts", "modified", 2, 0, "one\ntwo\nthree\nstaged\nunstaged\n"],
+      ],
+    );
+  });
+});
+
+test("readChanges working shows a path removed from the index but kept on disk once", async () => {
+  await withRepo(async (root, git) => {
+    // keep.ts is unchanged on disk, so it is not a change at all.
+    await git("rm", "-q", "--cached", "keep.ts", "gone.ts");
+    await fs.writeFile(path.join(root, "gone.ts"), "bye\nagain\n");
+
+    const changes = await readChanges(root, "working");
+    assert.equal(changes instanceof Error, false, String(changes));
+    if (changes instanceof Error) return;
+    assert.deepEqual(
+      summary(changes).map((file) => [
+        file.path,
+        file.status,
+        file.additions,
+        file.deletions,
+        file.contents,
+      ]),
+      [["gone.ts", "modified", 1, 0, { old: "bye\n", new: "bye\nagain\n" }]],
+    );
+  });
+});
+
+test("readChanges reads a symlink as its target path, not the file it points to", async () => {
+  await withRepo(async (root) => {
+    const outside = await fs.mkdtemp(path.join(os.tmpdir(), "diffmap-secret-"));
+    try {
+      await fs.writeFile(path.join(outside, "secret.txt"), "secret\n");
+      await fs.symlink(
+        path.join(outside, "secret.txt"),
+        path.join(root, "link.txt"),
+      );
+      const changes = await readChanges(root, "working");
+      assert.equal(changes instanceof Error, false, String(changes));
+      if (changes instanceof Error) return;
+      assert.deepEqual(
+        changes.files.map((file) => [file.path, file.contents?.new]),
+        [["link.txt", path.join(outside, "secret.txt")]],
+      );
+    } finally {
+      await fs.rm(outside, { recursive: true, force: true });
+    }
+  });
+});
+
+test("readChanges names files relative to a root below the repository's top level", async () => {
+  await withRepo(async (root, git) => {
+    await fs.mkdir(path.join(root, "pkg"));
+    await fs.writeFile(path.join(root, "pkg", "a.ts"), "a\n");
+    await git("add", ".");
+    await git("commit", "-qm", "Add a");
+    const sha = await git("rev-parse", "HEAD");
+    await fs.writeFile(path.join(root, "pkg", "a.ts"), "a\nb\n");
+    await fs.writeFile(path.join(root, "keep.ts"), "outside\n");
+
+    const pkg = path.join(root, "pkg");
+    const commit = await readChanges(pkg, sha);
+    const working = await readChanges(pkg, "working");
+    assert.equal(commit instanceof Error, false, String(commit));
+    assert.equal(working instanceof Error, false, String(working));
+    if (commit instanceof Error || working instanceof Error) return;
+    assert.deepEqual(
+      summary(commit).map((file) => [file.path, file.status]),
+      [["a.ts", "added"]],
+    );
+    assert.deepEqual(
+      summary(working).map((file) => [file.path, file.status, file.contents]),
+      [["a.ts", "modified", { old: "a\n", new: "a\nb\n" }]],
+    );
+  });
+});
+
+test("readDocumentChanges rejects unchanged files and ranges past the end", async () => {
+  await withRepo(async (root, git) => {
+    await fs.writeFile(path.join(root, "keep.ts"), "one\ntwo\nthree\nfour\n");
+    await git("commit", "-qam", "Add four");
+    const sha = (await git("rev-parse", "HEAD")).slice(0, 7);
+    const check = (reference: { path: string; start?: number; end?: number }) =>
+      readDocumentChanges(root, {
+        changeRevs: [],
+        references: [{ kind: "file", rev: sha, ...reference }],
+      });
+
+    const ok = await check({ path: "keep.ts", start: 4, end: 4 });
+    assert.equal(ok instanceof Error, false);
+    if (ok instanceof Error) return;
+    assert.deepEqual([...ok.keys()], [sha]);
+
+    const pastEnd = await check({ path: "keep.ts", start: 4, end: 5 });
+    assert.match(
+      pastEnd instanceof Error ? pastEnd.message : "",
+      /past the end of keep\.ts \(4 lines\)/,
+    );
+
+    const unchanged = await check({ path: "gone.ts" });
+    assert.match(
+      unchanged instanceof Error ? unchanged.message : "",
+      /gone\.ts is not changed/,
+    );
+  });
+});
+
+test("listDeltas lists a branch's commits, and picked windows read the right files", async () => {
+  await withRepo(async (root, git) => {
+    const write = (file: string, contents: string) =>
+      fs.writeFile(path.join(root, file), contents);
+    await git("branch", "-M", "main");
+    await git("checkout", "-qb", "feature");
+    await write("first.ts", "1\n");
+    await git("add", ".");
+    await git("commit", "-qm", "First");
+    await write("second.ts", "2\n");
+    await git("add", ".");
+    await git("commit", "-qm", "Second");
+    await write("staged.ts", "s\n");
+    await git("add", "staged.ts");
+    await write("keep.ts", "one\ntwo\nthree\nunstaged\n");
+
+    const deltas = await listDeltas(root);
+    assert.equal(deltas instanceof Error, false);
+    if (deltas instanceof Error) return;
+    // The initial commit is on main, so the list stops at the branch point.
+    assert.deepEqual(
+      deltas.map((delta) =>
+        delta.kind === "commit" ? delta.subject : delta.kind,
+      ),
+      ["unstaged", "staged", "Second", "First"],
+    );
+    assert.deepEqual(
+      deltas.slice(0, 2).map((delta) => [delta.additions, delta.deletions]),
+      [
+        [1, 0],
+        [1, 0],
+      ],
+    );
+
+    // An open commit before the branch point extends the list down to it.
+    const initial = await git("rev-parse", "main");
+    const reaching = await listDeltas(root, initial.slice(0, 7));
+    assert.equal(reaching instanceof Error, false);
+    if (reaching instanceof Error) return;
+    assert.deepEqual(
+      reaching.map((delta) =>
+        delta.kind === "commit" ? delta.subject : delta.kind,
+      ),
+      ["unstaged", "staged", "Second", "First", "Initial"],
+    );
+    assert.deepEqual(revWindow(reaching, initial.slice(0, 7)), {
+      newest: 4,
+      oldest: 4,
+    });
+    // Picking every row of the extended list keeps its oldest commit.
+    const everything = { newest: 0, oldest: reaching.length - 1 };
+    const whole = windowRev(reaching, everything);
+    assert.deepEqual(revWindow(reaching, whole), everything);
+    const wholeChanges = await readChanges(root, whole);
+    assert.equal(wholeChanges instanceof Error, false, String(wholeChanges));
+    if (wholeChanges instanceof Error) return;
+    assert.equal(
+      wholeChanges.files.some((file) => file.path === "gone.ts"),
+      true,
+    );
+
+    const filesFor = async (window: DeltaWindow) => {
+      const rev = windowRev(deltas, window);
+      // Every window maps back to the same rows, so the picker can show what a rev covers.
+      assert.deepEqual(revWindow(deltas, rev), window);
+      const changes = await readChanges(root, rev);
+      assert.equal(changes instanceof Error, false, String(changes));
+      if (changes instanceof Error) return [];
+      return changes.files.map((file) => file.path).toSorted();
+    };
+    assert.deepEqual(await filesFor({ newest: 2, oldest: 3 }), [
+      "first.ts",
+      "second.ts",
+    ]);
+    assert.deepEqual(await filesFor({ newest: 3, oldest: 3 }), ["first.ts"]);
+    assert.deepEqual(await filesFor({ newest: 1, oldest: 3 }), [
+      "first.ts",
+      "second.ts",
+      "staged.ts",
+    ]);
+    assert.deepEqual(await filesFor({ newest: 1, oldest: 1 }), ["staged.ts"]);
+    assert.deepEqual(await filesFor({ newest: 0, oldest: 0 }), ["keep.ts"]);
+    assert.deepEqual(await filesFor({ newest: 0, oldest: 1 }), [
+      "keep.ts",
+      "staged.ts",
+    ]);
+    assert.deepEqual(await filesFor({ newest: 0, oldest: 3 }), [
+      "first.ts",
+      "keep.ts",
+      "second.ts",
+      "staged.ts",
+    ]);
+  });
+});
+
+/** Whether a diff item shows a new-side line inside a hunk. */
+function covers(item: ReturnType<typeof changedFileItem>, line: number) {
+  return (
+    item?.type === "diff" &&
+    item.fileDiff.hunks.some(
+      (hunk) =>
+        line >= hunk.additionStart &&
+        line < hunk.additionStart + hunk.additionCount,
+    )
+  );
+}
+
+test("changedFileItem shows a focused range that sits in unchanged code", () => {
+  const lines = Array.from(
+    { length: 100 },
+    (_, index) => `line ${String(index + 1)}`,
+  );
+  const old = `${lines.join("\n")}\n`;
+  const next = old.replace("line 90\n", "line ninety\n");
+  const file = {
+    path: "a.ts",
+    status: "modified" as const,
+    additions: 1,
+    deletions: 1,
+    binary: false,
+    contents: { old, new: next },
+  };
+  assert.equal(covers(changedFileItem(file), 10), false);
+  const focused = changedFileItem(file, { start: 10, end: 12 });
+  assert.equal(covers(focused, 10) && covers(focused, 12), true);
+  // A new version makes Pierre reread the widened item.
+  assert.notEqual(focused?.version, changedFileItem(file)?.version);
+});