@design.estate/dees-catalog 13.1.0 → 13.2.0

package/ts_web/elements/00group-dataview/dees-dataview-codebox/codebox.diff.ts

@@ -61,6 +61,44 @@ export type TUnifiedDiffSummary =
   | { type: 'binary' }
   | { type: 'unparseable' };
 
+export type TUnifiedDiffMetadataKind =
+  | 'index'
+  | 'new-file-mode'
+  | 'deleted-file-mode'
+  | 'old-mode'
+  | 'new-mode'
+  | 'similarity-index'
+  | 'dissimilarity-index'
+  | 'rename-from'
+  | 'rename-to'
+  | 'copy-from'
+  | 'copy-to';
+
+export interface IUnifiedDiffMetadata {
+  kind: TUnifiedDiffMetadataKind;
+  value: string;
+}
+
+/** One ordered file section from a unified patch. Paths never retain Git's a/ and b/ prefixes. */
+export interface IUnifiedDiffFileSection {
+  beforePath?: string;
+  afterPath?: string;
+  displayPath?: string;
+  metadata: IUnifiedDiffMetadata[];
+  rows: IDiffRow[];
+  binary: boolean;
+}
+
+export type TUnifiedDiffDocumentSummary =
+  | { type: 'exact'; stats?: IDiffStats; binaryFiles: number }
+  | { type: 'partial'; stats?: IDiffStats; binaryFiles: number }
+  | { type: 'unparseable'; binaryFiles: number };
+
+export interface IUnifiedDiffDocument {
+  files: IUnifiedDiffFileSection[];
+  summary: TUnifiedDiffDocumentSummary;
+}
+
 const splitLines = (text: string): string[] => {
   if (!text) return [];
   const lines = text.split('\n');
@@ -171,61 +209,157 @@ export const computeLineDiff = (beforeText: string, afterText: string): IDiffRow
   return annotateIntraline(rows);
 };
 
