mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-19 11:26:02 +00:00
fix(cli): history show --diff works without git on PATH (#6475)
* fix(cli): history show --diff works without git on PATH * fix(cli): unifiedDiff passes lint and fallow: blocks, shared direction rule, split test * refactor(cli): split the diff walk and its backtrack into small steps
This commit is contained in:
@@ -0,0 +1,114 @@
|
||||
const CONTEXT = 3;
|
||||
// Past this many changed lines Myers' trace grows quadratically; the middle is then shown as one replace.
|
||||
const MAX_EDIT_LINES = 4000;
|
||||
|
||||
type Op = { kind: " " | "-" | "+"; text: string };
|
||||
|
||||
/** Lines of `text` with a marker on a last line that has no newline, so "A" and "A\n" differ as in git. */
|
||||
function linesOf(text: string): string[] {
|
||||
if (text === "") return [];
|
||||
const lines = text.split("\n");
|
||||
if (lines[lines.length - 1] === "") lines.pop();
|
||||
else lines[lines.length - 1] += "\0";
|
||||
return lines;
|
||||
}
|
||||
|
||||
const display = (line: string): string =>
|
||||
line.endsWith("\0") ? `${line.slice(0, -1)}\n\\ No newline at end of file` : line;
|
||||
|
||||
/** Edit script turning `a` into `b` (Myers), after the shared head and tail are set aside. */
|
||||
function editScript(a: string[], b: string[]): Op[] {
|
||||
let head = 0;
|
||||
while (head < a.length && head < b.length && a[head] === b[head]) head++;
|
||||
let tail = 0;
|
||||
while (
|
||||
tail < a.length - head &&
|
||||
tail < b.length - head &&
|
||||
a[a.length - 1 - tail] === b[b.length - 1 - tail]
|
||||
)
|
||||
tail++;
|
||||
const x = a.slice(head, a.length - tail);
|
||||
const y = b.slice(head, b.length - tail);
|
||||
const same = (lines: string[]): Op[] => lines.map((text) => ({ kind: " ", text }));
|
||||
return [...same(a.slice(0, head)), ...middle(x, y), ...same(a.slice(a.length - tail))];
|
||||
}
|
||||
|
||||
const replaceAll = (a: string[], b: string[]): Op[] => [
|
||||
...a.map((text): Op => ({ kind: "-", text })),
|
||||
...b.map((text): Op => ({ kind: "+", text })),
|
||||
];
|
||||
|
||||
/** Whether diagonal `k` of round `d` is reached by moving down (an insert) from the one before it. */
|
||||
const movesDown = (v: Int32Array, offset: number, k: number, d: number) =>
|
||||
k === -d || (k !== d && v[offset + k - 1]! < v[offset + k + 1]!);
|
||||
|
||||
/** How far along diagonal `k` of round `d` the walk gets in `a`, taking every shared line it meets. */
|
||||
function reach(v: Int32Array, offset: number, k: number, d: number, a: string[], b: string[]) {
|
||||
let x = movesDown(v, offset, k, d) ? v[offset + k + 1]! : v[offset + k - 1]! + 1;
|
||||
while (x < a.length && x - k < b.length && a[x] === b[x - k]) x++;
|
||||
return x;
|
||||
}
|
||||
|
||||
function middle(a: string[], b: string[]): Op[] {
|
||||
if (a.length + b.length > MAX_EDIT_LINES) return replaceAll(a, b);
|
||||
const offset = a.length + b.length;
|
||||
const v = new Int32Array(2 * offset + 2);
|
||||
const trace: Int32Array[] = [];
|
||||
for (let d = 0; ; d++) {
|
||||
trace.push(v.slice());
|
||||
for (let k = -d; k <= d; k += 2) {
|
||||
const x = reach(v, offset, k, d, a, b);
|
||||
v[offset + k] = x;
|
||||
if (x >= a.length && x - k >= b.length) return backtrack(trace, a, b, offset, d);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Pushes the shared lines of `a` from index `x` back down to `to`, and returns `to`. */
|
||||
function slideBack(ops: Op[], a: string[], x: number, to: number) {
|
||||
for (; x > to; x--) ops.push({ kind: " ", text: a[x - 1]! });
|
||||
return to;
|
||||
}
|
||||
|
||||
function backtrack(trace: Int32Array[], a: string[], b: string[], offset: number, last: number) {
|
||||
const ops: Op[] = [];
|
||||
let x = a.length;
|
||||
let y = b.length;
|
||||
for (let d = last; d > 0; d--) {
|
||||
const k = x - y;
|
||||
const down = movesDown(trace[d]!, offset, k, d);
|
||||
const prevX = trace[d]![offset + (down ? k + 1 : k - 1)]!;
|
||||
x = slideBack(ops, a, x, down ? prevX : prevX + 1);
|
||||
y = x - k;
|
||||
if (down) ops.push({ kind: "+", text: b[--y]! });
|
||||
else ops.push({ kind: "-", text: a[--x]! });
|
||||
}
|
||||
slideBack(ops, a, x, 0);
|
||||
return ops.reverse();
|
||||
}
|
||||
|
||||
/** A git-style unified diff of one text file, `after` empty for a deleted file and `before` empty for an added one. */
|
||||
export function unifiedDiff(path: string, before: string, after: string): string {
|
||||
const ops = editScript(linesOf(before), linesOf(after));
|
||||
const changed = ops.flatMap((op, index) => (op.kind === " " ? [] : [index]));
|
||||
if (changed.length === 0) return "";
|
||||
const out = [`diff --git a/${path} b/${path}`, `--- a/${path}`, `+++ b/${path}`];
|
||||
let from = 0;
|
||||
while (from < changed.length) {
|
||||
let to = from;
|
||||
while (to + 1 < changed.length && changed[to + 1]! - changed[to]! <= 2 * CONTEXT + 1) to++;
|
||||
const start = Math.max(0, changed[from]! - CONTEXT);
|
||||
const end = Math.min(ops.length, changed[to]! + CONTEXT + 1);
|
||||
const hunk = ops.slice(start, end);
|
||||
const before0 = ops.slice(0, start).filter((op) => op.kind !== "+").length;
|
||||
const after0 = ops.slice(0, start).filter((op) => op.kind !== "-").length;
|
||||
const oldLen = hunk.filter((op) => op.kind !== "+").length;
|
||||
const newLen = hunk.filter((op) => op.kind !== "-").length;
|
||||
const range = (first: number, length: number) =>
|
||||
length === 1 ? `${first + 1}` : `${length === 0 ? first : first + 1},${length}`;
|
||||
out.push(`@@ -${range(before0, oldLen)} +${range(after0, newLen)} @@`);
|
||||
for (const op of hunk) out.push(`${op.kind}${display(op.text)}`);
|
||||
from = to + 1;
|
||||
}
|
||||
return out.join("\n");
|
||||
}
|
||||
Reference in New Issue
Block a user