Add branchName autolinks

Author: nzaytsev

src/autolinks/__tests__/autolinks.test.ts

@@ -0,0 +1,71 @@
+import * as assert from 'assert';
+import { suite, test } from 'mocha';
+import type { RefSet } from '../autolinks';
+import { Autolinks } from '../autolinks';
+
+const mockRefSets = (prefixes: string[] = ['']): RefSet[] =>
+	prefixes.map(prefix => [
+		{ domain: 'test', icon: '1', id: '1', name: 'test' },
+		[
+			{
+				alphanumeric: false,
+				ignoreCase: false,
+				prefix: prefix,
+				title: 'test',
+				url: 'test/<num>',
+				description: 'test',
+			},
+		],
+	]);
+
+suite('Autolinks Test Suite', () => {
+	test('Branch name autolinks', () => {
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('123', mockRefSets()).map(x => x.url),
+			['test/123'],
+		);
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('feature/123', mockRefSets()).map(x => x.url),
+			['test/123'],
+		);
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('feature/PRE-123', mockRefSets()).map(x => x.url),
+			['test/123'],
+		);
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('123.2', mockRefSets()).map(x => x.url),
+			['test/123', 'test/2'],
+		);
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('123', mockRefSets(['PRE-'])).map(x => x.url),
+			[],
+		);
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('feature/123', mockRefSets(['PRE-'])).map(x => x.url),
+			[],
+		);
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('feature/PRE-123', mockRefSets(['PRE-'])).map(x => x.url),
+			['test/123'],
+		);
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('feature/PRE-123.2', mockRefSets(['PRE-'])).map(x => x.url),
+			['test/123'],
+		);
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('feature/3-123-PRE-123', mockRefSets(['PRE-'])).map(x => x.url),
+			['test/123'],
+		);
+		assert.deepEqual(
+			Autolinks._getBranchAutolinks('feature/3-123-PRE-123', mockRefSets(['', 'PRE-'])).map(x => x.url),
+			['test/123', 'test/3'],
+		);
+	});
+
+	test('Commit message autolinks', () => {
+		assert.deepEqual(
+			[...Autolinks._getAutolinks('test message 123 sd', mockRefSets()).values()].map(x => x.url),
+			['test/123'],
+		);
+	});
+});

src/autolinks.ts renamed to src/autolinks/autolinks.ts

@@ -1,29 +1,30 @@
 import type { ConfigurationChangeEvent } from 'vscode';
 import { Disposable } from 'vscode';
-import { GlyphChars } from './constants';
-import type { IntegrationId } from './constants.integrations';
-import { IssueIntegrationId } from './constants.integrations';
-import type { Container } from './container';
-import type { IssueOrPullRequest } from './git/models/issue';
-import { getIssueOrPullRequestHtmlIcon, getIssueOrPullRequestMarkdownIcon } from './git/models/issue';
-import type { GitRemote } from './git/models/remote';
-import type { ProviderReference } from './git/models/remoteProvider';
-import type { ResourceDescriptor } from './plus/integrations/integration';
-import { fromNow } from './system/date';
-import { debug } from './system/decorators/log';
-import { encodeUrl } from './system/encoding';
-import { join, map } from './system/iterable';
-import { Logger } from './system/logger';
-import { escapeMarkdown } from './system/markdown';
-import type { MaybePausedResult } from './system/promise';
-import { capitalize, encodeHtmlWeak, escapeRegex, getSuperscript } from './system/string';
-import { configuration } from './system/vscode/configuration';
+import { GlyphChars } from '../constants';
+import type { IntegrationId } from '../constants.integrations';
+import { IssueIntegrationId } from '../constants.integrations';
+import type { Container } from '../container';
+import type { IssueOrPullRequest } from '../git/models/issue';
+import { getIssueOrPullRequestHtmlIcon, getIssueOrPullRequestMarkdownIcon } from '../git/models/issue';
+import type { GitRemote } from '../git/models/remote';
+import type { ProviderReference } from '../git/models/remoteProvider';
+import type { ResourceDescriptor } from '../plus/integrations/integration';
+import { fromNow } from '../system/date';
+import { debug } from '../system/decorators/log';
+import { encodeUrl } from '../system/encoding';
+import { join, map } from '../system/iterable';
+import { Logger } from '../system/logger';
+import { escapeMarkdown } from '../system/markdown';
+import type { MaybePausedResult } from '../system/promise';
+import { capitalize, encodeHtmlWeak, escapeRegex, getSuperscript } from '../system/string';
+import { configuration } from '../system/vscode/configuration';
 
 const emptyAutolinkMap = Object.freeze(new Map<string, Autolink>());
 
 const numRegex = /<num>/g;
 
 export type AutolinkType = 'issue' | 'pullrequest';
