@hienlh/ppm 0.20.10 → 0.21.0

package/packages/ext-git-graph/src/commit-message-html.test.ts

@@ -0,0 +1,214 @@
+import { describe, it, expect } from "bun:test";
+import { formatCommitMessage, splitCommitBody, COMMIT_MESSAGE_JS } from "./commit-message-html.ts";
+
+/** The default rule the graph ships with, and the one that caused the bug. */
+const ISSUE_RULE = [{ pattern: "#(\\d+)", url: "" }];
+
+describe("formatCommitMessage", () => {
+  it("leaves an apostrophe alone with the issue rule active", () => {
+    // The bug: escaping first turned this into "Monaco's", then `#(\d+)`
+    // matched the "39" and split the entity, so the row showed `'`.
+    const html = formatCommitMessage("unregister Monaco's bundled TypeScript service", ISSUE_RULE);
+    expect(html).toBe("unregister Monaco's bundled TypeScript service");
+    expect(html).not.toContain("commit-link");
+  });
+
+  it("still links a real issue reference", () => {
+    const html = formatCommitMessage("fix #39 for good", ISSUE_RULE);
+    expect(html).toBe('fix <span class="commit-link" title="#39">#39</span> for good');
+  });
+
+  it("links an issue through a url template with its capture groups", () => {
+    const html = formatCommitMessage("closes #42", [{ pattern: "#(\\d+)", url: "https://x.test/i/$1" }]);
+    expect(html).toContain('href="https://x.test/i/42"');
+    expect(html).toContain(">#42</a>");
+    expect(html).toContain('rel="noreferrer"');
+  });
+
+  it("escapes every other entity-forming character too", () => {
+    const html = formatCommitMessage('a & b < c > d "e"', ISSUE_RULE);
+    expect(html).toBe("a &amp; b &lt; c &gt; d &quot;e&quot;");
+  });
+
+  it("cannot be made to inject markup from a commit message", () => {
+    const html = formatCommitMessage('<img src=x onerror=alert(1)>', ISSUE_RULE);
+    expect(html).toBe("&lt;img src=x onerror=alert(1)&gt;");
+  });
+
+  it("cannot be made to break out of a link's href", () => {
+    // Matching raw text means the href is the only place a quote could land.
+    const html = formatCommitMessage('see http://x.test/a"onmouseover="alert(1)', []);
+    expect(html).not.toContain('"onmouseover="');
+    expect(html).toContain("&quot;onmouseover=&quot;");
+  });
+
+  it("keeps a URL atomic instead of linking what is inside it", () => {
+    const html = formatCommitMessage("see https://x.test/pull/39#c/deadbeef1 now", ISSUE_RULE);
+    expect(html).toBe(
+      'see <a class="commit-link" href="https://x.test/pull/39#c/deadbeef1"'
+      + ' target="_blank" rel="noreferrer">https://x.test/pull/39#c/deadbeef1</a> now',
+    );
+  });
+
+  it("marks a bare commit hash", () => {
+    const html = formatCommitMessage("reverts 8abb115 as agreed", []);
+    expect(html).toBe('reverts <span class="commit-link" title="8abb115">8abb115</span> as agreed');
+  });
+
+  it("gives the first claim on a range to the rule that ran first", () => {
+    // "deadbeef" is both a hash and, here, an issue pattern. The rule wins,
+    // because rules run before the hash sweep.
+    const html = formatCommitMessage("deadbeef", [{ pattern: "deadbeef", url: "https://x.test/$0" }]);
+    expect((html.match(/commit-link/g) || []).length).toBe(1);
+    expect(html).toContain("<a ");
+  });
+
+  it("skips an invalid pattern rather than losing the message", () => {
+    const html = formatCommitMessage("keep me", [{ pattern: "(unclosed", url: "" }]);
+    expect(html).toBe("keep me");
+  });
+
+  it("skips a pattern long enough to be a backtracking bomb", () => {
+    const html = formatCommitMessage("keep me", [{ pattern: "a".repeat(201), url: "" }]);
+    expect(html).toBe("keep me");
+  });
+
+  it("does not hang or emit empty spans for a pattern that matches nothing", () => {
+    const html = formatCommitMessage("abc", [{ pattern: "x*", url: "" }]);
+    expect(html).toBe("abc");
+  });
+
+  it("handles an empty or missing message", () => {
+    expect(formatCommitMessage("", ISSUE_RULE)).toBe("");
+    expect(formatCommitMessage(undefined as unknown as string, ISSUE_RULE)).toBe("");
+  });
+});
+
+describe("COMMIT_MESSAGE_JS", () => {
+  it("is the same function, and reads the rules off the webview's state", () => {
+    // The webview gets the formatter as source. Evaluating it here is what
+    // proves the shipped copy behaves like the one tested above.
+    const evaluate = new Function(
+      "state",
+      `${COMMIT_MESSAGE_JS}; return formatCommitMessage;`,
+    ) as (state: unknown) => (msg: string) => string;
+
+    const withRule = evaluate({ settings: { issueLinkingRules: ISSUE_RULE } });
+    expect(withRule("unregister Monaco's service")).toBe("unregister Monaco&#39;s service");
+    expect(withRule("fix #39")).toContain('title="#39"');
+
+    // No settings at all must not throw — the panel renders before they load.
+    const bare = evaluate({});
+    expect(bare("plain 'message'")).toBe("plain &#39;message&#39;");
+  });
+});
+
+describe("splitCommitBody", () => {
+  const NL = "\n";
+
+  it("reflows a paragraph its author wrapped at 72 columns", () => {
+    const body = [
+      "Extensions could not activate at all when PPM ran from a compiled binary.",
+      "Toggling one off and on again reported that the worker had been terminated,",
+      "and on startup activation timed out after ten seconds.",
+    ].join(NL);
+    expect(splitCommitBody(body)).toEqual([{
+      kind: "prose",
+      text: "Extensions could not activate at all when PPM ran from a compiled binary. "
+        + "Toggling one off and on again reported that the worker had been terminated, "
+        + "and on startup activation timed out after ten seconds.",
+    }]);
+  });
+
+  it("leaves a bulleted list exactly as it was written", () => {
+    // Joining these would run three items into one sentence.
+    const body = ["- the first item, which wraps", "  onto a second line", "- the second item here too"].join(NL);
+    expect(splitCommitBody(body)).toEqual([{ kind: "pre", text: body }]);
+  });
+
+  it("leaves short lines alone even though nothing marks them", () => {
+    // The give-away that the breaks are meaningful is that the lines are
+    // nowhere near the block's longest — wrapped prose fills all but one.
+    const body = ["Before: 33.3 MB", "After: 1.08 MB"].join(NL);
+    expect(splitCommitBody(body)).toEqual([{ kind: "pre", text: body }]);
+  });
+
+  it("does not reflow a paragraph with one deliberately short line in it", () => {
+    const body = [
+      "This first line runs all the way out to the usual seventy-two columns ok",
+      "short",
+      "and this last one is long again out to about seventy-two columns as well",
+    ].join(NL);
+    expect(splitCommitBody(body)[0]!.kind).toBe("pre");
+  });
+
+  it("splits on blank lines and judges each paragraph on its own", () => {
+    const body = [
+      "A first paragraph that was wrapped by its author at about seventy columns",
+      "and continues onto a second line here.",
+      "",
+      "- a list that follows it",
+      "- and must not be reflowed",
+    ].join(NL);
+    expect(splitCommitBody(body).map((b) => b.kind)).toEqual(["prose", "pre"]);
+  });
+
+  it("keeps a fence, a quote, a heading and a table verbatim", () => {
+    for (const first of ["```js", "> quoted text here", "# A heading", "| a | b |"]) {
+      const body = [first, "something else that is long enough to look like wrapped prose"].join(NL);
+      expect(splitCommitBody(body)[0]!.kind).toBe("pre");
+    }
+  });
+
+  it("treats an indented block as verbatim", () => {
+    const body = ["    indented like code, and long enough to look like wrapped prose", "    a second line"].join(NL);
+    expect(splitCommitBody(body)[0]!.kind).toBe("pre");
+  });
+
+  it("drops trailing blank lines rather than emitting empty blocks", () => {
+    expect(splitCommitBody("one line only" + NL + NL + NL)).toEqual([{ kind: "pre", text: "one line only" }]);
+    expect(splitCommitBody("")).toEqual([]);
+    expect(splitCommitBody(null as unknown as string)).toEqual([]);
+  });
+
+  it("normalises CRLF, so a message written on Windows reflows too", () => {
+    const body = "A line long enough to have been wrapped at seventy-two columns\r\n"
+      + "and a second line that continues the same sentence to its end.";
+    const [block] = splitCommitBody(body);
+    expect(block!.kind).toBe("prose");
+    expect(block!.text).not.toContain("\r");
+  });
+
+  it("ships to the webview as source, like the formatter", () => {
+    // Same reason: one copy, typed and tested here, injected by toString().
+    expect(COMMIT_MESSAGE_JS).toContain("const splitCommitBody =");
+    expect(() => new Function(COMMIT_MESSAGE_JS)).not.toThrow();
+  });
+});
+
+describe("a commit message a cloned repository chose", () => {
+  it("stops collecting links when the whole body is hex-looking words", () => {
+    // `\b[0-9a-f]{7,40}\b` matches once per word and the overlap test is
+    // linear in the spans already collected, so collecting them is quadratic in
+    // something the commit's author chose. Measured on this input: 271 ms
+    // uncapped against 3 ms capped, on the thread that draws the panel.
+    //
+    // Asserted as a count rather than as a duration, because a duration on CI
+    // is a coin toss and the count is the thing that bounds it.
+    const body = Array.from({ length: 20_000 }, (_, i) => (0xa000000 + i).toString(16)).join(" ");
+
+    const html = formatCommitMessage(body, []);
+
+    expect([...html.matchAll(/class="commit-link"/g)]).toHaveLength(500);
+    // The cap costs link decoration, never text: the last word is still there.
+    expect(html).toContain((0xa000000 + 19_999).toString(16));
+  });
+
+  it("never drops text when the link cap is reached", () => {
+    const words = Array.from({ length: 900 }, (_, i) => (0xb000000 + i).toString(16));
+
+    const html = formatCommitMessage(words.join(" "), []);
+
+    for (const word of [words[0]!, words[500]!, words[899]!]) expect(html).toContain(word);
+  });
+});