-/** Parses a unified diff/patch into rows (file headers skipped, hunks kept). */
-export const parseUnifiedDiff = (patchText: string): IDiffRow[] => {
-  const rows: IDiffRow[] = [];
-  let oldLine = 0;
-  let newLine = 0;
-  let remainingOld = 0;
-  let remainingNew = 0;
-  let inHunk = false;
-  for (const line of splitLines(patchText)) {
-    const hunkMatch = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/.exec(line);
-    if (hunkMatch) {
-      oldLine = Number(hunkMatch[1]);
-      newLine = Number(hunkMatch[3]);
-      remainingOld = hunkMatch[2] === undefined ? 1 : Number(hunkMatch[2]);
-      remainingNew = hunkMatch[4] === undefined ? 1 : Number(hunkMatch[4]);
-      inHunk = true;
-      rows.push({ kind: 'hunk', text: line });
+const decodeGitQuotedPath = (valueArg: string): string => {
+  if (!(valueArg.startsWith('"') && valueArg.endsWith('"'))) return valueArg;
+  const source = valueArg.slice(1, -1);
+  const bytes: number[] = [];
+  const encoder = new TextEncoder();
+  const escapeBytes: Record<string, number> = {
+    a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13, '"': 34, '\\': 92,
+  };
+  for (let index = 0; index < source.length; index++) {
+    const character = source[index]!;
+    if (character !== '\\') {
+      const codePoint = source.codePointAt(index)!;
+      bytes.push(...encoder.encode(String.fromCodePoint(codePoint)));
+      if (codePoint > 0xffff) index++;
       continue;
     }
-    if (line.startsWith('\\ No newline')) continue;
-    if (!inHunk) continue;
-    if (line.startsWith('+')) {
-      rows.push({ kind: 'add', text: line.slice(1), newLine: newLine++ });
-      remainingNew--;
-    } else if (line.startsWith('-')) {
-      rows.push({ kind: 'remove', text: line.slice(1), oldLine: oldLine++ });
-      remainingOld--;
-    } else {
-      rows.push({ kind: 'context', text: line.startsWith(' ') ? line.slice(1) : line, oldLine: oldLine++, newLine: newLine++ });
-      remainingOld--;
-      remainingNew--;
+    const escaped = source[++index];
+    if (escaped === undefined) {
+      bytes.push(92);
+      break;
     }
-    if (remainingOld <= 0 && remainingNew <= 0) inHunk = false;
+    const octal = /^[0-7]{3}$/.exec(source.slice(index, index + 3));
+    if (octal) {
+      bytes.push(Number.parseInt(octal[0], 8));
+      index += 2;
+      continue;
+    }
+    bytes.push(escapeBytes[escaped] ?? escaped.charCodeAt(0));
   }
-  return annotateIntraline(rows);
+  return new TextDecoder().decode(Uint8Array.from(bytes));
+};
+
+const readGitPathToken = (
+  sourceArg: string,
+  startArg = 0,
+): { value: string; end: number } | undefined => {
+  let start = startArg;
+  while (sourceArg[start] === ' ') start++;
+  if (start >= sourceArg.length) return undefined;
+  if (sourceArg[start] !== '"') return { value: sourceArg.slice(start), end: sourceArg.length };
+  let escaped = false;
+  for (let index = start + 1; index < sourceArg.length; index++) {
+    const character = sourceArg[index]!;
+    if (character === '"' && !escaped) {
+      return {
+        value: decodeGitQuotedPath(sourceArg.slice(start, index + 1)),
+        end: index + 1,
+      };
+    }
+    escaped = character === '\\' && !escaped;
+    if (character !== '\\') escaped = false;
+  }
+  return undefined;
+};
+
+const normalizeGitPath = (valueArg: string | undefined): string | undefined => {
+  if (!valueArg) return undefined;
+  const value = decodeGitQuotedPath(valueArg);
+  if (value === '/dev/null') return undefined;
+  return value.startsWith('a/') || value.startsWith('b/') ? value.slice(2) : value;
+};
+
+const parsePatchHeaderPath = (valueArg: string): string | undefined => {
+  const value = valueArg.startsWith('"')
+    ? readGitPathToken(valueArg)?.value
+    : valueArg.split('\t', 1)[0];
+  return normalizeGitPath(value);
+};
+
+const parseMetadataPath = (valueArg: string): string | undefined => {
+  const value = valueArg.startsWith('"')
+    ? readGitPathToken(valueArg)?.value
+    : valueArg;
+  return value === '/dev/null' ? undefined : value;
+};
+
+const parseDiffGitPaths = (lineArg: string): { beforePath?: string; afterPath?: string } => {
+  const value = lineArg.slice('diff --git '.length);
+  if (value.startsWith('"')) {
+    const before = readGitPathToken(value);
+    const after = before ? readGitPathToken(value, before.end) : undefined;
+    const beforePath = normalizeGitPath(before?.value);
+    const afterPath = normalizeGitPath(after?.value);
+    return {
+      ...(beforePath ? { beforePath } : {}),
+      ...(afterPath ? { afterPath } : {}),
+    };
+  }
+  const boundary = Math.max(value.lastIndexOf(' b/'), value.lastIndexOf(' "b/'));
+  if (boundary < 0) return {};
+  const beforePath = normalizeGitPath(value.slice(0, boundary));
+  const afterToken = value.slice(boundary + 1);
+  const afterPath = normalizeGitPath(afterToken.startsWith('"')
+    ? readGitPathToken(afterToken)?.value
+    : afterToken);
+  return {
+    ...(beforePath ? { beforePath } : {}),
+    ...(afterPath ? { afterPath } : {}),
+  };
+};
+
+const metadataLine = (lineArg: string): IUnifiedDiffMetadata | undefined => {
+  const kinds: Array<[TUnifiedDiffMetadataKind, string]> = [
+    ['new-file-mode', 'new file mode '],
+    ['deleted-file-mode', 'deleted file mode '],
+    ['old-mode', 'old mode '],
+    ['new-mode', 'new mode '],
+    ['similarity-index', 'similarity index '],
+    ['dissimilarity-index', 'dissimilarity index '],
+    ['rename-from', 'rename from '],
+    ['rename-to', 'rename to '],
+    ['copy-from', 'copy from '],
+    ['copy-to', 'copy to '],
+    ['index', 'index '],
+  ];
+  const match = kinds.find(([, prefix]) => lineArg.startsWith(prefix));
+  if (!match) return undefined;
+  const rawValue = lineArg.slice(match[1].length);
+  const pathMetadata = match[0] === 'rename-from'
+    || match[0] === 'rename-to'
+    || match[0] === 'copy-from'
+    || match[0] === 'copy-to';
+  return {
+    kind: match[0],
+    value: pathMetadata ? parseMetadataPath(rawValue) ?? rawValue : rawValue,
+  };
 };
 
 /**
- * Returns trustworthy change counts for a unified patch. Declared hunk sizes
- * are validated before their rows contribute to the result. A truncated patch
- * reports only the complete hunk prefix, and omits stats when none is complete.
+ * Parses one unified patch without discarding file boundaries or extended Git metadata.
+ * Only complete hunks contribute to summary counts. A producer-declared truncation therefore
+ * reports a trustworthy complete prefix instead of inventing totals for the missing suffix.
  */
-export const summarizeUnifiedDiff = (
+export const parseUnifiedDiffDocument = (
   patchText: string,
   options: IUnifiedDiffSummaryOptions = {},
-): TUnifiedDiffSummary => {
-  const lines = splitLines(patchText);
-  let sawPatchStructure = false;
-  let sawOldHeader = false;
-  let sawNewHeader = false;
-  let sawHunk = false;
+): IUnifiedDiffDocument => {
+  const files: IUnifiedDiffFileSection[] = [];
+  let current: IUnifiedDiffFileSection | undefined;
+  let currentSawOldHeader = false;
+  let currentSawNewHeader = false;
+  let sawRecognizedContent = false;
+  let sawHeaderPair = false;
+  let unparseable = false;
+  let binaryPayload = false;
   let added = 0;
   let removed = 0;
   let completeHunks = 0;
   let hunk: {
+    oldLine: number;
+    newLine: number;
     expectedOld: number;
     expectedNew: number;
     observedOld: number;
@@ -234,9 +368,28 @@ export const summarizeUnifiedDiff = (
     removed: number;
   } | undefined;
 
-  const completeCurrentHunk = (): boolean => {
-    if (!hunk) return true;
-    if (hunk.observedOld !== hunk.expectedOld || hunk.observedNew !== hunk.expectedNew) return false;
+  const createFile = (pathsArg: { beforePath?: string; afterPath?: string } = {}) => {
+    current = {
+      ...pathsArg,
+      displayPath: pathsArg.afterPath ?? pathsArg.beforePath,
+      metadata: [],
+      rows: [],
+      binary: false,
+    };
+    files.push(current);
+    currentSawOldHeader = false;
+    currentSawNewHeader = false;
+    binaryPayload = false;
+    return current;
+  };
+  const requireFile = () => current ?? createFile();
+  const refreshDisplayPath = (fileArg: IUnifiedDiffFileSection) => {
+    fileArg.displayPath = fileArg.afterPath ?? fileArg.beforePath;
+  };
+  const completeHunk = () => {
+    if (!hunk
+      || hunk.observedOld !== hunk.expectedOld
+      || hunk.observedNew !== hunk.expectedNew) return false;
     added += hunk.added;
     removed += hunk.removed;
     completeHunks++;
@@ -244,13 +397,23 @@ export const summarizeUnifiedDiff = (
     return true;
   };
 
-  for (const line of lines) {
-    const hunkMatch = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(?:.*)$/.exec(line);
+  for (const line of splitLines(patchText)) {
+    if (line.startsWith('diff --git ')) {
+      if (hunk) {
+        unparseable = true;
+        hunk = undefined;
+      }
+      createFile(parseDiffGitPaths(line));
+      continue;
+    }
+
+    const hunkMatch = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/.exec(line);
     if (hunkMatch) {
-      if (!completeCurrentHunk()) return { type: 'unparseable' };
-      sawPatchStructure = true;
-      sawHunk = true;
+      if (hunk) unparseable = true;
+      const file = requireFile();
       hunk = {
+        oldLine: Number(hunkMatch[1]),
+        newLine: Number(hunkMatch[3]),
         expectedOld: hunkMatch[2] === undefined ? 1 : Number(hunkMatch[2]),
         expectedNew: hunkMatch[4] === undefined ? 1 : Number(hunkMatch[4]),
         observedOld: 0,
@@ -258,65 +421,135 @@ export const summarizeUnifiedDiff = (
         added: 0,
         removed: 0,
       };
-      if (hunk.expectedOld === 0 && hunk.expectedNew === 0) completeCurrentHunk();
+      file.rows.push({ kind: 'hunk', text: line });
+      sawRecognizedContent = true;
+      completeHunk();
       continue;
     }
 
-    if (/^(Binary files .+ differ|GIT binary patch)$/.test(line)) return { type: 'binary' };
     if (line.startsWith('\')) continue;
-
     if (hunk) {
+      const file = requireFile();
       if (line.startsWith('+')) {
+        file.rows.push({ kind: 'add', text: line.slice(1), newLine: hunk.newLine++ });
         hunk.observedNew++;
         hunk.added++;
       } else if (line.startsWith('-')) {
+        file.rows.push({ kind: 'remove', text: line.slice(1), oldLine: hunk.oldLine++ });
         hunk.observedOld++;
         hunk.removed++;
       } else if (line.startsWith(' ')) {
+        file.rows.push({
+          kind: 'context',
+          text: line.slice(1),
+          oldLine: hunk.oldLine++,
+          newLine: hunk.newLine++,
+        });
         hunk.observedOld++;
         hunk.observedNew++;
       } else {
-        return { type: 'unparseable' };
+        unparseable = true;
+        hunk = undefined;
+        continue;
       }
-      if (hunk.observedOld > hunk.expectedOld || hunk.observedNew > hunk.expectedNew) {
-        return { type: 'unparseable' };
-      }
-      if (hunk.observedOld === hunk.expectedOld && hunk.observedNew === hunk.expectedNew) {
-        completeCurrentHunk();
+      if (hunk
+        && (hunk.observedOld > hunk.expectedOld || hunk.observedNew > hunk.expectedNew)) {
+        unparseable = true;
+        hunk = undefined;
+      } else {
+        completeHunk();
       }
       continue;
     }
 
+    if (binaryPayload) continue;
     if (line.startsWith('--- ')) {
-      sawPatchStructure = true;
-      sawOldHeader = true;
+      if (currentSawNewHeader) createFile();
+      const file = requireFile();
+      file.beforePath = parsePatchHeaderPath(line.slice(4));
+      currentSawOldHeader = true;
+      refreshDisplayPath(file);
       continue;
     }
     if (line.startsWith('+++ ')) {
-      sawPatchStructure = true;
-      sawNewHeader = true;
+      const file = requireFile();
+      file.afterPath = parsePatchHeaderPath(line.slice(4));
+      currentSawNewHeader = true;
+      sawHeaderPair ||= currentSawOldHeader;
+      refreshDisplayPath(file);
       continue;
     }
-    if (
-      line.startsWith('diff ')
-      || line.startsWith('index ')
-      || /^(new file mode|deleted file mode|old mode|new mode|similarity index|dissimilarity index|rename from|rename to|copy from|copy to) /.test(line)
-    ) {
-      sawPatchStructure = true;
+    const metadata = metadataLine(line);
+    if (metadata) {
+      const file = requireFile();
+      file.metadata.push(metadata);
+      if (metadata.kind === 'rename-from' || metadata.kind === 'copy-from') {
+        file.beforePath ??= metadata.value;
+      }
+      if (metadata.kind === 'rename-to' || metadata.kind === 'copy-to') {
+        file.afterPath ??= metadata.value;
+      }
+      refreshDisplayPath(file);
+      sawRecognizedContent = true;
       continue;
     }
-    if (line.trim()) return { type: 'unparseable' };
+    const binaryMatch = /^Binary files (.+) and (.+) differ$/.exec(line);
+    if (binaryMatch) {
+      const file = requireFile();
+      file.beforePath ??= parsePatchHeaderPath(binaryMatch[1]!);
+      file.afterPath ??= parsePatchHeaderPath(binaryMatch[2]!);
+      refreshDisplayPath(file);
+      file.binary = true;
+      sawRecognizedContent = true;
+      continue;
+    }
+    if (line === 'GIT binary patch') {
+      requireFile().binary = true;
+      binaryPayload = true;
+      sawRecognizedContent = true;
+      continue;
+    }
+    if (line.trim()) unparseable = true;
   }
 
-  const finalHunkComplete = completeCurrentHunk();
-  if (!finalHunkComplete && !options.truncated) return { type: 'unparseable' };
-  if (options.truncated) {
-    return completeHunks ? { type: 'partial', stats: { added, removed } } : { type: 'partial' };
+  if (hunk) {
+    if (!options.truncated) unparseable = true;
+    hunk = undefined;
   }
-  if (!sawHunk && !(sawPatchStructure && sawOldHeader && sawNewHeader)) {
-    return { type: 'unparseable' };
+  for (const file of files) file.rows = annotateIntraline(file.rows);
+  const binaryFiles = files.filter((file) => file.binary).length;
+  const stats = completeHunks > 0 ? { added, removed } : undefined;
+  const recognized = sawRecognizedContent || sawHeaderPair || binaryFiles > 0;
+  const summary: TUnifiedDiffDocumentSummary = unparseable || !recognized
+    ? { type: 'unparseable', binaryFiles }
+    : options.truncated
+      ? { type: 'partial', ...(stats ? { stats } : {}), binaryFiles }
+      : { type: 'exact', ...(stats ? { stats } : {}), binaryFiles };
+  return { files, summary };
+};
+
+/** Compatibility row view. File boundaries and metadata are available from parseUnifiedDiffDocument. */
+export const parseUnifiedDiff = (patchText: string): IDiffRow[] =>
+  parseUnifiedDiffDocument(patchText).files.flatMap((file) => file.rows);
+
+/**
+ * Returns trustworthy change counts for a unified patch. Declared hunk sizes
+ * are validated before their rows contribute to the result. A truncated patch
+ * reports only the complete hunk prefix, and omits stats when none is complete.
+ */
+export const summarizeUnifiedDiff = (
+  patchText: string,
+  options: IUnifiedDiffSummaryOptions = {},
+): TUnifiedDiffSummary => {
+  const document = parseUnifiedDiffDocument(patchText, options);
+  if (document.summary.binaryFiles > 0) return { type: 'binary' };
+  if (document.summary.type === 'unparseable') return { type: 'unparseable' };
+  if (document.summary.type === 'partial') {
+    return document.summary.stats
+      ? { type: 'partial', stats: document.summary.stats }
+      : { type: 'partial' };
   }
-  return { type: 'exact', stats: { added, removed } };
+  return { type: 'exact', stats: document.summary.stats ?? { added: 0, removed: 0 } };
 };
 
 const maxIntralineChars = 400;