Avoids showing incorrect GitLab avatars

- Prevents showing a stranger's avatar when multiple GitLab users share the same name
- Prioritizes matching authors by their public email address for maximum confidence
- Falls back to matching by name only when there is a single, unambiguous match
- Performs a secondary email-based search to resolve ambiguous name matches before falling back to Gravatar

Fixes #2205

Author: eamodio

src/plus/integrations/providers/gitlab/__tests__/gitlab.utils.test.ts

@@ -1,5 +1,10 @@
 import * as assert from 'assert';
-import { getGitLabPullRequestIdentityFromMaybeUrl, isMaybeGitLabPullRequestUrl } from '../gitlab.utils.js';
+import {
+	getGitLabPullRequestIdentityFromMaybeUrl,
+	isMaybeGitLabPullRequestUrl,
+	selectGitLabUserForCommit,
+} from '../gitlab.utils.js';
+import type { GitLabUser } from '../models.js';
 
 suite('Test GitLab PR URL parsing to identity: getPullRequestIdentityFromMaybeUrl()', () => {
 	function t(message: string, query: string, prNumber: string | undefined, ownerAndRepo?: string) {
@@ -110,3 +115,63 @@ suite('Test GitLab PR URL parsing to identity: getPullRequestIdentityFromMaybeUr
 		);
 	});
 });
+
+suite('Test GitLab commit author resolution: selectGitLabUserForCommit()', () => {
+	function user(id: number, name: string, publicEmail?: string, state: string = 'active'): GitLabUser {
+		return {
+			id: id,
+			name: name,
+			username: name.toLowerCase().replace(/\s+/g, ''),
+			publicEmail: publicEmail,
+			state: state,
+			avatarUrl: `https://gitlab.com/avatars/${id}.png`,
+			webUrl: `https://gitlab.com/u${id}`,
+		};
+	}
+
+	test('returns undefined for no results', () => {
+		assert.strictEqual(selectGitLabUserForCommit([], 'Craig Wilson', 'craig@example.com'), undefined);
+	});
+
+	test('returns the single exact name match when there is no email to match', () => {
+		const u = user(1, 'Craig Wilson');
+		assert.strictEqual(selectGitLabUserForCommit([u], 'Craig Wilson', undefined), u);
+	});
+
+	test('returns the single exact name match when email does not match any public email', () => {
+		const u = user(1, 'Craig Wilson');
+		assert.strictEqual(selectGitLabUserForCommit([u], 'Craig Wilson', 'craig@example.com'), u);
+	});
+
+	test('prefers the public email match over a name match', () => {
+		const wrong = user(1, 'Craig Wilson');
+		const right = user(2, 'Craig Wilson', 'craig@example.com');
+		assert.strictEqual(selectGitLabUserForCommit([wrong, right], 'Craig Wilson', 'craig@example.com'), right);
+	});
+
+	test('email match wins even when a different user is the exact name match', () => {
+		const nameMatch = user(1, 'Craig Wilson');
+		const emailMatch = user(2, 'Craig W', 'craig@example.com');
+		assert.strictEqual(
+			selectGitLabUserForCommit([nameMatch, emailMatch], 'Craig Wilson', 'craig@example.com'),
+			emailMatch,
+		);
+	});
+
+	test('returns undefined when multiple users share the name and none match the email (#2205)', () => {
+		const a = user(1, 'Craig Wilson', 'someoneelse@example.com');
+		const b = user(2, 'Craig Wilson');
+		assert.strictEqual(selectGitLabUserForCommit([a, b], 'Craig Wilson', 'craig@example.com'), undefined);
+	});
+
+	test('matches name case-insensitively', () => {
+		const u = user(1, 'CRAIG WILSON');
+		assert.strictEqual(selectGitLabUserForCommit([u], 'craig wilson', undefined), u);
+	});
+
+	test('matches public email case-insensitively', () => {
+		const a = user(1, 'Craig Wilson');
+		const b = user(2, 'Craig Wilson', 'Craig@Example.com');
+		assert.strictEqual(selectGitLabUserForCommit([a, b], 'Craig Wilson', 'craig@example.com'), b);
+	});
+});