package/packages/ext-git-graph/src/commit-message-html.ts

@@ -0,0 +1,190 @@
+/**
+ * A commit message, as HTML, with the links a graph row wants in it.
+ *
+ * The rule that matters: **every pattern is matched against the raw message,
+ * and escaping happens only when the answer is emitted.** The previous version
+ * escaped first and matched second, which quietly wrecked messages — the
+ * default issue rule is `#(\d+)`, an apostrophe escapes to `'`, and so
+ * "Monaco's" was rendered as a literal `'s` with `#39` styled as an issue
+ * link. Anything that matches digits, `amp`, `quot` or `lt` would do the same.
+ *
+ * Matches are collected as spans over the raw text and the first claim on a
+ * range wins, in the order URL → issue rule → bare hash. URLs go first so that
+ * a `#123` or a hex-looking segment inside one cannot be linked separately and
+ * split the URL in half.
+ *
+ * The function is deliberately self-contained: it is injected into the webview
+ * by `toString()`, so it may not reference anything in this module's scope.
+ * That is also what lets it be tested here rather than by reading HTML back
+ * out of a string.
+ */
+
+export interface IssueLinkRule {
+  /** A JavaScript regular expression source. Applied with `g`. */
+  pattern: string;
+  /** Target URL with `$1`… replaced by the capture groups. Empty means "highlight, do not link". */
+  url?: string;
+}
+
+function formatCommitMessageImpl(message: string, rules: IssueLinkRule[]): string {
+  const esc = (value: string): string =>
+    String(value == null ? "" : value)
+      .replace(/&/g, "&")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#39;");
+
+  const text = String(message == null ? "" : message);
+  const spans: { start: number; end: number; html: string }[] = [];
+
+  // The overlap test is linear in the spans already collected, so collecting
+  // them is quadratic — and the bare-hash rule matches once per hex-looking
+  // *word*, which a commit body can be made entirely of. Past this many links
+  // the message is not one anybody is reading anyway, and the rest of it is
+  // still rendered, just without link decoration. 500 caps the comparisons at
+  // ~125k rather than at whatever a cloned repository felt like.
+  // The literal is inline because this function is injected by `toString()`
+  // and cannot reach a constant in this module's scope.
+  const add = (start: number, end: number, html: string): void => {
+    if (end <= start || spans.length >= 500) return;
+    for (const span of spans) if (start < span.end && end > span.start) return;
+    spans.push({ start, end, html });
+  };
+
+  // A URL is atomic: linking anything inside one would split it.
+  for (const match of text.matchAll(/https?:\/\/[^\s<]+/g)) {
+    const url = match[0];
+    add(
+      match.index,
+      match.index + url.length,
+      '<a class="commit-link" href="' + esc(url) + '" target="_blank" rel="noreferrer">' + esc(url) + "</a>",
+    );
+  }
+
+  for (const rule of rules || []) {
+    // 200 is longer than any sane issue pattern and short enough to bound
+    // backtracking; the literal is inline because this function is injected by
+    // `toString()` and cannot reach a constant in this module's scope.
+    if (!rule || !rule.pattern || rule.pattern.length > 200) continue;
+    let re: RegExp;
+    try {
+      re = new RegExp(rule.pattern, "g");
+    } catch {
+      continue; // an invalid pattern is the user's typo, not a reason to lose the message
+    }
+    for (const match of text.matchAll(re)) {
+      const found = match[0];
+      if (rule.url) {
+        let href = rule.url;
+        for (let group = 1; group < match.length; group++) {
+          const value = match[group];
+          if (typeof value === "string") href = href.split("$" + group).join(value);
+        }
+        add(
+          match.index,
+          match.index + found.length,
+          '<a class="commit-link" href="' + esc(href) + '" target="_blank" rel="noreferrer" title="'
+            + esc(href) + '">' + esc(found) + "</a>",
+        );
+      } else {
+        add(
+          match.index,
+          match.index + found.length,
+          '<span class="commit-link" title="' + esc(found) + '">' + esc(found) + "</span>",
+        );
+      }
+    }
+  }
+
+  // A bare hash in a message ("reverts 8abb115") is worth marking, but it is
+  // only ever a highlight: this view cannot know the hash is in this repository.
+  for (const match of text.matchAll(/\b[0-9a-f]{7,40}\b/g)) {
+    const hash = match[0];
+    add(
+      match.index,
+      match.index + hash.length,
+      '<span class="commit-link" title="' + esc(hash) + '">' + esc(hash) + "</span>",
+    );
+  }
+
+  spans.sort((a, b) => a.start - b.start);
+  let html = "";
+  let at = 0;
+  for (const span of spans) {
+    html += esc(text.slice(at, span.start)) + span.html;
+    at = span.end;
+  }
+  return html + esc(text.slice(at));
+}
+
+/** Exported for tests; the webview gets the same function through `COMMIT_MESSAGE_JS`. */
+export const formatCommitMessage = formatCommitMessageImpl;
+
+export interface CommitBodyBlock {
+  /** `prose` may be reflowed to the pane; `pre` keeps every break the author typed. */
+  kind: "prose" | "pre";
+  text: string;
+}
+
+/**
+ * Split a commit body into blocks, and say which ones are hard-wrapped prose.
+ *
+ * A commit body is wrapped at whatever width its author liked — 72 columns,
+ * usually — so rendering it verbatim in a pane of some other width gives a
+ * ragged half-filled column, and rendering it as flowing text destroys the
+ * lists and the aligned blocks. So each paragraph is judged on its own.
+ *
+ * The test for "this was wrapped, and the breaks are not meaningful" is that
+ * every line but the last comes close to the block's longest — a hand-written
+ * list has short lines throughout, wrapped prose does not. Anything opening
+ * with a bullet, a quote, a fence, a heading, a number, a table pipe or an
+ * indent is left alone, and so is any block whose longest line is too short to
+ * have been wrapped at all.
+ *
+ * Self-contained for the same reason as the formatter above: it is injected by
+ * `toString()`.
+ */
+function splitCommitBodyImpl(body: string): CommitBodyBlock[] {
+  const source = String(body == null ? "" : body).replace(/\r\n?/g, "\n");
+  const blocks: CommitBodyBlock[] = [];
+  const MIN_WRAP_WIDTH = 40;
+
+  for (const chunk of source.split(/\n[ \t]*\n+/)) {
+    if (!chunk.trim()) continue;
+    const lines = chunk.replace(/\s+$/, "").split("\n");
+    let widest = 0;
+    for (const line of lines) if (line.length > widest) widest = line.length;
+
+    const flowing = widest >= MIN_WRAP_WIDTH && lines.every((line, i) => {
+      if (!/^\S/.test(line)) return false;
+      if (/^([-*+>|#]|\d+[.)])/.test(line)) return false;
+      if (line.startsWith("```")) return false;
+      // Every line but the last has to look full, or the breaks meant something.
+      return i === lines.length - 1 || line.length * 3 >= widest * 2;
+    });
+
+    blocks.push(flowing
+      ? { kind: "prose", text: lines.map((line) => line.trim()).join(" ") }
+      : { kind: "pre", text: lines.join("\n") });
+  }
+  return blocks;
+}
+
+/** Exported for tests; the webview gets the same function through `COMMIT_MESSAGE_JS`. */
+export const splitCommitBody = splitCommitBodyImpl;
+
+/**
+ * The formatter, as source, for the webview script.
+ *
+ * `toString()` rather than a second copy in a template literal: one of the two
+ * would drift, and regex-heavy code written inside a template literal needs its
+ * backslashes doubled, which is its own bug factory.
+ */
+export const COMMIT_MESSAGE_JS = `
+const __formatCommitMessage = ${formatCommitMessageImpl.toString()};
+function formatCommitMessage(msg) {
+  return __formatCommitMessage(msg, (state.settings && state.settings.issueLinkingRules) || []);
+}
+const splitCommitBody = ${splitCommitBodyImpl.toString()};
+`;

package/packages/ext-git-graph/src/commit-request-generation.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Scrolling the graph fires one `requestCommits` per page, and each spawns two
+ * git processes with nothing to abort the previous pair. Pages are additive, so
+ * a late append is still wanted — the thing that must not land is an answer
+ * from before the list was thrown away and started again.
+ */
+import { describe, it, expect } from "bun:test";
+import {
+  beginCommitRequest,
+  isStaleCommitRequest,
+  type CommitRequestState,
+} from "./extension.ts";
+
+const fresh = (): CommitRequestState => ({ latest: 0, lastReset: 0 });
+
+describe("commit-window request generations", () => {
+  it("keeps a page that was asked for after the last reset", () => {
+    const state = fresh();
+    const first = beginCommitRequest(state, 0);
+    const second = beginCommitRequest(state, 300);
+
+    // Page two arrives after page one — the ordinary case, and both count.
+    expect(isStaleCommitRequest(state, first)).toBe(false);
+    expect(isStaleCommitRequest(state, second)).toBe(false);
+  });
+
+  it("drops a page that was in flight when the branch changed", () => {
+    const state = fresh();
+    beginCommitRequest(state, 0);
+    const pageTwo = beginCommitRequest(state, 300);
+    // Switching branch sends skip 0, which replaces the list rather than
+    // appending to it. Page two of the old branch must not be appended to page
+    // one of the new one.
+    const newBranch = beginCommitRequest(state, 0);
+
+    expect(isStaleCommitRequest(state, pageTwo)).toBe(true);
+    expect(isStaleCommitRequest(state, newBranch)).toBe(false);
+  });
+
+  it("drops everything older than the newest reset, not just the one before it", () => {
+    const state = fresh();
+    const a = beginCommitRequest(state, 0);
+    const b = beginCommitRequest(state, 300);
+    const c = beginCommitRequest(state, 600);
+    beginCommitRequest(state, 0);
+
+    for (const generation of [a, b, c]) expect(isStaleCommitRequest(state, generation)).toBe(true);
+  });
+
+  it("treats a refresh as a reset even when nothing else changed", () => {
+    const state = fresh();
+    const before = beginCommitRequest(state, 0);
+    beginCommitRequest(state, 0);
+
+    expect(isStaleCommitRequest(state, before)).toBe(true);
+  });
+});

package/packages/ext-git-graph/src/compare-view.ts

@@ -8,7 +8,7 @@ import { assertSafeFilePaths, assertValidRef, spawnGit } from "./git-exec.ts";
 import { openPanel } from "./panel-registry.ts";
 import { registerViewCommand } from "./register-view-command.ts";
 import { takePendingTarget } from "./panel-nav.ts";
-import { resolveProjectName } from "./ppm-api.ts";
+import { resolveFileTab } from "./ppm-api.ts";
 import { FILE_HISTORY_FORMAT, parseFileHistory } from "./file-history-parser.ts";
 import type { CompareMode } from "./compare-args.ts";
 import { buildRangeSpec, parseAheadBehind, parseNumstatZ, parseRefList } from "./compare-args.ts";
@@ -79,10 +79,9 @@ export function openCompareView(
             const ref1 = assertValidRef(msg.ref1, "ref1");
             const ref2 = assertValidRef(msg.ref2, "ref2");
             const fileName = filePath.split(/[\\/]/).pop() || filePath;
-            const projectName = await resolveProjectName(projectPath);
-            await vscode.window.openTab("git-diff", `${fileName} (${ref1}→${ref2})`, projectName, {
-              projectName,
-              filePath,
+            const target = await resolveFileTab(projectPath, filePath);
+            await vscode.window.openTab("git-diff", `${fileName} (${ref1}→${ref2})`, target.projectName, {
+              ...target,
               ref1,
               ref2,
             });