main
/**
* Unified-diff parsing for the commit view.
*
* The backend exposes per-commit diffs as raw patch text
* (`GET /repos/{s}/{r}/diff/raw?base=&head=`) plus a numstat list, and there is
* no structured JSON diff — so we parse the patch here. File sections are kept
* as raw text and hunks are parsed lazily: an initial-import commit can carry
* megabytes of patch, and rendering every line of every file at once would
* freeze the page.
*/
import { getLocale, translate } from '@app/i18n'
export type DiffFileStatus = 'added' | 'deleted' | 'renamed' | 'copied' | 'modified' | 'binary'
export interface DiffFile {
path: string
oldPath: string | null
status: DiffFileStatus
/** Patch section for this file, parsed on demand by `parseHunks`. */
raw: string
additions: number
deletions: number
}
export interface DiffLine {
kind: 'context' | 'add' | 'del'
oldNo: number | null
newNo: number | null
text: string
}
export interface DiffHunk {
header: string
lines: DiffLine[]
}
/** Git's empty tree — the base for root commits (mirrors the server). */
export const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'
/** `diff --git` appears at the start of a file section; the header line of the
* whole patch is empty, so we only split on real boundaries. */
export function splitDiffFiles(text: string): DiffFile[] {
if (!text.trim()) return []
const chunks = text.split(/(?=^diff --git )/m).filter((chunk) => chunk.startsWith('diff --git '))
return chunks.map((chunk) => {
const header = /^diff --git a\/(.*?) b\/(.*?)$/m.exec(chunk)
let path = header ? unquoteGitPath(header[2] ?? '') : ''
let oldPath: string | null = header ? unquoteGitPath(header[1] ?? '') : null
const plus = /^\+\+\s+(.*)$/m.exec(chunk) ?? /^\+\+\+\s+(.*)$/m.exec(chunk)
const minus = /^---\s+(.*)$/m.exec(chunk)
const plusTarget = plus?.[1]?.trim() ?? ''
const minusTarget = minus?.[1]?.trim() ?? ''
if (plusTarget && plusTarget !== '/dev/null') path = stripAB(plusTarget)
if (minusTarget && minusTarget !== '/dev/null') oldPath = stripAB(minusTarget)
const renamed = /^rename from (.*)$/m.exec(chunk)
if (renamed) oldPath = unquoteGitPath(renamed[1].trim())
let status: DiffFileStatus = 'modified'
if (/^new file mode /m.test(chunk) || minusTarget === '/dev/null') status = 'added'
else if (/^deleted file mode /m.test(chunk) || plusTarget === '/dev/null') status = 'deleted'
else if (/^rename from /m.test(chunk)) status = 'renamed'
else if (/^copy from /m.test(chunk)) status = 'copied'
else if (/^Binary files /m.test(chunk)) status = 'binary'
// An added file has no predecessor to show.
if (status === 'added') oldPath = null
let additions = 0
let deletions = 0
for (const line of chunk.split('\n')) {
if (line.startsWith('+++') || line.startsWith('---')) continue
if (line.startsWith('+')) additions += 1
else if (line.startsWith('-')) deletions += 1
}
return {
path: path || translate(getLocale(), 'repo.unknownPath'),
oldPath,
status,
raw: chunk,
additions,
deletions,
}
})
}
/** `a/foo.py` / `"a/foo.py"` → `foo.py`. Git always prefixes the a/ b/ side,
* and the prefix can hide inside the quotes, so unquote first. */
function stripAB(value: string): string {
const token = value.split(/\s/)[0] ?? ''
const unquoted = unquoteGitPath(token)
return unquoted === token ? token.replace(/^[ab]\//, '') : unquoted.replace(/^[ab]\//, '')
}
/**
* Git C-quotes paths with unusual bytes: `"caf\303\251.png"`, `"a\tb"`.
* Octal escapes are raw bytes, so decode them as UTF-8; anything we cannot
* parse is returned untouched rather than guessed at.
*/
export function unquoteGitPath(value: string): string {
if (!value.startsWith('"') || !value.endsWith('"')) return value
const inner = value.slice(1, -1)
if (!inner.includes('\\')) return inner
const bytes: number[] = []
for (let i = 0; i < inner.length; i += 1) {
const char = inner[i]
if (char !== '\\') {
bytes.push(...new TextEncoder().encode(char))
continue
}
const next = inner[i + 1]
const octal = /^\\([0-7]{1,3})/.exec(inner.slice(i))
if (octal) {
bytes.push(Number.parseInt(octal[1], 8))
i += octal[1].length
continue
}
const simple: Record<string, string> = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', '"': '"', '\\': '\\' }
if (next && simple[next] !== undefined) {
bytes.push(...new TextEncoder().encode(simple[next]))
i += 1
continue
}
bytes.push(...new TextEncoder().encode(next ?? ''))
i += 1
}
return new TextDecoder('utf-8', { fatal: false }).decode(new Uint8Array(bytes))
}
/** Line cap so one giant file cannot take the page down. */
export const MAX_DIFF_LINES = 1500
export function parseHunks(raw: string, cap = MAX_DIFF_LINES): { hunks: DiffHunk[]; truncated: boolean } {
const hunks: DiffHunk[] = []
let current: DiffHunk | null = null
let oldNo = 0
let newNo = 0
let used = 0
let truncated = false
for (const line of raw.split('\n')) {
if (line.startsWith('@@')) {
const match = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line)
oldNo = match ? Number(match[1]) : 0
newNo = match ? Number(match[2]) : 0
current = { header: line, lines: [] }
hunks.push(current)
continue
}
if (!current) continue
if (
line.startsWith('index ') ||
line.startsWith('\\ ') ||
/^(new|old|deleted|rename|copy|Binary|---|\+\+\+) /.test(line)
) {
continue
}
if (line.startsWith('+')) {
current.lines.push({ kind: 'add', oldNo: null, newNo: newNo++, text: line.slice(1) })
used += 1
} else if (line.startsWith('-')) {
current.lines.push({ kind: 'del', oldNo: oldNo++, newNo: null, text: line.slice(1) })
used += 1
} else {
// Trailing-whitespace-stripped context lines arrive as an empty string.
current.lines.push({
kind: 'context',
oldNo: oldNo++,
newNo: newNo++,
text: line.startsWith(' ') ? line.slice(1) : line,
})
used += 1
}
if (used >= cap) {
truncated = true
break
}
}
return { hunks, truncated }
}
/** numstat rows keyed by path — authoritative +/- counts (patch counting above
* is only a fallback for files numstat does not list). */
export interface NumstatRow {
path: string
old_path?: string | null
additions: number
deletions: number
}
export function applyNumstat(files: DiffFile[], rows: NumstatRow[]): DiffFile[] {
if (!rows.length) return files
const byPath = new Map(rows.map((row) => [row.path, row]))
return files.map((file) => {
const row = byPath.get(file.path) ?? (file.oldPath ? byPath.get(file.oldPath) : undefined)
if (!row) return file
return { ...file, additions: row.additions, deletions: row.deletions }
})
}
/* ---- split (side-by-side) rendering ------------------------------------- */
export interface SplitRow {
left: DiffLine | null
right: DiffLine | null
}
/**
* Pair a hunk's linear lines into side-by-side rows: a deletion followed by an
* addition becomes one row, context repeats on both sides, and lone adds/dels
* leave the opposite cell blank.
*/
export function toSplitRows(lines: DiffLine[]): SplitRow[] {
const rows: SplitRow[] = []
for (let i = 0; i < lines.length; i += 1) {
const line = lines[i]
if (line.kind === 'del') {
const next = lines[i + 1]
if (next?.kind === 'add') {
rows.push({ left: line, right: next })
i += 1
} else {
rows.push({ left: line, right: null })
}
continue
}
if (line.kind === 'add') {
rows.push({ left: null, right: line })
continue
}
rows.push({ left: line, right: line })
}
return rows
}
export type DiffStyle = 'unified' | 'split'
/** Anything the server does not recognise behaves as unified there too. */
export function normalizeDiffStyle(value: string | null | undefined): DiffStyle {
return value === 'split' ? 'split' : 'unified'
}