@adecore/merge 0.22.1 → 0.23.1

package/src/patch-of.ts

@@ -0,0 +1,128 @@
+import { diffChanges, type Change } from './diff.ts';
+import type { Hunk, ParsedPatch, PatchLine } from './patch-parser.ts';
+import { shapeOf } from './text.ts';
+
+function fileLines(text: string): string[] {
+    if (text === '') {
+        return [];
+    }
+    const lines = text.split('\n');
+    if (text.endsWith('\n')) {
+        lines.pop();
+    }
+    return lines;
+}
+
+function keysOf(lines: readonly string[], finalNewline: boolean): string[] {
+    return lines.map((line, index) => `${index === lines.length - 1 && !finalNewline ? 'unterminated:' : 'terminated:'}${line}`);
+}
+
+function alignChanges(changes: Change[], old: readonly string[], fresh: readonly string[]): void {
+    for (const [index, change] of changes.entries()) {
+        const previous = changes[index - 1];
+        const oldBound = previous?.baseEnd ?? 0;
+        const newBound = previous?.otherEnd ?? 0;
+        const insert = change.baseStart === change.baseEnd;
+        const remove = change.otherStart === change.otherEnd;
+        if (!insert && !remove) {
+            continue;
+        }
+        // Move a repeated blank from the end of an edit to its start, between adjacent functions.
+        while (change.baseStart > oldBound && change.otherStart > newBound) {
+            const tail = insert ? fresh[change.otherEnd - 1]! : old[change.baseEnd - 1]!;
+            if (tail.slice(tail.indexOf(':') + 1).trim() !== '' || old[change.baseStart - 1] !== tail || fresh[change.otherStart - 1] !== tail) {
+                break;
+            }
+            change.baseStart -= 1;
+            change.baseEnd -= 1;
+            change.otherStart -= 1;
+            change.otherEnd -= 1;
+        }
+    }
+}
+
+function rangeText(start: number, count: number): string {
+    return `${start + (count === 0 ? 0 : 1)},${count}`;
+}
+
+export function patchOf(oldText: string, newText: string, context = 3, options?: { readonly maxWork?: number }): ParsedPatch {
+    if (!Number.isSafeInteger(context) || context < 0) {
+        throw new RangeError('Patch context must be a nonnegative safe integer.');
+    }
+    const maxWork = options?.maxWork;
+    if (maxWork !== undefined && (!Number.isSafeInteger(maxWork) || maxWork < 0)) {
+        throw new RangeError('Patch work budget must be a nonnegative safe integer.');
+    }
+    const old = fileLines(oldText);
+    const fresh = fileLines(newText);
+    const oldShape = shapeOf(oldText);
+    const newShape = shapeOf(newText);
+    const oldKeys = keysOf(old, oldShape.finalNewline);
+    const newKeys = keysOf(fresh, newShape.finalNewline);
+    const { changes, limited } = diffChanges(oldKeys, newKeys, maxWork);
+    alignChanges(changes, oldKeys, newKeys);
+    const hunks: Hunk[] = [];
+    let group: Change[] = [];
+    const finish = (): void => {
+        if (group.length === 0) {
+            return;
+        }
+        const first = group[0]!;
+        const last = group.at(-1)!;
+        const before = Math.min(context, first.baseStart, first.otherStart);
+        const after = Math.min(context, old.length - last.baseEnd, fresh.length - last.otherEnd);
+        const oldStart = first.baseStart - before;
+        const newStart = first.otherStart - before;
+        const lines: PatchLine[] = [];
+        const line = (kind: PatchLine['kind'], at: number): void => {
+            const source = kind === 'insert' ? fresh : old;
+            const shape = kind === 'insert' ? newShape : oldShape;
+            lines.push({ kind, text: source[at]!, ...(at === source.length - 1 && !shape.finalNewline ? { noNewline: true as const } : {}) });
+        };
+        let oldAt = oldStart;
+        for (const change of group) {
+            for (; oldAt < change.baseStart; oldAt++) {
+                line('context', oldAt);
+            }
+            for (; oldAt < change.baseEnd; oldAt++) {
+                line('delete', oldAt);
+            }
+            for (let newAt = change.otherStart; newAt < change.otherEnd; newAt++) {
+                line('insert', newAt);
+            }
+        }
+        for (; oldAt < last.baseEnd + after; oldAt++) {
+            line('context', oldAt);
+        }
+        const coarse = limited || group.some((change) => change.baseEnd - change.baseStart + change.otherEnd - change.otherStart > 4000);
+        hunks.push({
+            oldStart,
+            newStart,
+            oldCount: last.baseEnd + after - oldStart,
+            newCount: last.otherEnd + after - newStart,
+            section: '',
+            lines,
+            ...(coarse ? { coarse: true as const } : {})
+        });
+        group = [];
+    };
+    for (const change of changes) {
+        const previous = group.at(-1);
+        if (previous !== undefined && change.baseStart - previous.baseEnd > 2 * context) {
+            finish();
+        }
+        group.push(change);
+    }
+    finish();
+    const parts: string[] = [];
+    for (const hunk of hunks) {
+        parts.push(`@@ -${rangeText(hunk.oldStart, hunk.oldCount)} +${rangeText(hunk.newStart, hunk.newCount)} @@`);
+        for (const line of hunk.lines) {
+            parts.push(`${line.kind === 'context' ? ' ' : line.kind === 'delete' ? '-' : '+'}${line.text}`);
+            if (line.noNewline) {
+                parts.push('\');
+            }
+        }
+    }
+    return { text: parts.length === 0 ? '' : `${parts.join('\n')}\n`, hunks, missing: { old: false, new: false }, partial: false };
+}

package/src/patch-parser.ts

@@ -0,0 +1,148 @@
+export interface PatchLine {
+    readonly kind: 'context' | 'delete' | 'insert';
+    readonly text: string;
+    readonly noNewline?: true;
+}
+
+export interface Hunk {
+    readonly oldStart: number;
+    readonly oldCount: number;
+    readonly newStart: number;
+    readonly newCount: number;
+    readonly section: string;
+    readonly coarse?: true;
+    readonly lines: readonly PatchLine[];
+}
+
+export interface ParsedPatch {
+    readonly text: string;
+    readonly hunks: readonly Hunk[];
+    readonly missing: { readonly old: boolean; readonly new: boolean };
+    readonly partial: boolean;
+}
+
+const HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?: ?(.*))?$/;
+
+/* The numbers of a hunk header as written: one-based starts, and a count that is one when omitted. */
+export interface HunkHeader {
+    readonly oldStart: number;
+    readonly oldCount: number;
+    readonly newStart: number;
+    readonly newCount: number;
+    readonly section: string;
+}
+
+/* Reads one `@@ -a,b +c,d @@ section` line without its line ending; undefined when it is not a hunk header. */
+export function parseHunkHeader(line: string): HunkHeader | undefined {
+    const match = HEADER.exec(line);
+    if (match === null) {
+        return undefined;
+    }
+    return {
+        oldStart: Number(match[1]),
+        oldCount: Number(match[2] ?? 1),
+        newStart: Number(match[3]),
+        newCount: Number(match[4] ?? 1),
+        section: match[5] ?? ''
+    };
+}
+
+export function parsePatch(patch: string): ParsedPatch {
+    const hunks: Hunk[] = [];
+    const lines = patch.split('\n');
+    let current: (Omit<Hunk, 'lines'> & { lines: PatchLine[] }) | undefined;
+    let oldCount = 0;
+    let newCount = 0;
+    let partial = false;
+    let oldEnded = false;
+    let newEnded = false;
+    const header: string[] = [];
+    const finish = (): void => {
+        if (current !== undefined && (oldCount !== current.oldCount || newCount !== current.newCount)) {
+            partial = true;
+        }
+        current = undefined;
+    };
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index]!;
+        const metadata = line.replace(/\r$/, '');
+        if (metadata.startsWith('@@')) {
+            finish();
+            const match = parseHunkHeader(metadata);
+            if (match === undefined) {
+                partial = true;
+                continue;
+            }
+            const oldLength = match.oldCount;
+            const newLength = match.newCount;
+            const oldStart = match.oldStart - (oldLength === 0 ? 0 : 1);
+            const newStart = match.newStart - (newLength === 0 ? 0 : 1);
+            if (
+                ![oldStart, newStart, oldLength, newLength, oldStart + oldLength, newStart + newLength].every(
+                    (value) => Number.isSafeInteger(value) && value >= 0
+                )
+            ) {
+                partial = true;
+                continue;
+            }
+            const previous = hunks.at(-1);
+            if (previous !== undefined && (oldStart < previous.oldStart + previous.oldCount || newStart < previous.newStart + previous.newCount)) {
+                partial = true;
+            }
+            current = { oldStart, oldCount: oldLength, newStart, newCount: newLength, section: match.section, lines: [] };
+            hunks.push(current);
+            oldCount = 0;
+            newCount = 0;
+            continue;
+        }
+        if (metadata.startsWith('diff --git ') && hunks.length > 0) {
+            finish();
+            partial = true;
+            break;
+        }
+        if (current === undefined) {
+            if (hunks.length === 0) {
+                header.push(metadata);
+            } else if (line !== '') {
+                partial = true;
+            }
+            continue;
+        }
+        if (metadata === '\') {
+            const previous = current.lines.at(-1);
+            if (previous === undefined || previous.noNewline) {
+                partial = true;
+            } else {
+                current.lines[current.lines.length - 1] = { ...previous, noNewline: true };
+                oldEnded ||= previous.kind !== 'insert';
+                newEnded ||= previous.kind !== 'delete';
+            }
+            continue;
+        }
+        // The last empty split field is the patch's terminator, not a source line.
+        if (line === '' && index === lines.length - 1) {
+            continue;
+        }
+        const kind = line.startsWith('-') ? 'delete' : line.startsWith('+') ? 'insert' : line.startsWith(' ') || line === '' ? 'context' : undefined;
+        if (kind === undefined) {
+            partial = true;
+            continue;
+        }
+        if (kind !== 'insert') {
+            partial ||= oldEnded;
+            oldCount += 1;
+        }
+        if (kind !== 'delete') {
+            partial ||= newEnded;
+            newCount += 1;
+        }
+        current.lines.push({ kind, text: line === '' ? '' : line.slice(1) });
+    }
+    finish();
+    return {
+        text: patch,
+        hunks,
+        missing: { old: header.some((line) => /^--- \/dev\/null(?:\t|$)/.test(line)), new: header.some((line) => /^\+\+\+ \/dev\/null(?:\t|$)/.test(line)) },
+        partial
+    };
+}

