@gitkraken/core-gitlens 0.1.0

package/src/git-cli/parsers/statusParser.ts

@@ -0,0 +1,209 @@
+import { GitStatus } from '../../git/models/status.js';
+import { GitStatusFile } from '../../git/models/statusFile.js';
+import { normalizePath } from '../../utils/path.js';
+import { maybeStopWatch } from '../../utils/stopwatch.js';
+import type { Uri } from '../../utils/uri.js';
+
+const aheadStatusV1Regex = /(?:ahead ([0-9]+))/;
+const behindStatusV1Regex = /(?:behind ([0-9]+))/;
+const quoteRegex = /"/g;
+
+export function parseGitStatus(
+	data: string,
+	repoPath: string,
+	porcelainVersion: number,
+	getUri: (path: string) => Uri,
+): GitStatus | undefined {
+	using sw = maybeStopWatch(`Git.parseStatus(${repoPath}, v=${porcelainVersion})`, {
+		log: { onlyExit: true, level: 'debug' },
+	});
+	if (!data) {
+		sw?.stop({ suffix: ` no data` });
+		return undefined;
+	}
+
+	const lines = data.split('\n').filter(<T>(i?: T): i is T => Boolean(i));
+	if (lines.length === 0) {
+		sw?.stop({ suffix: ` parsed no files` });
+		return undefined;
+	}
+
+	const status =
+		porcelainVersion < 2 ? parseStatusV1(lines, repoPath, getUri) : parseStatusV2(lines, repoPath, getUri);
+
+	sw?.stop({ suffix: ` parsed ${status.files.length} files` });
+
+	return status;
+}
+
+function parseStatusV1(lines: string[], repoPath: string, getUri: (path: string) => Uri): GitStatus {
+	let branch: string | undefined;
+	const files = [];
+	const state = {
+		ahead: 0,
+		behind: 0,
+	};
+	let upstream;
+	let missing = false;
+
+	let position = -1;
+	while (++position < lines.length) {
+		const line = lines[position];
+		// Header
+		if (line.startsWith('##')) {
+			const lineParts = line.split(' ');
+			[branch, upstream] = lineParts[1].split('...');
+			if (lineParts.length > 2) {
+				const upstreamStatus = lineParts.slice(2).join(' ');
+				if (upstreamStatus === '[gone]') {
+					missing = true;
+					state.ahead = 0;
+					state.behind = 0;
+				} else {
+					const aheadStatus = aheadStatusV1Regex.exec(upstreamStatus);
+					state.ahead = aheadStatus == null ? 0 : Number(aheadStatus[1]) || 0;
+
+					const behindStatus = behindStatusV1Regex.exec(upstreamStatus);
+					state.behind = behindStatus == null ? 0 : Number(behindStatus[1]) || 0;
+				}
+			}
+		} else {
+			const rawStatus = line.substring(0, 2);
+			const fileName = line.substring(3);
+			if (rawStatus.startsWith('R') || rawStatus.startsWith('C')) {
+				const [file1, file2] = fileName.replace(quoteRegex, '').split(' -> ');
+				files.push(parseStatusFile(repoPath, rawStatus, file2.trim(), getUri, file1.trim()));
+			} else {
+				files.push(parseStatusFile(repoPath, rawStatus, fileName, getUri));
+			}
+		}
+	}
+
+	return new GitStatus(
+		normalizePath(repoPath),
+		branch ?? '',
+		'',
+		files,
+		upstream ? { name: upstream, missing: missing, state: state } : undefined,
+	);
+}
+
+function parseStatusV2(lines: string[], repoPath: string, getUri: (path: string) => Uri): GitStatus {
+	let branch: string | undefined;
+	const files = [];
+	let sha: string | undefined;
+	const state = {
+		ahead: 0,
+		behind: 0,
+	};
+	let missing = true;
+	let upstream;
+
+	let position = -1;
+	while (++position < lines.length) {
+		const line = lines[position];
+		// Headers
+		if (line.startsWith('#')) {
+			const lineParts = line.split(' ');
+			switch (lineParts[1]) {
+				case 'branch.oid':
+					sha = lineParts[2];
+					break;
+				case 'branch.head':
+					branch = lineParts[2];
+					break;
+				case 'branch.upstream':
+					upstream = lineParts[2];
+					break;
+				case 'branch.ab':
+					missing = false;
+					state.ahead = Number(lineParts[2].substring(1));
+					state.behind = Number(lineParts[3].substring(1));
+					break;
+			}
+		} else {
+			const lineParts = line.split(' ');
+			switch (lineParts[0][0]) {
+				case '1': {
+					// normal: 1 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <path>
+					// <sub> starts with 'S' if submodule, 'N' if not
+					const submodule = lineParts[2]?.startsWith('S')
+						? { oid: lineParts[7], previousOid: lineParts[6] }
+						: undefined;
+					files.push(
+						parseStatusFile(
+							repoPath,
+							lineParts[1],
+							lineParts.slice(8).join(' '),
+							getUri,
+							undefined,
+							submodule,
+						),
+					);
+					break;
+				}
+				case '2': {
+					// rename: 2 <XY> <sub> <mH> <mI> <mW> <hH> <hI> <X><score> <path>\t<origPath>
+					const submodule = lineParts[2]?.startsWith('S')
+						? { oid: lineParts[7], previousOid: lineParts[6] }
+						: undefined;
+					const file = lineParts.slice(9).join(' ').split('\t');
+					files.push(parseStatusFile(repoPath, lineParts[1], file[0], getUri, file[1], submodule));
+					break;
+				}
+				case 'u': {
+					// unmerged: u <XY> <sub> <m1> <m2> <m3> <mW> <h1> <h2> <h3> <path>
+					const submodule = lineParts[2]?.startsWith('S')
+						? { oid: lineParts[9], previousOid: lineParts[7] }
+						: undefined;
+					files.push(
+						parseStatusFile(
+							repoPath,
+							lineParts[1],
+							lineParts.slice(10).join(' '),
+							getUri,
+							undefined,
+							submodule,
+						),
+					);
+					break;
+				}
+				case '?': // untracked
+					files.push(parseStatusFile(repoPath, '??', lineParts.slice(1).join(' '), getUri));
+					break;
+			}
+		}
+	}
+
+	return new GitStatus(
+		normalizePath(repoPath),
+		branch ?? '',
+		sha ?? '',
+		files,
+		upstream ? { name: upstream, missing: missing, state: state } : undefined,
+	);
+}
+
+function parseStatusFile(
+	repoPath: string,
+	rawStatus: string,
+	fileName: string,
+	getUri: (path: string) => Uri,
+	originalFileName?: string,
+	submodule?: { readonly oid: string; readonly previousOid?: string },
+): GitStatusFile {
+	let x = !rawStatus.startsWith('.') ? rawStatus[0].trim() : undefined;
+	if (x == null || x.length === 0) {
+		x = undefined;
+	}
+
+	let y = undefined;
+	if (rawStatus.length > 1) {
+		y = rawStatus[1] !== '.' ? rawStatus[1].trim() : undefined;
+		if (y == null || y.length === 0) {
+			y = undefined;
+		}
+	}
+
+	return new GitStatusFile(repoPath, x, y, fileName, getUri(fileName), originalFileName, submodule);
+}