+export type AutolinkReferenceType = 'commitMessage' | 'branchName';
 
 export interface AutolinkReference {
 	/** Short prefix to match to generate autolinks for the external resource */
@@ -37,6 +38,7 @@ export interface AutolinkReference {
 	readonly title: string | undefined;
 
 	readonly type?: AutolinkType;
+	readonly referenceType?: AutolinkReferenceType;
 	readonly description?: string;
 	readonly descriptor?: ResourceDescriptor;
 }
@@ -105,6 +107,7 @@ export interface CacheableAutolinkReference extends AutolinkReference {
 	messageHtmlRegex?: RegExp;
 	messageMarkdownRegex?: RegExp;
 	messageRegex?: RegExp;
+	branchNameRegex?: RegExp;
 }
 
 export interface DynamicAutolinkReference {
@@ -123,14 +126,27 @@ export interface DynamicAutolinkReference {
 
 export const supportedAutolinkIntegrations = [IssueIntegrationId.Jira];
 
-function isDynamic(ref: AutolinkReference | DynamicAutolinkReference): ref is DynamicAutolinkReference {
+export function isDynamic(ref: AutolinkReference | DynamicAutolinkReference): ref is DynamicAutolinkReference {
 	return !('prefix' in ref) && !('url' in ref);
 }
 
 function isCacheable(ref: AutolinkReference | DynamicAutolinkReference): ref is CacheableAutolinkReference {
 	return 'prefix' in ref && ref.prefix != null && 'url' in ref && ref.url != null;
 }
 
+export type RefSet = [
+	ProviderReference | undefined,
+	(AutolinkReference | DynamicAutolinkReference)[] | CacheableAutolinkReference[],
+];
+
+type ComparingAutolinkSet = {
+	/** the place where the autolink is found from start-like symbol (/|_) */
+	index: number;
+	/** the place where the autolink is found from start */
+	startIndex: number;
+	autolink: Autolink;
+};
+
 export class Autolinks implements Disposable {
 	protected _disposable: Disposable | undefined;
 	private _references: CacheableAutolinkReference[] = [];
@@ -162,30 +178,11 @@ export class Autolinks implements Disposable {
 		}
 	}
 
-	async getAutolinks(message: string, remote?: GitRemote): Promise<Map<string, Autolink>>;
-	async getAutolinks(
-		message: string,
-		remote: GitRemote,
-		// eslint-disable-next-line @typescript-eslint/unified-signatures
-		options?: { excludeCustom?: boolean },
-	): Promise<Map<string, Autolink>>;
-	@debug<Autolinks['getAutolinks']>({
-		args: {
-			0: '<message>',
-			1: false,
-		},
-	})
-	async getAutolinks(
-		message: string,
-		remote?: GitRemote,
-		options?: { excludeCustom?: boolean },
-	): Promise<Map<string, Autolink>> {
-		const refsets: [
-			ProviderReference | undefined,
-			(AutolinkReference | DynamicAutolinkReference)[] | CacheableAutolinkReference[],
-		][] = [];
-		// Connected integration autolinks
-		await Promise.allSettled(
+	/**
+	 * put connected integration autolinks to mutable refsets
+	 */
+	private async collectIntegrationAutolinks(refsets: RefSet[]) {
+		return Promise.allSettled(
 			supportedAutolinkIntegrations.map(async integrationId => {
 				const integration = await this.container.integrations.get(integrationId);
 				// Don't check for integration access, as we want to allow autolinks to always be generated
@@ -195,8 +192,10 @@ export class Autolinks implements Disposable {
 				}
 			}),
 		);
+	}
 
-		// Remote-specific autolinks and remote integration autolinks
+	/** put remote-specific autolinks and remote integration autolinks to mutable refsets */
+	private async collectRemoteAutolinks(remote: GitRemote | undefined, refsets: RefSet[]) {
 		if (remote?.provider != null) {
 			const autoLinks = [];
 			// Don't check for integration access, as we want to allow autolinks to always be generated
@@ -212,15 +211,136 @@ export class Autolinks implements Disposable {
 				refsets.push([remote.provider, autoLinks]);
 			}
 		}
+	}
 
-		// Custom-configured autolinks
-		if (this._references.length && (remote?.provider == null || !options?.excludeCustom)) {
+	/** put custom-configured autolinks to mutable refsets */
+	private collectCustomAutolinks(remote: GitRemote | undefined, refsets: RefSet[]) {
+		if (this._references.length && remote?.provider == null) {
 			refsets.push([undefined, this._references]);
 		}
+	}
+
+	/**
+	 * it should always return non-0 result that means a probability of the autolink `b` is more relevant of the autolink `a`
+	 */
+	private static compareAutolinks(a: ComparingAutolinkSet, b: ComparingAutolinkSet) {
+		// consider that if the number is in the start, it's the most relevant link
+		if (b.index === 0) {
+			return 1;
+		}
+		if (a.index === 0) {
+			return -1;
+		}
+		// maybe it worths to use some weight function instead.
+		return (
+			b.autolink.prefix.length - a.autolink.prefix.length ||
+			-(b.startIndex - a.startIndex) ||
+			-(b.index - a.index)
+		);
+	}
+
+	/**
+	 * returns sorted list of autolinks. the first is matched as the most relevant
+	 */
+	async getBranchAutolinks(
+		branchName: string,
+		remote?: GitRemote,
+		options?: { excludeCustom: boolean },
+	): Promise<undefined | Autolink[]> {
+		const refsets: RefSet[] = [];
+		await this.collectIntegrationAutolinks(refsets);
+		await this.collectRemoteAutolinks(remote, refsets);
+		if (!options?.excludeCustom) {
+			this.collectCustomAutolinks(remote, refsets);
+		}
+		if (refsets.length === 0) return undefined;
+
+		return Autolinks._getBranchAutolinks(branchName, refsets);
+	}
+
+	static _getBranchAutolinks(branchName: string, refsets: Readonly<RefSet[]>) {
+		const autolinks = new Map<string, ComparingAutolinkSet>();
+
+		let match;
+		let num;
+		for (const [provider, refs] of refsets) {
+			for (const ref of refs) {
+				if (!isCacheable(ref)) {
+					continue;
+				}
+				if (ref.type === 'pullrequest' || (ref.referenceType && ref.referenceType !== 'branchName')) {
+					continue;
+				}
+
+				ensureCachedRegex(ref, 'plaintext');
+				const matches = branchName.matchAll(ref.branchNameRegex);
+				do {
+					match = matches.next();
+					if (!match.value?.groups) break;
+
+					num = match?.value?.groups.issueKeyNumber;
+					let index = match.value.index;
+					const linkUrl = ref.url?.replace(numRegex, num);
+					// strange case (I would say synthetic), but if we parse the link twice, use the most relevant of them
+					if (autolinks.has(linkUrl)) {
+						index = Math.min(index, autolinks.get(linkUrl)!.index);
+					}
+					autolinks.set(linkUrl, {
+						index: index,
+						// TODO: calc the distance from the nearest start-like symbol
+						startIndex: 0,
+						autolink: {
+							...ref,
+							provider: provider,
+							id: num,
+
+							url: linkUrl,
+							title: ref.title?.replace(numRegex, num),
+							description: ref.description?.replace(numRegex, num),
+							descriptor: ref.descriptor,
+						},
+					});
+				} while (!match.done);
+			}
+		}
+
+		return [...autolinks.values()]
+			.flat()
+			.sort(this.compareAutolinks)
+			.map(x => x.autolink);
+	}
+
+	async getAutolinks(message: string, remote?: GitRemote): Promise<Map<string, Autolink>>;
+	async getAutolinks(
+		message: string,
+		remote: GitRemote,
+		// eslint-disable-next-line @typescript-eslint/unified-signatures
+		options?: { excludeCustom?: boolean },
+	): Promise<Map<string, Autolink>>;
+	@debug<Autolinks['getAutolinks']>({
+		args: {
+			0: '<message>',
+			1: false,
+		},
+	})
+	async getAutolinks(
+		message: string,
+		remote?: GitRemote,
+		options?: { excludeCustom?: boolean; isBranchName?: boolean },
+	): Promise<Map<string, Autolink>> {
+		const refsets: RefSet[] = [];
+		await this.collectIntegrationAutolinks(refsets);
+		await this.collectRemoteAutolinks(remote, refsets);
+		if (!options?.excludeCustom) {
+			this.collectCustomAutolinks(remote, refsets);
+		}
 		if (refsets.length === 0) return emptyAutolinkMap;
 
-		const autolinks = new Map<string, Autolink>();
+		return Autolinks._getAutolinks(message, refsets);
+	}
 
+	static _getAutolinks(message: string, refsets: Readonly<RefSet[]>) {
+		const autolinks = new Map<string, Autolink>();
 		let match;
 		let num;
 		for (const [provider, refs] of refsets) {
@@ -236,7 +356,7 @@ export class Autolinks implements Disposable {
 
 				do {
 					match = ref.messageRegex.exec(message);
-					if (match == null) break;
+					if (!match) break;
 
 					[, , , num] = match;
 
@@ -625,7 +745,7 @@ function ensureCachedRegex(
 function ensureCachedRegex(
 	ref: CacheableAutolinkReference,
 	outputFormat: 'plaintext',
-): asserts ref is RequireSome<CacheableAutolinkReference, 'messageRegex'>;
+): asserts ref is RequireSome<CacheableAutolinkReference, 'messageRegex' | 'branchNameRegex'>;
 function ensureCachedRegex(ref: CacheableAutolinkReference, outputFormat: 'html' | 'markdown' | 'plaintext') {
 	// Regexes matches the ref prefix followed by a token (e.g. #1234)
 	if (outputFormat === 'markdown' && ref.messageMarkdownRegex == null) {
@@ -646,6 +766,12 @@ function ensureCachedRegex(ref: CacheableAutolinkReference, outputFormat: 'html'
 			`(^|\\s|\\(|\\[|\\{)(${escapeRegex(ref.prefix)}(${ref.alphanumeric ? '\\w' : '\\d'}+))\\b`,
 			ref.ignoreCase ? 'gi' : 'g',
 		);
+		ref.branchNameRegex = new RegExp(
+			`(^|\\-|_|\\.|\\/)(?<prefix>${ref.prefix})(?<issueKeyNumber>${
+				ref.alphanumeric ? '\\w' : '\\d'
+			}+)(?=$|\\-|_|\\.|\\/)`,
+			'gi',
+		);
 	}
 
 	return true;

src/autolinks/index.ts

@@ -0,0 +1 @@
+export * from './autolinks';