package/src/patch.ts

@@ -0,0 +1,51 @@
+/* Which side a patch says the file is missing on, read from its header so no line of the file can pass for it. */
+export function missingSides(patch: string): { old: boolean; new: boolean } {
+    const start = patch.search(/^@@/m);
+    const header = start === -1 ? patch : patch.slice(0, start);
+    return { old: /^--- \/dev\/null$/m.test(header), new: /^\+\+\+ \/dev\/null$/m.test(header) };
+}
+
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+
+/* Git's --ignore-all-space may show either side's spacing on a context line. */
+export function patchFits(patch: string, oldText: string, newText: string, ignoreWhitespace: boolean): boolean {
+    const oldLines = oldText.split('\n');
+    const newLines = newText.split('\n');
+    const same = ignoreWhitespace
+        ? (shown: string, actual: string | undefined): boolean => actual !== undefined && shown.replace(/\s+/g, '') === actual.replace(/\s+/g, '')
+        : (shown: string, actual: string | undefined): boolean => shown === actual;
+    let oldAt = -1;
+    let newAt = -1;
+    let hunks = 0;
+    for (const line of patch.split('\n')) {
+        const header = HUNK_HEADER.exec(line);
+        if (header) {
+            hunks += 1;
+            oldAt = Number(header[1]) - (header[2] === '0' ? 0 : 1);
+            newAt = Number(header[3]) - (header[4] === '0' ? 0 : 1);
+            continue;
+        }
+        if (oldAt === -1) {
+            continue;
+        }
+        const body = line.slice(1);
+        if (line.startsWith(' ')) {
+            if (!same(body, oldLines[oldAt]) || !same(body, newLines[newAt])) {
+                return false;
+            }
+            oldAt += 1;
+            newAt += 1;
+        } else if (line.startsWith('-')) {
+            if (!same(body, oldLines[oldAt])) {
+                return false;
+            }
+            oldAt += 1;
+        } else if (line.startsWith('+')) {
+            if (!same(body, newLines[newAt])) {
+                return false;
+            }
+            newAt += 1;
+        }
+    }
+    return hunks > 0;
+}

