@gitkraken/core-gitlens 0.1.0

package/src/git/utils/reference.utils.ts

@@ -0,0 +1,267 @@
+import { capitalize } from '../../utils/string.js';
+import type {
+	GitBranchReference,
+	GitReference,
+	GitRevisionReference,
+	GitStashReference,
+	GitTagReference,
+} from '../models/reference.js';
+import { getBranchNameWithoutRemote, getRemoteNameFromBranchName } from './branch.utils.js';
+import { isRevisionRange, isShaWithParentSuffix, shortenRevision } from './revision.utils.js';
+
+interface GitBranchReferenceOptions {
+	refType: 'branch';
+	id?: string;
+	name: string;
+	remote: boolean;
+	sha?: string;
+	upstream?: { name: string; missing: boolean };
+	worktree?: { path: string; isDefault: boolean } | boolean;
+}
+
+interface GitCommitReferenceOptions {
+	refType: 'revision';
+	name?: string;
+	message?: string;
+}
+
+interface GitStashReferenceOptions {
+	refType: 'stash';
+	name: string;
+	number: string | undefined;
+	message?: string;
+	stashOnRef?: string;
+}
+
+interface GitTagReferenceOptions {
+	refType: 'tag';
+	id?: string;
+	name: string;
+	sha?: string;
+}
+
+export function createReference(ref: string, repoPath: string, options: GitBranchReferenceOptions): GitBranchReference;
+export function createReference(ref: string, repoPath: string, options: GitStashReferenceOptions): GitStashReference;
+export function createReference(ref: string, repoPath: string, options: GitTagReferenceOptions): GitTagReference;
+export function createReference(
+	ref: string,
+	repoPath: string,
+	options?: GitCommitReferenceOptions,
+): GitRevisionReference;
+export function createReference(
+	ref: string,
+	repoPath: string,
+	options:
+		| GitBranchReferenceOptions
+		| GitStashReferenceOptions
+		| GitTagReferenceOptions
+		| GitCommitReferenceOptions = { refType: 'revision' },
+): GitReference {
+	switch (options.refType) {
+		case 'branch':
+			return {
+				refType: 'branch',
+				repoPath: repoPath,
+				ref: ref,
+				name: options.name,
+				id: options.id,
+				remote: options.remote,
+				sha: options.sha,
+				upstream: options.upstream,
+				worktree: options.worktree,
+			};
+		case 'stash':
+			return {
+				refType: 'stash',
+				repoPath: repoPath,
+				ref: ref,
+				sha: ref,
+				name: options.name,
+				stashNumber: options.number,
+				message: options.message,
+				stashOnRef: options.stashOnRef,
+			};
+		case 'tag':
+			return {
+				refType: 'tag',
+				repoPath: repoPath,
+				ref: ref,
+				name: options.name,
+				id: options.id,
+				sha: options.sha,
+			};
+		default:
+			return {
+				refType: 'revision',
+				repoPath: repoPath,
+				ref: ref,
+				sha: ref,
+				name: options.name ?? shortenRevision(ref, { strings: { working: 'Working Tree' } }),
+				message: options.message,
+			};
+	}
+}
+
+export function getReferenceNameWithoutRemote(ref: GitReference): string {
+	if (ref.refType === 'branch') {
+		return ref.remote ? getBranchNameWithoutRemote(ref.name) : ref.name;
+	}
+	return ref.name;
+}
+
+export function getReferenceTypeLabel(ref: GitReference | undefined): 'Branch' | 'Commit' | 'Stash' | 'Tag' {
+	switch (ref?.refType) {
+		case 'branch':
+			return 'Branch';
+		case 'stash':
+			return 'Stash';
+		case 'tag':
+			return 'Tag';
+		default:
+			return 'Commit';
+	}
+}
+
+export function isBranchReference(ref: GitReference | undefined): ref is GitBranchReference {
+	return ref?.refType === 'branch';
+}
+
+export function isGitReference(ref: unknown): ref is GitReference {
+	if (ref == null || typeof ref !== 'object') return false;
+
+	const r = ref as GitReference;
+	return (
+		typeof r.refType === 'string' &&
+		typeof r.repoPath === 'string' &&
+		typeof r.ref === 'string' &&
+		typeof r.name === 'string'
+	);
+}
+
+export function isRevisionReference(ref: GitReference | undefined): ref is GitRevisionReference {
+	return ref?.refType === 'revision';
+}
+
+export function isRevisionRangeReference(ref: GitReference | undefined): ref is GitRevisionReference {
+	return ref?.refType === 'revision' && isRevisionRange(ref.ref);
+}
+
+export function isStashReference(ref: GitReference | undefined): ref is GitStashReference {
+	return ref?.refType === 'stash' || (ref?.refType === 'revision' && Boolean('stashName' in ref && ref.stashName));
+}
+
+export function isTagReference(ref: GitReference | undefined): ref is GitTagReference {
+	return ref?.refType === 'tag';
+}
+
+export function getReferenceLabel(
+	refs: GitReference | GitReference[] | undefined,
+	options?: { capitalize?: boolean; expand?: boolean; icon?: boolean; label?: boolean; quoted?: boolean } | false,
+): string {
+	if (refs == null) return '';
+
+	options =
+		options === false
+			? {}
+			: { expand: true, icon: true, label: options?.label ?? options?.expand ?? true, ...options };
+
+	let result;
+	if (!Array.isArray(refs) || refs.length === 1) {
+		const ref = Array.isArray(refs) ? refs[0] : refs;
+		let refName = options?.quoted ? `'${ref.name}'` : ref.name;
+		switch (ref.refType) {
+			case 'branch': {
+				if (ref.remote) {
+					refName = `${getRemoteNameFromBranchName(refName)}: ${getBranchNameWithoutRemote(refName)}`;
+					refName = options?.quoted ? `'${refName}'` : refName;
+				}
+
+				let label;
+				if (options.label) {
+					if (options.capitalize && options.expand) {
+						label = `${ref.remote ? 'Remote ' : ''}Branch `;
+					} else {
+						label = `${ref.remote ? 'remote ' : ''}branch `;
+					}
+				} else {
+					label = '';
+				}
+
+				result = `${label}${options.icon ? `$(git-branch)\u00a0${refName}` : refName}`;
+				break;
+			}
+			case 'tag':
+				result = `${options.label ? 'tag ' : ''}${options.icon ? `$(tag)\u00a0${refName}` : refName}`;
+				break;
+			default: {
+				if (isStashReference(ref)) {
+					let message;
+					if (options.expand && ref.message) {
+						message = `${ref.stashNumber != null ? `#${ref.stashNumber}: ` : ''}${
+							ref.message.length > 20 ? `${ref.message.substring(0, 20).trimEnd()}\u2026` : ref.message
+						}`;
+					}
+
+					result = `${options.label ? 'stash ' : ''}${
+						options.icon
+							? `$(archive)\u00a0${message ?? ref.name}`
+							: (message ?? (ref.stashNumber ? `#${ref.stashNumber}` : ref.name))
+					}`;
+				} else if (isRevisionRange(ref.ref)) {
+					result = refName;
+				} else {
+					let message;
+					if (options.expand && ref.message) {
+						message =
+							ref.message.length > 20
+								? ` (${ref.message.substring(0, 20).trimEnd()}\u2026)`
+								: ` (${ref.message})`;
+					}
+
+					let prefix;
+					if (options.expand && options.label && isShaWithParentSuffix(ref.ref)) {
+						refName = ref.name.endsWith('^') ? ref.name.substring(0, ref.name.length - 1) : ref.name;
+						if (options?.quoted) {
+							refName = `'${refName}'`;
+						}
+						prefix = 'before ';
+					} else {
+						prefix = '';
+					}
+
+					result = `${options.label ? `${prefix}commit ` : ''}${
+						options.icon ? `$(git-commit)\u00a0${refName}${message ?? ''}` : `${refName}${message ?? ''}`
+					}`;
+				}
+				break;
+			}
+		}
+
+		return options.capitalize && options.expand && options.label !== false ? capitalize(result) : result;
+	}
+
+	const expanded = options.expand ? ` (${refs.map(r => r.name).join(', ')})` : '';
+	switch (refs[0].refType) {
+		case 'branch':
+			return `${refs.length} branches${expanded}`;
+		case 'tag':
+			return `${refs.length} tags${expanded}`;
+		default:
+			return `${refs.length} ${isStashReference(refs[0]) ? 'stashes' : 'commits'}${expanded}`;
+	}
+}
+
+export function getReferenceTypeIcon(ref: GitReference | undefined, webview?: boolean): string {
+	switch (ref?.refType) {
+		case 'branch':
+			if (ref.remote) return 'cloud';
+			if (ref.worktree) return webview ? 'gl-worktree' : 'gitlens-worktree';
+			return 'git-branch';
+		case 'tag':
+			return 'tag';
+		case 'stash':
+			return 'archive';
+		default:
+			return 'git-commit';
+	}
+}

package/src/git/utils/remote.utils.ts

@@ -0,0 +1,140 @@
+import type { GitRemote } from '../models/remote.js';
+import type { RemoteProvider } from '../models/remoteProvider.js';
+import type { RemoteResource } from '../models/remoteResource.js';
+import { RemoteResourceType } from '../models/remoteResource.js';
+
+export function getDefaultRemoteOrHighlander<T extends GitRemote>(remotes: T[]): T | undefined {
+	return remotes.length === 1 ? remotes[0] : remotes.find(r => r.default);
+}
+
+export function getHighlanderProviderName(remotes: GitRemote<RemoteProvider>[]): string | undefined {
+	if (remotes.length === 0) return undefined;
+
+	const remote = getDefaultRemoteOrHighlander(remotes);
+	if (remote != null) return remote.provider.name;
+
+	const providerName = remotes[0].provider.name;
+	// Only use the real provider name if there is only 1 type of provider
+	if (remotes.every(r => r.provider.name === providerName)) return providerName;
+
+	return undefined;
+}
+
+export function getHighlanderProviders(remotes: GitRemote<RemoteProvider>[]): RemoteProvider[] | undefined {
+	if (remotes.length === 0) return undefined;
+
+	const remote = getDefaultRemoteOrHighlander(remotes);
+	if (remote != null) return [remote.provider];
+
+	const providerName = remotes[0].provider.name;
+	if (remotes.every(r => r.provider.name === providerName)) return remotes.map(r => r.provider);
+
+	return undefined;
+}
+
+export function getRemoteArrowsGlyph(remote: GitRemote): string {
+	let arrows;
+	let left;
+	let right;
+	for (const { type } of remote.urls) {
+		if (type === 'fetch') {
+			left = true;
+
+			if (right) break;
+		} else if (type === 'push') {
+			right = true;
+
+			if (left) break;
+		}
+	}
+
+	if (left && right) {
+		arrows = '\u21c4'; // ArrowsRightLeft
+	} else if (right) {
+		arrows = '\u2192'; // ArrowRight
+	} else if (left) {
+		arrows = '\u2190'; // ArrowLeft
+	} else {
+		arrows = '\u2014'; // Dash
+	}
+
+	return arrows;
+}
+
+export function getRemoteThemeIconString(remote: GitRemote | undefined): string {
+	return getRemoteProviderThemeIconString(remote?.provider);
+}
+
+export function getRemoteProviderThemeIconString(provider: RemoteProvider | undefined): string {
+	return provider != null ? `gitlens-provider-${provider.icon}` : 'cloud';
+}
+
+export function getRemoteUpstreamDescription(remote: GitRemote): string {
+	const arrows = getRemoteArrowsGlyph(remote);
+
+	const { provider } = remote;
+	if (provider != null) {
+		return `${arrows}\u00a0 ${provider.name} \u00a0\u2022\u00a0 ${provider.displayPath}`;
+	}
+
+	return `${arrows}\u00a0 ${remote.domain ? `${remote.domain} \u00a0\u2022\u00a0 ` : ''}${remote.path}`;
+}
+
+export function getVisibilityCacheKey(remote: GitRemote): string;
+export function getVisibilityCacheKey(remotes: GitRemote[]): string;
+export function getVisibilityCacheKey(remotes: GitRemote | GitRemote[]): string {
+	if (!Array.isArray(remotes)) return remotes.remoteKey;
+	return remotes
+		.map(r => r.remoteKey)
+		.sort()
+		.join(',');
+}
+
+export const gitSuffixRegex = /\.git\/?$/;
+
+// Test git urls
+/*
+http://host.xz/user/project.git
+https://host.xz/user/project.git
+git@host.xz:user/project.git
+git://host.xz/path/to/repo.git/
+ssh://host.xz/project.git
+ssh://user@host.xz/path/to/repo.git
+user@host.xz:path/to/repo.git
+*/
+export const remoteUrlRegex =
+	/^(?:(git:\/\/)(.*?)\/|(https?:\/\/)(?:.*?@)?(.*?)\/|git@(.*):|(ssh:\/\/)(?:.*@)?(.*?)(?::.*?)?(?:\/|(?=~))|(?:.*?@)(.*?):)(.*)$/;
+
+export function parseGitRemoteUrl(url: string): [scheme: string, domain: string, path: string] {
+	const match = remoteUrlRegex.exec(url);
+	if (match == null) return ['', '', url];
+
+	return [
+		match[1] || match[3] || match[6],
+		match[2] || match[4] || match[5] || match[7] || match[8],
+		match[9].replace(gitSuffixRegex, ''),
+	];
+}
+
+export function getNameFromRemoteResource(resource: RemoteResource): string {
+	switch (resource.type) {
+		case RemoteResourceType.Branch:
+			return 'Branch';
+		case RemoteResourceType.Branches:
+			return 'Branches';
+		case RemoteResourceType.Commit:
+			return 'Commit';
+		case RemoteResourceType.Comparison:
+			return 'Comparison';
+		case RemoteResourceType.CreatePullRequest:
+			return 'Create Pull Request';
+		case RemoteResourceType.File:
+			return 'File';
+		case RemoteResourceType.Repo:
+			return 'Repository';
+		case RemoteResourceType.Revision:
+			return 'File';
+		default:
+			return '';
+	}
+}

package/src/git/utils/repository.utils.ts

@@ -0,0 +1,18 @@
+import { normalizePath } from '../../utils/path.js';
+import type { Uri } from '../../utils/uri.js';
+
+export function getRepositoryOrWorktreePath(uri: Uri): string {
+	return uri.scheme === 'file' ? normalizePath(uri.fsPath) : uri.toString();
+}
+
+export function getCommonRepositoryPath(commonUri: Uri): string {
+	const uri = getCommonRepositoryUri(commonUri);
+	return getRepositoryOrWorktreePath(uri);
+}
+
+export function getCommonRepositoryUri(commonUri: Uri): Uri {
+	if (commonUri?.path.endsWith('/.git')) {
+		return commonUri.with({ path: commonUri.path.substring(0, commonUri.path.length - 5) });
+	}
+	return commonUri;
+}

package/src/git/utils/resourceDescriptor.utils.ts

@@ -0,0 +1,26 @@
+import type {
+	IssueResourceDescriptor,
+	RepositoryDescriptor,
+	ResourceDescriptor,
+} from '../models/resourceDescriptor.js';
+
+export function isRepositoryDescriptor(resource: ResourceDescriptor): resource is RepositoryDescriptor {
+	return (
+		'key' in resource &&
+		resource.key != null &&
+		'owner' in resource &&
+		resource.owner != null &&
+		'name' in resource &&
+		resource.name != null
+	);
+}
+export function isIssueResourceDescriptor(resource: ResourceDescriptor): resource is IssueResourceDescriptor {
+	return (
+		'key' in resource &&
+		resource.key != null &&
+		'id' in resource &&
+		resource.id != null &&
+		'name' in resource &&
+		resource.name != null
+	);
+}

package/src/git/utils/revision.utils.ts

@@ -0,0 +1,149 @@
+import type { GitRevisionRange, GitRevisionRangeNotation } from '../models/revision.js';
+import { deletedOrMissing, uncommitted, uncommittedStaged } from '../models/revision.js';
+
+const rangeRegex = /^([\w\-/]+(?:\.[\w\-/]+)*)?(\.\.\.?)([\w\-/]+(?:\.[\w\-/]+)*)?$/;
+const qualifiedRangeRegex = /^([\w\-/]+(?:\.[\w\-/]+)*)(\.\.\.?)([\w\-/]+(?:\.[\w\-/]+)*)$/;
+const qualifiedDoubleDotRange = /^([\w\-/]+(?:\.[\w\-/]+)*)(\.\.)([\w\-/]+(?:\.[\w\-/]+)*)$/;
+const qualifiedTripleDotRange = /^([\w\-/]+(?:\.[\w\-/]+)*)(\.\.\.)([\w\-/]+(?:\.[\w\-/]+)*)$/;
+const shaWithOptionalRevisionSuffixRegex = /(^[0-9a-f]{40}([\^@~:]\S*)?$)|(^[0]{40}(:|-)$)/;
+const revisionWithSuffixRegex = /^\S+[\^@~:]\S*$/;
+const shaRegex = /(^[0-9a-f]{40}$)|(^[0]{40}(:|-)$)/;
+const shaShortRegex = /(^[0-9a-f]{7,40}$)|(^[0]{40}(:|-)$)/;
+const shaParentRegex = /(^[0-9a-f]{40})\^[0-3]?$/;
+const shaShortenRegex = /^(.*?)([\^@~:].*)?$/;
+const uncommittedRegex = /^[0]{40}(?:[\^@~:]\S*)?:?$/;
+const uncommittedStagedRegex = /^[0]{40}([\^@~]\S*)?:$/;
+
+function isMatch(regex: RegExp, rev: string | undefined) {
+	return !rev ? false : regex.test(rev);
+}
+
+/** Checks if the rev looks like a revision with a navigation suffixes (like ^, @, ~, or :) */
+export function isRevisionWithSuffix(rev: string): boolean {
+	return isMatch(revisionWithSuffixRegex, rev) && rev.length > 40;
+}
+
+/** Checks if the rev looks like a SHA-1 hash
+ * @param allowShort If true, allows short SHAs (7-40 characters)
+ */
+export function isSha(rev: string, allowShort: boolean = false): boolean {
+	return isMatch(allowShort ? shaShortRegex : shaRegex, rev);
+}
+
+/** Checks if the rev looks like a SHA-1 hash with an optional revision navigation suffixes (like ^, @, ~, or :) */
+export function isShaWithOptionalRevisionSuffix(rev: string): boolean {
+	return isMatch(shaWithOptionalRevisionSuffixRegex, rev);
+}
+
+/** Checks if the rev looks like a SHA-1 hash with a ^ parent suffix */
+export function isShaWithParentSuffix(rev: string): boolean {
+	return isMatch(shaParentRegex, rev);
+}
+
+export function isUncommitted(rev: string | undefined, exact: boolean = false): boolean {
+	return rev === uncommitted || rev === uncommittedStaged || (!exact && isMatch(uncommittedRegex, rev));
+}
+
+export function isUncommittedStaged(rev: string | undefined, exact: boolean = false): boolean {
+	return rev === uncommittedStaged || (!exact && isMatch(uncommittedStagedRegex, rev));
+}
+
+export function isUncommittedWithParentSuffix(rev: string | undefined): rev is `${typeof uncommitted}${'^' | ':^'}` {
+	return rev === `${uncommitted}^` || rev === `${uncommittedStaged}^`;
+}
+
+export function isUncommittedStagedWithParentSuffix(
+	rev: string | undefined,
+): rev is `${typeof uncommitted}${'^' | ':^'}` {
+	return rev === `${uncommittedStaged}^`;
+}
+
+let abbreviatedShaLength = 7;
+export function getAbbreviatedShaLength(): number {
+	return abbreviatedShaLength;
+}
+
+export function setAbbreviatedShaLength(length: number): void {
+	abbreviatedShaLength = length;
+}
+
+/** Resets the abbreviated SHA length to the default (7). For test isolation. */
+export function resetAbbreviatedShaLength(): void {
+	abbreviatedShaLength = 7;
+}
+
+export function shortenRevision(
+	rev: string | undefined,
+	options?: {
+		strings?: { uncommitted?: string; uncommittedStaged?: string; working?: string };
+	},
+): string {
+	if (rev === deletedOrMissing) return '(deleted)';
+	if (!rev) return options?.strings?.working ?? '';
+	if (isUncommitted(rev)) {
+		return isUncommittedStaged(rev)
+			? (options?.strings?.uncommittedStaged ?? 'Index')
+			: (options?.strings?.uncommitted ?? 'Working Tree');
+	}
+	if (isRevisionRange(rev) || !isShaWithOptionalRevisionSuffix(rev)) return rev;
+
+	// Don't allow shas to be shortened to less than 5 characters
+	const len = Math.max(5, getAbbreviatedShaLength());
+
+	// If we have a suffix, append it
+	const match = shaShortenRegex.exec(rev);
+	if (match != null) {
+		const [, rev, suffix] = match;
+
+		if (suffix != null) {
+			return `${rev.substring(0, len)}${suffix}`;
+		}
+	}
+
+	return rev.substring(0, len);
+}
+
+export function createRevisionRange(
+	left: string | undefined,
+	right: string | undefined,
+	notation: GitRevisionRangeNotation,
+): GitRevisionRange {
+	return `${left ?? ''}${notation}${right ?? ''}`;
+}
+
+export function getRevisionRangeParts(
+	revRange: GitRevisionRange,
+): { left: string | undefined; right: string | undefined; notation: GitRevisionRangeNotation } | undefined {
+	const match = rangeRegex.exec(revRange);
+	if (match == null) return undefined;
+
+	const [, left, notation, right] = match;
+	return {
+		left: left || undefined,
+		right: right || undefined,
+		notation: notation as GitRevisionRangeNotation,
+	};
+}
+
+export function isRevisionRange(
+	rev: string | undefined,
+	rangeType: 'any' | 'qualified' | 'qualified-double-dot' | 'qualified-triple-dot' = 'any',
+): rev is GitRevisionRange {
+	if (rev == null) return false;
+
+	switch (rangeType) {
+		case 'qualified':
+			return qualifiedRangeRegex.test(rev);
+		case 'qualified-double-dot':
+			return qualifiedDoubleDotRange.test(rev);
+		case 'qualified-triple-dot':
+			return qualifiedTripleDotRange.test(rev);
+		default:
+			return rangeRegex.test(rev);
+	}
+}
+
+//** Strips `origin/` from a reference or range, because we "fake" origin as the default remote */
+export function stripOrigin<T extends string | GitRevisionRange | undefined>(ref: T): T {
+	return ref?.replace(/(?:^|(?<=..))origin\//, '') as T;
+}