Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

azureDevOpsDiff.ts

202 lines7.2 KB

1import { quoteGitPatchPath } from "@t3tools/shared/gitPatchPath";
2import { structuredPatch } from "diff";
3​
4import type { AzureDevOpsChangeEntry } from "./azureDevOpsPullRequestJson.ts";
5​
6/** Pin the iteration to prevent pushes from renumbering files during pagination. */
7export interface AzureDevOpsDiffCursor {
8 readonly iterationId: number;
9 readonly fileIndex: number;
11​
12const CURSOR_SEPARATOR = ":";
13​
14const CURSOR_COMPONENT = /^\d+$/;
15​
16export function formatAzureDevOpsDiffCursor(cursor: AzureDevOpsDiffCursor): string {
17 return `${cursor.iterationId}${CURSOR_SEPARATOR}${cursor.fileIndex}`;
19​
20export function parseAzureDevOpsDiffCursor(
21 raw: string | null | undefined,
22): AzureDevOpsDiffCursor | null {
23 if (raw === null || raw === undefined) return null;
24 const [iteration, file, ...rest] = raw.split(CURSOR_SEPARATOR);
25 if (rest.length > 0) return null;
26 if (iteration === undefined || file === undefined) return null;
27 if (!CURSOR_COMPONENT.test(iteration) || !CURSOR_COMPONENT.test(file)) return null;
28 const iterationId = Number(iteration);
29 const fileIndex = Number(file);
30 if (!Number.isSafeInteger(iterationId) || iterationId <= 0) return null;
31 if (!Number.isSafeInteger(fileIndex) || fileIndex < 0) return null;
32 return { iterationId, fileIndex };
34​
35export interface AzureDevOpsFileTexts {
36 readonly oldContents: string;
37 readonly newContents: string;
38 readonly binary: boolean;
40​
41export interface AzureDevOpsFilePatch {
42 readonly section: string;
43 readonly truncated: boolean;
44 readonly abandoned: boolean;
45 readonly edits: number;
47​
48/** Azure returns whole files; oversized files incur both reads before diffing. */
49const MAX_FILE_BYTES = 512 * 1024;
50​
51const PATCH_CONTEXT_LINES = 3;
52​
53/** Edit distance bounds quadratic work independently of machine speed. */
54export const MAX_FILE_DIFF_EDITS = 2_000;
55​
56const MAX_FILE_DIFF_MILLIS = 2_000;
57​
58export const MAX_DIFF_SLICE_EDITS = 6_000;
59​
60export const MAX_DIFF_SLICE_BYTES = 256 * 1024;
61​
62/** Header-only entries can evade the byte and edit budgets. */
63export const MAX_DIFF_SLICE_FILES = 300;
64​
65const NO_NEWLINE_MARKER = "\\ No newline at end of file";
66​
67function contentLines(contents: string): ReadonlyArray<string> {
68 if (contents === "") return [];
69 const lines = contents.split("\n");
70 if (lines.at(-1) === "") lines.pop();
71 return lines;
73​
74function isBinary(contents: string): boolean {
75 return contents.includes("\u0000");
77​
78export const byteLength = (contents: string) => Buffer.byteLength(contents, "utf8");
79​
80/** Git anchors empty ranges at the preceding line, which may be zero. */
81function hunkRange(start: number, lines: number): string {
82 if (lines === 0) return `${start - 1},0`;
83 return lines === 1 ? String(start) : `${start},${lines}`;
85​
86/** Azure omits modes. Quote prefixed paths to preserve tabs/newlines. */
87function patchHeader(change: AzureDevOpsChangeEntry): string {
88 const oldSide = quoteGitPatchPath(`a/${change.oldPath}`);
89 const newSide = quoteGitPatchPath(`b/${change.path}`);
90 const lines = [`diff --git ${oldSide} ${newSide}`];
91 if (change.changeKind === "new") lines.push("new file mode 100644");
92 if (change.changeKind === "deleted") lines.push("deleted file mode 100644");
93 if (change.changeKind === "rename-pure" || change.changeKind === "rename-changed") {
94 // Pierre needs this header to keep the rename.
95 lines.push(
96 `similarity index ${change.changeKind === "rename-pure" ? 100 : 0}%`,
97 `rename from ${quoteGitPatchPath(change.oldPath)}`,
98 `rename to ${quoteGitPatchPath(change.path)}`,
99 );
100 }
101 lines.push(
102 `--- ${change.changeKind === "new" ? "/dev/null" : oldSide}`,
103 `+++ ${change.changeKind === "deleted" ? "/dev/null" : newSide}`,
104 );
105 return lines.join("\n");
107​
108function replacementSection(header: string, texts: AzureDevOpsFileTexts): string {
109 const oldLines = contentLines(texts.oldContents);
110 const newLines = contentLines(texts.newContents);
111 const noNewline = (contents: string, lines: ReadonlyArray<string>) =>
112 lines.length > 0 && !contents.endsWith("\n") ? [NO_NEWLINE_MARKER] : [];
113 return [
114 header,
115 `@@ -${hunkRange(1, oldLines.length)} +${hunkRange(1, newLines.length)} @@`,
116 ...oldLines.map((line) => `-${line}`),
117 ...noNewline(texts.oldContents, oldLines),
118 ...newLines.map((line) => `+${line}`),
119 ...noNewline(texts.newContents, newLines),
120 "",
121 ].join("\n");
123​
124export function azureDevOpsFilePatch(input: {
125 readonly change: AzureDevOpsChangeEntry;
126 readonly texts: AzureDevOpsFileTexts;
127}): AzureDevOpsFilePatch {
128 const header = patchHeader(input.change);
129 const { oldContents, newContents } = input.texts;
130​
131 if (input.texts.binary || isBinary(oldContents) || isBinary(newContents)) {
132 const oldSide = quoteGitPatchPath(`a/${input.change.oldPath}`);
133 const newSide = quoteGitPatchPath(`b/${input.change.path}`);
134 const binary = `Binary files ${oldSide} and ${newSide} differ`;
135 return { section: `${header}\n${binary}\n`, truncated: true, abandoned: false, edits: 0 };
136 }
137 if (byteLength(oldContents) > MAX_FILE_BYTES || byteLength(newContents) > MAX_FILE_BYTES) {
138 return { section: `${header}\n`, truncated: true, abandoned: false, edits: 0 };
139 }
140​
141 const created = oldContents === "" && newContents !== "";
142 const deleted = newContents === "" && oldContents !== "";
143 if (created || deleted) {
144 const contents = created ? newContents : oldContents;
145 const lines = contentLines(contents);
146 // Include per-line markers in the byte budget.
147 if (byteLength(contents) + lines.length > MAX_FILE_BYTES) {
148 return { section: `${header}\n`, truncated: true, abandoned: false, edits: lines.length };
149 }
150 const section = replacementSection(header, input.texts);
151 if (byteLength(section) > MAX_FILE_BYTES) {
152 return { section: `${header}\n`, truncated: true, abandoned: false, edits: lines.length };
153 }
154 return { section, truncated: false, abandoned: false, edits: lines.length };
155 }
156​
157 const patch = structuredPatch(
158 `a/${input.change.oldPath}`,
159 `b/${input.change.path}`,
160 oldContents,
161 newContents,
162 undefined,
163 undefined,
164 {
165 context: PATCH_CONTEXT_LINES,
166 maxEditLength: MAX_FILE_DIFF_EDITS,
167 timeout: MAX_FILE_DIFF_MILLIS,
168 },
169 );
170 // A full replacement could bury a small change that hit the edit limit.
171 if (patch === undefined) {
172 return {
173 section: `${header}\n`,
174 truncated: true,
175 abandoned: true,
176 edits: MAX_FILE_DIFF_EDITS,
177 };
178 }
179​
180 let edits = 0;
181 const hunks = patch.hunks.map((hunk) => {
182 for (const line of hunk.lines) {
183 if (line.startsWith("+") || line.startsWith("-")) edits += 1;
184 }
185 return [
186 `@@ -${hunkRange(hunk.oldStart, hunk.oldLines)} +${hunkRange(hunk.newStart, hunk.newLines)} @@`,
187 ...hunk.lines,
188 ].join("\n");
189 });
190 const section = hunks.length === 0 ? `${header}\n` : `${header}\n${hunks.join("\n")}\n`;
191 // Long lines can exceed the byte budget even within the edit budget.
192 if (byteLength(section) > MAX_FILE_BYTES) {
193 return { section: `${header}\n`, truncated: true, abandoned: false, edits };
194 }
195 return { section, truncated: false, abandoned: false, edits };
197​
198export function azureDevOpsUnreadableFilePatch(
199 change: AzureDevOpsChangeEntry,
200): AzureDevOpsFilePatch {
201 return { section: `${patchHeader(change)}\n`, truncated: true, abandoned: false, edits: 0 };