Files
dbx/apps/desktop/src/components/diff/DiffHunkBuilder.ts
T

536 lines
16 KiB
TypeScript

import { diffLines, type Change } from "diff";
export type HunkType = "equal" | "delete" | "insert" | "modify";
export interface DiffLine {
type: HunkType;
content: string;
lineNumber: number | null;
isPadding: boolean;
comparisonContent?: string;
}
export interface DiffHunk {
id: string;
type: HunkType;
leftLines: DiffLine[];
rightLines: DiffLine[];
// Measured pixel positions after rendering
leftTop: number;
leftBottom: number;
rightTop: number;
rightBottom: number;
}
const SIMILARITY_THRESHOLD = 0.3;
const ALIGN_WINDOW = 3;
const MAX_GLOBAL_ALIGNMENT_CELLS = 10_000;
const ALIGN_DELETE = 1;
const ALIGN_INSERT = 2;
const ALIGN_MODIFY = 3;
const SQL_LINE_KEYWORDS = new Set([
"add",
"alter",
"as",
"begin",
"check",
"cluster",
"comment",
"constraint",
"create",
"delete",
"distributed",
"drop",
"else",
"end",
"engine",
"foreign",
"from",
"group",
"having",
"if",
"index",
"insert",
"join",
"key",
"on",
"order",
"partition",
"primary",
"references",
"return",
"returns",
"select",
"set",
"settings",
"tablespace",
"then",
"union",
"unique",
"update",
"using",
"values",
"when",
"where",
"with",
]);
function splitLines(value: string): string[] {
const lines = value.split("\n");
if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
return lines;
}
function buildLines(lines: string[], type: HunkType, startLineNum: number): DiffLine[] {
return lines.map((content, idx) => ({
type,
content,
lineNumber: startLineNum + idx,
isPadding: false,
}));
}
function buildPaddingLines(count: number): DiffLine[] {
return Array.from({ length: count }, () => ({
type: "equal" as HunkType,
content: "",
lineNumber: null,
isPadding: true,
}));
}
function normalizeDdl(ddl: string): string {
return ddl
.replace(/\r\n/g, "\n")
.replace(/\r/g, "\n")
.split("\n")
.map((line) => line.replace(/[ \t]+$/g, ""))
.join("\n");
}
function collectSameKindChanges(changes: Change[], startIdx: number, kind: "added" | "removed"): [string[], number] {
const parts: string[] = [];
let i = startIdx;
while (i < changes.length && changes[i][kind]) {
parts.push(changes[i].value);
i++;
}
return [parts, i];
}
function levenshteinDistance(a: string, b: string): number {
let previous = Array.from({ length: a.length + 1 }, (_, index) => index);
for (let i = 1; i <= b.length; i++) {
const current = [i];
for (let j = 1; j <= a.length; j++) {
current[j] = b.charAt(i - 1) === a.charAt(j - 1) ? previous[j - 1] : Math.min(previous[j - 1] + 1, current[j - 1] + 1, previous[j] + 1);
}
previous = current;
}
return previous[a.length];
}
function computeSimilarity(a: string, b: string): number {
if (a === b) return 1;
const longer = a.length > b.length ? a : b;
if (longer.length === 0) return 1;
const distance = levenshteinDistance(a, b);
return (longer.length - distance) / longer.length;
}
type AlignedItem = { type: "modify"; left: string; right: string } | { type: "delete"; left: string } | { type: "insert"; right: string };
type SqlIdentifier = {
value: string;
rest: string;
quoted: boolean;
};
function readSqlIdentifier(value: string): SqlIdentifier | null {
const input = value.trimStart();
const opening = input[0];
const closing = opening === "[" ? "]" : opening;
if (opening === "`" || opening === '"' || opening === "[") {
let identifier = "";
for (let i = 1; i < input.length; i++) {
if (input[i] !== closing) {
identifier += input[i];
continue;
}
if (input[i + 1] === closing) {
identifier += closing;
i++;
continue;
}
return { value: identifier, rest: input.slice(i + 1), quoted: true };
}
return null;
}
const match = input.match(/^([A-Za-z_][A-Za-z0-9_$#@]*)(.*)$/s);
if (!match) return null;
return { value: match[1], rest: match[2], quoted: false };
}
function readIdentifierAfterKeyword(line: string, keyword: RegExp): string | null {
const match = line.trimStart().match(keyword);
if (!match) return null;
return readSqlIdentifier(line.trimStart().slice(match[0].length))?.value ?? null;
}
function ddlLineIdentity(line: string): string | null {
const trimmed = line.trimStart();
const constraint = readIdentifierAfterKeyword(trimmed, /^CONSTRAINT\s+/i);
if (constraint !== null) return `constraint:${constraint}`;
const index = readIdentifierAfterKeyword(trimmed, /^(?:(?:UNIQUE|FULLTEXT|SPATIAL)\s+)?(?:KEY|INDEX)\s+/i);
if (index !== null) return `index:${index}`;
const createdIndex = readIdentifierAfterKeyword(trimmed, /^CREATE\s+(?:(?:UNIQUE|FULLTEXT|SPATIAL)\s+)?INDEX\s+/i);
if (createdIndex !== null) return `index:${createdIndex}`;
if (/^PRIMARY\s+KEY\b/i.test(trimmed)) return "constraint:primary-key";
const identifier = readSqlIdentifier(trimmed);
if (!identifier || !/^\s+/.test(identifier.rest)) return null;
const normalizedIdentifier = identifier.quoted ? identifier.value : identifier.value.toLowerCase();
if (!identifier.quoted && SQL_LINE_KEYWORDS.has(normalizedIdentifier)) return `keyword:${normalizedIdentifier}`;
return `column:${normalizedIdentifier}`;
}
function isNamedDdlIdentity(identity: string | null): identity is string {
return identity !== null && (identity.startsWith("column:") || identity.startsWith("constraint:") || identity.startsWith("index:"));
}
function comparableDdlLine(line: string): string {
return line.trim().replace(/,\s*$/, "");
}
function linePairSimilarity(left: string, right: string, leftIdentity = ddlLineIdentity(left), rightIdentity = ddlLineIdentity(right)): number | null {
if (leftIdentity !== null || rightIdentity !== null) {
if (leftIdentity === null || rightIdentity === null || leftIdentity !== rightIdentity) return null;
}
const similarity = computeSimilarity(left, right);
return similarity >= SIMILARITY_THRESHOLD ? similarity : null;
}
function alignWithinWindow(removedLines: string[], addedLines: string[]): AlignedItem[] {
const result: AlignedItem[] = [];
let r = 0;
let a = 0;
while (r < removedLines.length && a < addedLines.length) {
let bestR = -1;
let bestA = -1;
let bestSimilarity = -1;
for (let ri = r; ri < Math.min(r + ALIGN_WINDOW, removedLines.length); ri++) {
for (let ai = a; ai < Math.min(a + ALIGN_WINDOW, addedLines.length); ai++) {
const similarity = linePairSimilarity(removedLines[ri], addedLines[ai]);
if (similarity !== null && similarity > bestSimilarity) {
bestSimilarity = similarity;
bestR = ri;
bestA = ai;
}
}
}
if (bestR < 0 || bestA < 0) {
result.push({ type: "delete", left: removedLines[r++] });
result.push({ type: "insert", right: addedLines[a++] });
continue;
}
while (r < bestR) result.push({ type: "delete", left: removedLines[r++] });
while (a < bestA) result.push({ type: "insert", right: addedLines[a++] });
result.push({ type: "modify", left: removedLines[r++], right: addedLines[a++] });
}
while (r < removedLines.length) result.push({ type: "delete", left: removedLines[r++] });
while (a < addedLines.length) result.push({ type: "insert", right: addedLines[a++] });
return result;
}
function buildGlobalAlignmentDirections(removedLines: string[], addedLines: string[], removedIdentities: Array<string | null>, addedIdentities: Array<string | null>): Uint8Array {
const removedCount = removedLines.length;
const addedCount = addedLines.length;
const directions = new Uint8Array(removedCount * addedCount);
let nextCosts = new Float64Array(addedCount + 1);
for (let a = addedCount - 1; a >= 0; a--) nextCosts[a] = nextCosts[a + 1] + 1;
for (let r = removedCount - 1; r >= 0; r--) {
const currentCosts = new Float64Array(addedCount + 1);
currentCosts[addedCount] = nextCosts[addedCount] + 1;
for (let a = addedCount - 1; a >= 0; a--) {
let bestCost = nextCosts[a] + 1;
let direction = ALIGN_DELETE;
const insertCost = currentCosts[a + 1] + 1;
if (insertCost < bestCost) {
bestCost = insertCost;
direction = ALIGN_INSERT;
}
const similarity = linePairSimilarity(removedLines[r], addedLines[a], removedIdentities[r], addedIdentities[a]);
if (similarity !== null) {
const modifyCost = nextCosts[a + 1] + (1 - similarity);
if (modifyCost <= bestCost) {
bestCost = modifyCost;
direction = ALIGN_MODIFY;
}
}
currentCosts[a] = bestCost;
directions[r * addedCount + a] = direction;
}
nextCosts = currentCosts;
}
return directions;
}
function alignLineByLine(removedLines: string[], addedLines: string[]): AlignedItem[] {
const removedCount = removedLines.length;
const addedCount = addedLines.length;
if (removedCount * addedCount > MAX_GLOBAL_ALIGNMENT_CELLS) return alignWithinWindow(removedLines, addedLines);
const removedIdentities = removedLines.map(ddlLineIdentity);
const addedIdentities = addedLines.map(ddlLineIdentity);
const directions = buildGlobalAlignmentDirections(removedLines, addedLines, removedIdentities, addedIdentities);
const result: AlignedItem[] = [];
let r = 0;
let a = 0;
while (r < removedLines.length || a < addedLines.length) {
if (r >= removedLines.length) {
result.push({ type: "insert", right: addedLines[a] });
a++;
} else if (a >= addedLines.length) {
result.push({ type: "delete", left: removedLines[r] });
r++;
} else {
const direction = directions[r * addedCount + a];
if (direction === ALIGN_MODIFY) {
result.push({ type: "modify", left: removedLines[r], right: addedLines[a] });
r++;
a++;
} else if (direction === ALIGN_INSERT) {
result.push({ type: "insert", right: addedLines[a] });
a++;
} else {
result.push({ type: "delete", left: removedLines[r] });
r++;
}
}
}
return result;
}
type DiffLineReference = {
line: DiffLine;
identity: string;
};
function collectChangedLineReferences(hunks: DiffHunk[], side: "leftLines" | "rightLines", hunkType: "delete" | "insert"): DiffLineReference[] {
const references: DiffLineReference[] = [];
for (const hunk of hunks) {
if (hunk.type !== hunkType) continue;
for (const line of hunk[side]) {
if (line.isPadding || line.type !== hunkType) continue;
const identity = ddlLineIdentity(line.content);
if (isNamedDdlIdentity(identity)) references.push({ line, identity });
}
}
return references;
}
function reconcileMovedDdlLines(hunks: DiffHunk[]): void {
const deletedLines = collectChangedLineReferences(hunks, "leftLines", "delete");
const insertedByIdentity = new Map<string, DiffLineReference[]>();
for (const reference of collectChangedLineReferences(hunks, "rightLines", "insert")) {
const matches = insertedByIdentity.get(reference.identity) ?? [];
matches.push(reference);
insertedByIdentity.set(reference.identity, matches);
}
for (const deleted of deletedLines) {
const matches = insertedByIdentity.get(deleted.identity);
if (!matches?.length) continue;
const exactIndex = matches.findIndex((inserted) => comparableDdlLine(inserted.line.content) === comparableDdlLine(deleted.line.content));
const inserted = matches.splice(exactIndex >= 0 ? exactIndex : 0, 1)[0];
if (comparableDdlLine(deleted.line.content) === comparableDdlLine(inserted.line.content)) {
deleted.line.type = "equal";
inserted.line.type = "equal";
continue;
}
deleted.line.type = "modify";
inserted.line.type = "modify";
deleted.line.comparisonContent = inserted.line.content;
inserted.line.comparisonContent = deleted.line.content;
}
}
export function buildHunks(sourceDdl: string, targetDdl: string): DiffHunk[] {
const normalizedSource = normalizeDdl(sourceDdl);
const normalizedTarget = normalizeDdl(targetDdl);
const changes = diffLines(normalizedSource, normalizedTarget, { newlineIsToken: false });
const hunks: DiffHunk[] = [];
let leftLineNum = 1;
let rightLineNum = 1;
let hunkIdCounter = 0;
function nextId(): string {
return `hunk-${hunkIdCounter++}`;
}
let i = 0;
while (i < changes.length) {
const change = changes[i];
if (!change.added && !change.removed) {
const lines = splitLines(change.value);
hunks.push({
id: nextId(),
type: "equal",
leftLines: buildLines(lines, "equal", leftLineNum),
rightLines: buildLines(lines, "equal", rightLineNum),
leftTop: 0,
leftBottom: 0,
rightTop: 0,
rightBottom: 0,
});
leftLineNum += lines.length;
rightLineNum += lines.length;
i++;
continue;
}
if (change.removed) {
const [removedParts, afterRemoved] = collectSameKindChanges(changes, i, "removed");
const [addedParts, afterAdded] = collectSameKindChanges(changes, afterRemoved, "added");
const removedValue = removedParts.join("");
const removedLines = splitLines(removedValue);
if (addedParts.length > 0) {
const addedValue = addedParts.join("");
const addedLines = splitLines(addedValue);
const aligned = alignLineByLine(removedLines, addedLines);
for (const item of aligned) {
if (item.type === "modify") {
const maxLines = 1;
const leftReal = buildLines([item.left], "modify", leftLineNum);
const rightReal = buildLines([item.right], "modify", rightLineNum);
leftLineNum++;
rightLineNum++;
hunks.push({
id: nextId(),
type: "modify",
leftLines: padLines(leftReal, maxLines, "modify"),
rightLines: padLines(rightReal, maxLines, "modify"),
leftTop: 0,
leftBottom: 0,
rightTop: 0,
rightBottom: 0,
});
} else if (item.type === "delete") {
const leftReal = buildLines([item.left], "delete", leftLineNum);
leftLineNum++;
hunks.push({
id: nextId(),
type: "delete",
leftLines: leftReal,
rightLines: buildPaddingLines(1),
leftTop: 0,
leftBottom: 0,
rightTop: 0,
rightBottom: 0,
});
} else if (item.type === "insert") {
const rightReal = buildLines([item.right], "insert", rightLineNum);
rightLineNum++;
hunks.push({
id: nextId(),
type: "insert",
leftLines: buildPaddingLines(1),
rightLines: rightReal,
leftTop: 0,
leftBottom: 0,
rightTop: 0,
rightBottom: 0,
});
}
}
} else {
const maxLines = removedLines.length;
const leftReal = buildLines(removedLines, "delete", leftLineNum);
leftLineNum += removedLines.length;
hunks.push({
id: nextId(),
type: "delete",
leftLines: leftReal,
rightLines: buildPaddingLines(maxLines),
leftTop: 0,
leftBottom: 0,
rightTop: 0,
rightBottom: 0,
});
}
i = afterAdded;
continue;
}
if (change.added) {
const [addedParts, afterAdded] = collectSameKindChanges(changes, i, "added");
const addedValue = addedParts.join("");
const addedLines = splitLines(addedValue);
const rightReal = buildLines(addedLines, "insert", rightLineNum);
rightLineNum += addedLines.length;
hunks.push({
id: nextId(),
type: "insert",
leftLines: buildPaddingLines(addedLines.length),
rightLines: rightReal,
leftTop: 0,
leftBottom: 0,
rightTop: 0,
rightBottom: 0,
});
i = afterAdded;
continue;
}
}
reconcileMovedDdlLines(hunks);
return hunks;
}
function padLines(lines: DiffLine[], targetCount: number, type: HunkType): DiffLine[] {
if (lines.length >= targetCount) return lines;
const padding = Array.from({ length: targetCount - lines.length }, () => ({
type,
content: "",
lineNumber: null,
isPadding: true,
}));
return [...lines, ...padding];
}