Lets user reset their choice of Merge Target

(#4224, #4258)

Author: sergeibbb

src/commands/changeBranchMergeTarget.ts

@@ -1,10 +1,12 @@
+import type { CancellationToken } from 'vscode';
 import type { Container } from '../container';
 import type { GitBranch } from '../git/models/branch';
 import type { Repository } from '../git/models/repository';
+import { getSettledValue } from '../system/promise';
 import type { ViewsWithRepositoryFolders } from '../views/viewBase';
 import type { PartialStepState, StepGenerator, StepState } from './quickCommand';
 import { endSteps, QuickCommand, StepResultBreak } from './quickCommand';
-import { pickBranchOrTagStep, pickBranchStep, pickRepositoryStep } from './quickCommand.steps';
+import { pickBranchStep, pickOrResetBranchStep, pickRepositoryStep } from './quickCommand.steps';
 
 interface Context {
 	repos: Repository[];
@@ -84,25 +86,68 @@ export class ChangeBranchMergeTargetCommand extends QuickCommand {
 				state.branch = branches.name;
 			}
 
-			const result = yield* pickBranchOrTagStep(state, context, {
+			if (!state.mergeBranch) {
+				state.mergeBranch = await this.container.git
+					.branches(state.repo.path)
+					.getBaseBranchName?.(state.branch);
+			}
+
+			const gitBranch = await state.repo.git.branches().getBranch(state.branch);
+			const detectedMergeTarget = gitBranch && (await getDetectedMergeTarget(this.container, gitBranch));
+
+			const result = yield* pickOrResetBranchStep(state, context, {
 				picked: state.mergeBranch,
 				placeholder: 'Pick a merge target branch',
-				value: undefined,
-				filter: {
-					branches: (branch: GitBranch) => branch.remote && branch.name !== state.branch,
-					tags: () => false,
-				},
+				filter: (branch: GitBranch) => branch.remote && branch.name !== state.branch,
+				resetTitle: 'Reset Merge Target',
+				resetDescription: `Reset to "${detectedMergeTarget}"`,
 			});
 			if (result === StepResultBreak) {
 				continue;
 			}
-			if (result && state.branch) {
+			if (state.branch) {
 				await this.container.git
 					.branches(state.repo.path)
-					.setUserMergeTargetBranchName?.(state.branch, result.name);
+					.setUserMergeTargetBranchName?.(state.branch, result?.name);
 			}
 
 			endSteps(state);
 		}
 	}
 }
+
+async function getDetectedMergeTarget(
+	container: Container,
+	branch: GitBranch,
+	options?: { cancellation?: CancellationToken },
+): Promise<string | undefined> {
+	const [baseResult, defaultResult, targetResult] = await Promise.allSettled([
+		container.git.branches(branch.repoPath).getBaseBranchName?.(branch.name),
+		container.git.branches(branch.repoPath).getDefaultBranchName(branch.getRemoteName()),
+		container.git.branches(branch.repoPath).getTargetBranchName?.(branch.name),
+	]);
+
+	const baseBranchName = getSettledValue(baseResult);
+	const defaultBranchName = getSettledValue(defaultResult);
+	const targetMaybeResult = getSettledValue(targetResult);
+	const localValue = targetMaybeResult || baseBranchName || defaultBranchName;
+	if (localValue) {
+		return localValue;
+	}
+
+	// only if nothing found locally, try value from integration
+	return getIntegrationDefaultBranchName(container, branch.repoPath, options);
+}
+
+async function getIntegrationDefaultBranchName(
+	container: Container,
+	repoPath: string,
+	options?: { cancellation?: CancellationToken },
+): Promise<string | undefined> {
+	const remote = await container.git.remotes(repoPath).getBestRemoteWithIntegration();
+	if (remote == null) return undefined;
+
+	const integration = await remote.getIntegration();
+	const defaultBranch = await integration?.getDefaultBranch?.(remote.provider.repoDesc, options);
+	return defaultBranch && `${remote.name}/${defaultBranch?.name}`;
+}

src/commands/quickCommand.steps.ts

@@ -783,6 +783,84 @@ export function* pickBranchStep<
 	return canPickStepContinue(step, state, selection) ? selection[0].item : StepResultBreak;
 }
 
+export function* pickOrResetBranchStep<
+	State extends PartialStepState & { repo: Repository },
+	Context extends { repos: Repository[]; showTags?: boolean; title: string },
+>(
+	state: State,
+	context: Context,
+	{
+		filter,
+		picked,
+		placeholder,
+		title,
+		resetTitle,
+		resetDescription,
+	}: {
+		filter?: (b: GitBranch) => boolean;
+		picked?: string | string[];
+		placeholder: string;
+		title?: string;
+		resetTitle: string;
+		resetDescription: string;
+	},
+): StepResultGenerator<GitBranchReference | undefined> {
+	const items = getBranches(state.repo, {
+		buttons: [RevealInSideBarQuickInputButton],
+		filter: filter,
+		picked: picked,
+	}).then(branches =>
+		branches.length === 0
+			? [createDirectiveQuickPickItem(Directive.Back, true), createDirectiveQuickPickItem(Directive.Cancel)]
+			: [
+					createDirectiveQuickPickItem(Directive.Reset, false, {
+						label: resetTitle,
+						description: resetDescription,
+					}),
+					...branches,
+			  ],
+	);
+
+	const resetButton: QuickInputButton = {
+		iconPath: new ThemeIcon('notebook-revert'),
+		tooltip: resetDescription,
+	};
+	let resetButtonClicked = false;
+	const step = createPickStep<BranchQuickPickItem>({
+		title: appendReposToTitle(title ?? context.title, state, context),
+		placeholder: count => (!count ? `No branches found in ${state.repo.formattedName}` : placeholder),
+		matchOnDetail: true,
+		items: items,
+		additionalButtons: [resetButton],
+		onDidClickButton: (_quickpick, button) => {
+			if (button === resetButton) {
+				resetButtonClicked = true;
+				return true;
+			}
+			return false;
+		},
+		onDidClickItemButton: (_quickpick, button, { item }) => {
+			if (button === RevealInSideBarQuickInputButton) {
+				void BranchActions.reveal(item, { select: true, focus: false, expand: true });
+			}
+		},
+		keys: ['right', 'alt+right', 'ctrl+right'],
+		onDidPressKey: async (_quickpick, _key, { item }) => {
+			await BranchActions.reveal(item, {
+				select: true,
+				focus: false,
+				expand: true,
+			});
+		},
+	});
+
+	const selection: StepSelection<typeof step> = yield step;
+	if (resetButtonClicked) {
+		return undefined;
+	}
+	return canPickStepContinue(step, state, selection) ? selection[0].item : StepResultBreak;
+}
+
 export function* pickBranchesStep<
 	State extends PartialStepState & { repo: Repository },
 	Context extends { repos: Repository[]; showTags?: boolean; title: string },

src/git/gitProvider.ts

@@ -259,7 +259,7 @@ export interface GitBranchesSubProvider {
 	getTargetBranchName?(repoPath: string, ref: string): Promise<string | undefined>;
 	setTargetBranchName?(repoPath: string, ref: string, target: string): Promise<void>;
 	getUserMergeTargetBranchName?(repoPath: string, ref: string): Promise<string | undefined>;
-	setUserMergeTargetBranchName?(repoPath: string, ref: string, target: string): Promise<void>;
+	setUserMergeTargetBranchName?(repoPath: string, ref: string, target: string | undefined): Promise<void>;
 	renameBranch?(repoPath: string, oldName: string, newName: string): Promise<void>;
 }
 

src/quickpicks/items/directive.ts

@@ -5,6 +5,7 @@ import { pluralize } from '../../system/string';
 export enum Directive {
 	Back,
 	Cancel,
+	Reset,
 	LoadMore,
 	Noop,
 	Reload,
@@ -57,6 +58,9 @@ export function createDirectiveQuickPickItem(
 			case Directive.Reload:
 				label = 'Refresh';
 				break;
+			case Directive.Reset:
+				label = 'Reset';
+				break;
 			case Directive.SignIn:
 				label = 'Sign In';
 				break;