package/src/word-changes.ts

@@ -0,0 +1,32 @@
+import { diffLines } from './diff.ts';
+
+export interface DiffWordRange {
+    readonly from: number;
+    readonly to: number;
+}
+
+let segmenter: Intl.Segmenter | undefined;
+
+export function wordChanges(oldLine: string, newLine: string): { old: DiffWordRange[]; new: DiffWordRange[] } | null {
+    if (oldLine.length + newLine.length > 20000) {
+        return null;
+    }
+    segmenter ??= new Intl.Segmenter('en', { granularity: 'word' });
+    const before = [...segmenter.segment(oldLine)];
+    const after = [...segmenter.segment(newLine)];
+    if (before.length + after.length > 2000) {
+        return null;
+    }
+    const range = (segments: readonly Intl.SegmentData[], text: string, from: number, to: number): DiffWordRange[] =>
+        from === to ? [] : [{ from: segments[from]!.index, to: segments[to]?.index ?? text.length }];
+    const old: DiffWordRange[] = [];
+    const fresh: DiffWordRange[] = [];
+    for (const change of diffLines(
+        before.map((part) => part.segment),
+        after.map((part) => part.segment)
+    )) {
+        old.push(...range(before, oldLine, change.baseStart, change.baseEnd));
+        fresh.push(...range(after, newLine, change.otherStart, change.otherEnd));
+    }
+    return { old, new: fresh };
+}