package/src/git-cli/parsers/treeParser.ts

@@ -0,0 +1,61 @@
+import type { GitTreeEntry, GitTreeType } from '../../git/models/tree.js';
+import { maybeStopWatch } from '../../utils/stopwatch.js';
+import { iterateByDelimiter } from '../../utils/string.js';
+
+export function parseGitTree(data: string | undefined, ref: string, singleEntry: boolean): GitTreeEntry[] {
+	using sw = maybeStopWatch(`Git.parseTree`, { log: { onlyExit: true, level: 'debug' } });
+
+	const trees: GitTreeEntry[] = [];
+	if (!data) {
+		sw?.stop({ suffix: ` no data` });
+		return trees;
+	}
+
+	// Format: <mode> <type> <oid> <size>\t<path>
+
+	let metadata: string;
+	let oid: string;
+	let size: number;
+	let type: GitTreeType;
+	let path: string;
+
+	let startIndex: number;
+	let endIndex: number;
+
+	// Avoid generator if we are only parsing a single entry
+	for (let line of singleEntry ? data.split('\n') : iterateByDelimiter(data, '\n')) {
+		line = line.trim();
+		if (!line) continue;
+
+		[metadata, path] = line.split('\t');
+
+		// Skip mode
+		startIndex = metadata.indexOf(' ');
+		if (startIndex === -1) continue;
+
+		// Parse type
+		startIndex++;
+		endIndex = metadata.indexOf(' ', startIndex);
+		if (endIndex === -1) continue;
+
+		type = metadata.substring(startIndex, endIndex) as GitTreeType;
+
+		// Parse oid
+		startIndex = endIndex + 1;
+		endIndex = metadata.indexOf(' ', startIndex);
+		if (endIndex === -1) continue;
+
+		oid = metadata.substring(startIndex, endIndex);
+
+		// Parse size
+		startIndex = endIndex + 1;
+
+		size = parseInt(metadata.substring(startIndex), 10);
+
+		trees.push({ ref: ref, oid: oid, path: path || '', size: isNaN(size) ? 0 : size, type: type || 'blob' });
+	}
+
+	sw?.stop({ suffix: ` parsed ${trees.length} trees` });
+
+	return trees;
+}