src/plus/integrations/providers/gitlab/gitlab.ts

@@ -29,6 +29,7 @@ import {
 } from '../../../../messages.js';
 import { configuration } from '../../../../system/-webview/configuration.js';
 import type { TokenWithInfo } from '../../authentication/models.js';
+import { selectGitLabUserForCommit } from './gitlab.utils.js';
 import type {
 	GitLabCommit,
 	GitLabIssue,
@@ -114,18 +115,16 @@ export class GitLabApi implements Disposable {
 				scope,
 			);
 
-			let user: GitLabUser | undefined;
-
-			const users = await this.findUser(provider, token, commit.author_name, options);
-			for (const u of users) {
-				if (u.name === commit.author_name || (u.publicEmail && u.publicEmail === commit.author_email)) {
-					user = u;
-					if (u.state === 'active') break;
-				} else if (
-					equalsIgnoreCase(u.name, commit.author_name) ||
-					(u.publicEmail && equalsIgnoreCase(u.publicEmail, commit.author_email))
-				) {
-					user = u;
+			let users = await this.findUser(provider, token, commit.author_name, options, cancellation);
+			let user = selectGitLabUserForCommit(users, commit.author_name, commit.author_email);
+
+			// If the name search was ambiguous (multiple users share the name), try an email-scoped search to
+			// disambiguate before giving up — otherwise we'd show a stranger's avatar (see #2205)
+			if (user == null && commit.author_email) {
+				const exactNameMatches = users.filter(u => equalsIgnoreCase(u.name, commit.author_name)).length;
+				if (exactNameMatches > 1) {
+					users = await this.findUser(provider, token, commit.author_email, options, cancellation);
+					user = selectGitLabUserForCommit(users, commit.author_name, commit.author_email);
 				}
 			}
 

src/plus/integrations/providers/gitlab/gitlab.utils.ts

@@ -1,5 +1,7 @@
 import type { PullRequestUrlIdentity } from '@gitlens/git/utils/pullRequest.utils.js';
+import { equalsIgnoreCase } from '@gitlens/utils/string.js';
 import type { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId } from '../../../../constants.integrations.js';
+import type { GitLabUser } from './models.js';
 
 export type GitLabIntegrationIds =
 	| GitCloudHostIntegrationId.GitLab
@@ -39,3 +41,32 @@ export function getGitLabPullRequestIdentityFromMaybeUrl(
 
 	return prNumber != null ? { ownerAndRepo: ownerAndRepo, prNumber: prNumber, provider: id } : undefined;
 }
+
+/**
+ * Selects the GitLab user that authored a commit from a set of search results.
+ *
+ * GitLab has no way to resolve a commit's author to a user directly, so we search users by name/email and
+ * disambiguate here. To avoid showing a stranger's avatar when multiple users share a name (see #2205), we only
+ * return a user when we can identify them confidently — a matching public email, or a single exact name match.
+ * Otherwise we return `undefined` so avatar resolution falls back to the commit email's Gravatar.
+ */
+export function selectGitLabUserForCommit(
+	users: GitLabUser[],
+	authorName: string,
+	authorEmail: string | undefined,
+): GitLabUser | undefined {
+	if (users.length === 0) return undefined;
+
+	// Strongest signal: a public email that matches the commit email — unambiguous identity
+	if (authorEmail) {
+		const byEmail = users.find(u => u.publicEmail && equalsIgnoreCase(u.publicEmail, authorEmail));
+		if (byEmail != null) return byEmail;
+	}
+
+	// Otherwise fall back to an exact name match — but only when it's unambiguous
+	const nameMatches = users.filter(u => equalsIgnoreCase(u.name, authorName));
+	if (nameMatches.length === 1) return nameMatches[0];
+
+	// No matches, or multiple name matches we can't disambiguate by email — don't guess
+	return undefined;
+}