components/draft-compare/draft-compare-patch.ts

Functions

Imports

It imports components/draft-compare/draft-compare-render.ts. Imported by components/draft-compare/draft-compare.ts.

Source

1// Draft compare's unified-diff view: parsePatch and renderPatch (draft-compare.ts).
2
3import { esc, plural, sr } from "./draft-compare-render.ts";
4
5// ---------------------------------------------------------------------------------------
6// The patch mode: a unified git patch shown as it is, by line
7// ---------------------------------------------------------------------------------------
8
9export type PatchOp = "same" | "ins" | "del";
10
11export interface PatchLine {
12  op: PatchOp;
13  text: string;
14  // The line's number in the old and new file; null on the side it is not in.
15  oldNo: number | null;
16  newNo: number | null;
17  // A "\ No newline at end of file" note follows this line.
18  noEol?: boolean;
19}
20
21export interface PatchHunk {
22  header: string;
23  context: string;
24  lines: PatchLine[];
25}
26
27export interface PatchFile {
28  oldPath: string;
29  newPath: string;
30  hunks: PatchHunk[];
31  // "Binary file changed" and the like, in words, when there is no text to show.
32  note?: string;
33  added: number;
34  removed: number;
35}
36
37const HUNK = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@ ?(.*)$/;
38const stripPrefix = (p: string) => (p === "/dev/null" ? p : p.replace(/^[ab]\//, ""));
39
40// Reads a unified patch (git diff, git show, git format-patch) into files, hunks and lines.
41// Pure and forgiving: text it does not understand (commit headers, index lines) is skipped.
42export function parsePatch(patch: string): PatchFile[] {
43  const files: PatchFile[] = [];
44  let file: PatchFile | undefined;
45  let hunk: PatchHunk | undefined;
46  let oldNo = 0;
47  let newNo = 0;
48  const open = (oldPath = "", newPath = ""): PatchFile => {
49    const f: PatchFile = { oldPath, newPath, hunks: [], added: 0, removed: 0 };
50    files.push(f);
51    file = f;
52    hunk = undefined;
53    return f;
54  };
55  for (const raw of patch.replace(/\r\n?/g, "\n").split("\n")) {
56    const git = /^diff --git a\/(.+?) b\/(.+)$/.exec(raw);
57    if (git) {
58      open(git[1] ?? "", git[2] ?? "");
59      continue;
60    }
61    if (!hunk && raw.startsWith("--- ")) {
62      const f = file && !file.hunks.length && !file.note ? file : open();
63      f.oldPath = stripPrefix(raw.slice(4).split("\t")[0] ?? "");
64      continue;
65    }
66    if (!hunk && raw.startsWith("+++ ") && file) {
67      file.newPath = stripPrefix(raw.slice(4).split("\t")[0] ?? "");
68      continue;
69    }
70    const h = HUNK.exec(raw);
71    if (h) {
72      const f = file ?? open();
73      oldNo = Number(h[1]);
74      newNo = Number(h[2]);
75      hunk = { header: raw, context: h[3] ?? "", lines: [] };
76      f.hunks.push(hunk);
77      continue;
78    }
79    if (!file) continue;
80    if (!hunk) {
81      if (/^(Binary files|GIT binary patch)/.test(raw)) file.note = "Binary file changed; no text to show.";
82      else if (/^rename from /.test(raw)) file.note = "Renamed.";
83      continue;
84    }
85    if (raw.startsWith("\\")) {
86      const last = hunk.lines[hunk.lines.length - 1];
87      if (last) last.noEol = true;
88    } else if (raw.startsWith("+")) {
89      hunk.lines.push({ op: "ins", text: raw.slice(1), oldNo: null, newNo: newNo++ });
90      file.added++;
91    } else if (raw.startsWith("-")) {
92      hunk.lines.push({ op: "del", text: raw.slice(1), oldNo: oldNo++, newNo: null });
93      file.removed++;
94    } else if (raw.startsWith(" ")) {
95      hunk.lines.push({ op: "same", text: raw.slice(1), oldNo: oldNo++, newNo: newNo++ });
96    }
97  }
98  return files.filter((f) => f.hunks.length || f.note);
99}
100
101export interface PatchOptions {
102  // The id of the region; give each patch on a page its own. Default "patch".
103  id?: string;
104  // What the patch is of: "Draft 4 against Draft 3". Names the region.
105  title?: string;
106}
107
108export interface PatchCounts {
109  files: number;
110  added: number;
111  removed: number;
112}
113
114export function patchCounts(files: readonly PatchFile[]): PatchCounts {
115  return { files: files.length, added: files.reduce((n, f) => n + f.added, 0), removed: files.reduce((n, f) => n + f.removed, 0) };
116}
117
118export function patchCountsText(c: PatchCounts): string {
119  return `${plural(c.files, "file", "files")} changed, ${plural(c.added, "line", "lines")} added, ${c.removed} removed`;
120}
121
122const SIGN: Record<PatchOp, string> = { same: "", ins: "+", del: "−" };
123const SIGN_WORD: Record<PatchOp, string> = { same: "", ins: "added", del: "removed" };
124
125// A revision label, `id@v1` against `id@v2`: the same thing at two revisions, not a rename.
126// Returns the shared name and the two revisions, or null for any other pair of paths.
127const REVISION = /^(.+)@([^@/]+)$/;
128export function revisionPair(oldPath: string, newPath: string): { name: string; from: string; to: string } | null {
129  const a = REVISION.exec(oldPath);
130  const b = REVISION.exec(newPath);
131  if (!a || !b || a[1] !== b[1] || a[2] === b[2]) return null;
132  return { name: a[1] as string, from: a[2] as string, to: b[2] as string };
133}
134
135function patchPath(f: PatchFile): string {
136  if (f.oldPath === "/dev/null") return f.newPath;
137  if (f.newPath === "/dev/null") return f.oldPath;
138  const rev = revisionPair(f.oldPath, f.newPath);
139  if (rev) return rev.name;
140  return f.oldPath && f.newPath && f.oldPath !== f.newPath ? `${f.oldPath} → ${f.newPath}` : f.newPath || f.oldPath;
141}
142
143function patchLine(l: PatchLine): string {
144  const sign = l.op === "same" ? "" : `<span aria-hidden="true">${SIGN[l.op]}</span>${sr(SIGN_WORD[l.op])}`;
145  const eol = l.noEol ? `<span class="cap-patch-eol">${sr("no newline at end of file")}<span aria-hidden="true">∅</span></span>` : "";
146  return `<tr class="cap-patch-line" data-op="${l.op}"><td class="cap-patch-no">${l.oldNo ?? ""}</td><td class="cap-patch-no">${l.newNo ?? ""}</td><td class="cap-patch-sign">${sign}</td><td class="cap-patch-code"><code>${esc(l.text)}</code>${eol}</td></tr>`;
147}
148
149function patchFile(f: PatchFile, id: string, n: number): string {
150  const path = patchPath(f);
151  const heading = `${id}-file-${n}`;
152  const rev = revisionPair(f.oldPath, f.newPath);
153  const kind = f.oldPath === "/dev/null" ? "new file" : f.newPath === "/dev/null" ? "deleted" : rev ? `${rev.from} to ${rev.to}` : "";
154  const counts = `${f.added} added, ${f.removed} removed`;
155  const body = f.hunks
156    .map((h) => `<tbody class="cap-patch-hunk"><tr class="cap-patch-hunk-head"><th scope="rowgroup" colspan="4"><code>${esc(h.header)}</code></th></tr>${h.lines.map(patchLine).join("")}</tbody>`)
157    .join("");
158  const table = f.hunks.length
159    ? `<div class="cap-patch-scroll" role="region" aria-labelledby="${heading}" tabindex="0"><table class="cap-patch-table"><caption class="cap-sr-only">${esc(path)}, ${counts}</caption>${body}</table></div>`
160    : "";
161  return `<section class="cap-patch-file" aria-labelledby="${heading}"><h3 class="cap-patch-path" id="${heading}"><code>${esc(path)}</code>${kind ? ` <span class="cap-patch-kind">${kind}</span>` : ""}<span class="cap-patch-file-counts">${counts}</span></h3>${f.note ? `<p class="cap-patch-note">${esc(f.note)}</p>` : ""}${table}</section>`;
162}
163
164// A unified git patch as it is: one file at a time, one row per line, the old and new line
165// numbers beside it and a literal plus or minus opening each changed line, so a change is
166// never only a tint. Use it where the line is the unit (code, a configuration file, a commit);
167// for prose, renderCompare compares by word.
168export function renderPatch(patch: string, options: PatchOptions = {}): string {
169  const id = options.id ?? "patch";
170  const files = parsePatch(patch);
171  const name = options.title ? `Patch: ${options.title}` : "Patch";
172  const attrs = `class="cap-compare cap-patch" data-mode="patch" id="${id}" aria-label="${esc(name)}"`;
173  if (!files.length) return `<section ${attrs}><p class="cap-compare-none" role="status"><strong>No changes.</strong> This patch has no lines to show.</p></section>`;
174  const key = `<ul class="cap-compare-key" aria-label="Key to the marks"><li><span class="cap-compare-key-mark" data-kind="ins">Added</span> a plus opens the line</li><li><span class="cap-compare-key-mark" data-kind="del">Removed</span> a minus opens the line</li></ul>`;
175  return `<section ${attrs}><div class="cap-compare-bar"><div class="cap-compare-legend">${key}<p class="cap-compare-counts">${esc(patchCountsText(patchCounts(files)))}</p></div></div>${files.map((f, i) => patchFile(f, id, i + 1)).join("")}</section>`;
176}