package/src/git-cli/parsers/worktreeParser.ts

@@ -0,0 +1,113 @@
+import type { GitBranch } from '../../git/models/branch.js';
+import type { WorkspaceFolderResolver } from '../../git/models/worktree.js';
+import { GitWorktree } from '../../git/models/worktree.js';
+import { normalizePath } from '../../utils/path.js';
+import { maybeStopWatch } from '../../utils/stopwatch.js';
+import { iterateByDelimiter } from '../../utils/string.js';
+import { fileUri } from '../../utils/uri.js';
+
+interface WorktreeEntry {
+	path: string;
+	sha?: string;
+	branch?: string;
+	bare: boolean;
+	detached: boolean;
+	locked?: boolean | string;
+	prunable?: boolean | string;
+}
+
+export function parseGitWorktrees(
+	data: string | undefined,
+	repoPath: string,
+	branches: GitBranch[],
+	getWorkspaceFolder?: WorkspaceFolderResolver,
+): GitWorktree[] {
+	using sw = maybeStopWatch(`Git.parseWorktrees(${repoPath})`, { log: { onlyExit: true, level: 'debug' } });
+
+	const worktrees: GitWorktree[] = [];
+	if (!data) {
+		sw?.stop({ suffix: ` no data` });
+		return worktrees;
+	}
+
+	if (repoPath != null) {
+		repoPath = normalizePath(repoPath);
+	}
+
+	let entry: Partial<WorktreeEntry> | undefined = undefined;
+	let line: string;
+	let index: number;
+	let key: string;
+	let value: string;
+	let locked: string;
+	let prunable: string;
+	let main = true; // the first worktree is the main worktree
+
+	for (line of iterateByDelimiter(data, '\n')) {
+		index = line.indexOf(' ');
+		if (index === -1) {
+			key = line;
+			value = '';
+		} else {
+			key = line.substring(0, index);
+			value = line.substring(index + 1);
+		}
+
+		if (!key && entry != null) {
+			// eslint-disable-next-line no-loop-func
+			const branch = entry.branch ? branches?.find(b => b.name === entry!.branch) : undefined;
+			const uri = fileUri(entry.path!);
+
+			worktrees.push(
+				new GitWorktree(
+					main,
+					entry.bare ? 'bare' : entry.detached ? 'detached' : 'branch',
+					repoPath,
+					uri,
+					entry.locked ?? false,
+					entry.prunable ?? false,
+					entry.sha,
+					branch,
+					getWorkspaceFolder?.(uri),
+				),
+			);
+
+			entry = undefined;
+			main = false;
+			continue;
+		}
+
+		entry ??= {};
+
+		switch (key) {
+			case 'worktree':
+				entry.path = value;
+				break;
+			case 'bare':
+				entry.bare = true;
+				break;
+			case 'HEAD':
+				entry.sha = value;
+				break;
+			case 'branch':
+				// Strip off refs/heads/
+				entry.branch = value.substring(11);
+				break;
+			case 'detached':
+				entry.detached = true;
+				break;
+			case 'locked':
+				[, locked] = value.split(' ', 2);
+				entry.locked = locked?.trim() || true;
+				break;
+			case 'prunable':
+				[, prunable] = value.split(' ', 2);
+				entry.prunable = prunable?.trim() || true;
+				break;
+		}
+	}
+
+	sw?.stop({ suffix: ` parsed ${worktrees.length} worktrees` });
+
+	return worktrees;
+}