convert deleteBranches into deleteBranch and call multiple times

Author: sergiolms

src/commands/git/branch.ts

@@ -401,7 +401,7 @@ export class BranchGitCommand extends QuickCommand {
 				} catch (ex) {
 					Logger.error(ex);
 					// TODO likely need some better error handling here
-					return showGenericErrorMessage(new BranchError(ex.reason, ex, state.name).message);
+					return showGenericErrorMessage(ex.WithBranch(state.name));
 				}
 			}
 		}
@@ -518,17 +518,17 @@ export class BranchGitCommand extends QuickCommand {
 
 			endSteps(state);
 
-			try {
-				await state.repo.git.deleteBranches(state.references, {
-					force: state.flags.includes('--force'),
-					remote: state.flags.includes('--remotes'),
-				});
-			} catch (ex) {
-				Logger.error(ex);
-				// TODO likely need some better error handling here
-				return showGenericErrorMessage(
-					new BranchError(ex.reason, ex, state.references.map(r => r.name).join(', ')).message,
-				);
+			for (const ref of state.references) {
+				try {
+					await state.repo.git.deleteBranch(ref, {
+						force: state.flags.includes('--force'),
+						remote: state.flags.includes('--remotes'),
+					});
+				} catch (ex) {
+					Logger.error(ex);
+					// TODO likely need some better error handling here
+					return showGenericErrorMessage(ex.WithBranch(ref.name));
+				}
 			}
 		}
 	}
@@ -637,7 +637,7 @@ export class BranchGitCommand extends QuickCommand {
 			} catch (ex) {
 				Logger.error(ex);
 				// TODO likely need some better error handling here
-				return showGenericErrorMessage(new BranchError(ex.reason, ex, state.name).message);
+				return showGenericErrorMessage(ex.WithBranch(state.name));
 			}
 		}
 	}

src/env/node/git/git.ts

@@ -987,7 +987,7 @@ export class Git {
 			upstream?: string;
 			delete?: {
 				remote: string;
-				branches: string[];
+				branch: string;
 			};
 		},
 	): Promise<void> {
@@ -1017,7 +1017,7 @@ export class Git {
 		} else if (options.remote) {
 			params.push(options.remote);
 		} else if (options.delete) {
-			params.push('-d', options.delete.remote, ...options.delete.branches);
+			params.push('-d', options.delete.remote, options.delete.branch);
 		}
 
 		try {

src/env/node/git/localGitProvider.ts

@@ -1251,77 +1251,51 @@ export class LocalGitProvider implements GitProvider, Disposable {
 	}
 
 	@log()
-	async deleteBranches(
+	async deleteBranch(
 		repoPath: string,
-		branches: GitBranchReference[],
+		branch: GitBranchReference,
 		options: { force?: boolean; remote?: boolean },
 	): Promise<void> {
-		const localBranches = branches.filter((b: GitBranchReference) => !b.remote);
-		if (localBranches.length !== 0) {
-			const args = ['--delete'];
-			if (options.force) {
-				args.push('--force');
-			}
-
-			if (options.remote) {
-				const trackingBranches = localBranches.filter(b => b.upstream != null);
-				if (trackingBranches.length !== 0) {
-					const branchesByOrigin = groupByMap(trackingBranches, b =>
-						getRemoteNameFromBranchName(b.upstream!.name),
-					);
-
-					for (const [remote, branches] of branchesByOrigin.entries()) {
-						const remoteCommitByBranch: Map<string, string> = {};
-						branches.forEach(async b => {
-							remoteCommit = await this.git.rev_list(repoPath, `refs/remotes/${remote}/${b.ref}`, {
-								maxResults: 1,
-							});
-							remoteCommitByBranch[b.ref] = remoteCommit;
-						});
+		if (branch.remote) {
+			return this.git.push(repoPath, {
+				delete: {
+					remote: getRemoteNameFromBranchName(branch.name),
+					branch: branch.remote ? getBranchNameWithoutRemote(branch.name) : branch.name,
+				},
+			});
+		}
 
-						await this.git.branch(
-							repoPath,
-							'--delete',
-							'--remotes',
-							...branches.map((b: GitBranchReference) => `${remote}/${b.ref}`),
-						);
+		const args = ['--delete'];
+		if (options.force) {
+			args.push('--force');
+		}
 
-						try {
-							await this.git.branch(repoPath, ...args, ...branches.map((b: GitBranchReference) => b.ref));
-							await this.git.push(repoPath, {
-								delete: {
-									remote: remote,
-									branches: branches.map(b => getBranchNameWithoutRemote(b.upstream!.name)),
-								},
-							});
-						} catch (ex) {
-							// If it fails, restore the remote branches
-							remoteCommitByBranch.forEach(async (branch, commit) => {
-								await this.git.update_ref(repoPath, `refs/remotes/${remote}/${branch}`, commit);
-								await this.git.branch__set_upstream(repoPath, branch, remote, branch);
-							});
-							throw ex;
-						}
-					}
-				}
-			}
+		if (!options.remote || !branch.upstream) {
+			return this.git.branch(repoPath, ...args, branch.ref);
 		}
 
-		const remoteBranches = branches.filter((b: GitBranchReference) => b.remote);
-		if (remoteBranches.length !== 0) {
-			const branchesByOrigin = groupByMap(remoteBranches, b => getRemoteNameFromBranchName(b.name));
+		const remote = getRemoteNameFromBranchName(branch.upstream.name);
+		remoteCommit = await this.git.rev_list(repoPath, `refs/remotes/${remote}/${branch.ref}`, {
+			maxResults: 1,
+		});
 
-			for (const [remote, branches] of branchesByOrigin.entries()) {
-				await this.git.push(repoPath, {
-					delete: {
-						remote: remote,
-						branches: branches.map((b: GitBranchReference) =>
-							b.remote ? getBranchNameWithoutRemote(b.name) : b.name,
-						),
-					},
-				});
-			}
+		await this.git.branch(repoPath, '--delete', '--remotes', `${remote}/${branch.ref}`);
+
+		try {
+			await this.git.branch(repoPath, ...args, branch.ref);
+		} catch (ex) {
+			// If it fails, restore the remote branch
+			await this.git.update_ref(repoPath, `refs/remotes/${remote}/${branch.ref}`, commit);
+			await this.git.branch__set_upstream(repoPath, branch, remote, branch);
+			throw ex;
 		}
+
+		await this.git.push(repoPath, {
+			delete: {
+				remote: remote,
+				branch: getBranchNameWithoutRemote(branch.upstream.name),
+			},
+		});
 	}
 
 	@log()

src/git/gitProvider.ts

@@ -115,9 +115,9 @@ export interface RepositoryVisibilityInfo {
 export interface GitProviderRepository {
 	createBranch?(repoPath: string, name: string, ref: string): Promise<void>;
 	renameBranch?(repoPath: string, oldName: string, newName: string): Promise<void>;
-	deleteBranches?(
+	deleteBranch?(
 		repoPath: string,
-		branches: GitBranchReference | GitBranchReference[],
+		branches: GitBranchReference,
 		options?: { force?: boolean; remote?: boolean },
 	): Promise<void>;
 	addRemote?(repoPath: string, name: string, url: string, options?: { fetch?: boolean }): Promise<void>;

src/git/gitProviderService.ts

@@ -1355,19 +1355,15 @@ export class GitProviderService implements Disposable {
 	}
 
 	@log()
-	deleteBranches(
+	deleteBranch(
 		repoPath: string,
-		branches: GitBranchReference | GitBranchReference[],
+		branch: GitBranchReference,
 		options?: { force?: boolean; remote?: boolean },
 	): Promise<void> {
 		const { provider, path } = this.getProvider(repoPath);
-		if (provider.deleteBranches == null) throw new ProviderNotSupportedError(provider.descriptor.name);
+		if (provider.deleteBranch == null) throw new ProviderNotSupportedError(provider.descriptor.name);
 
-		if (!Array.isArray(branches)) {
-			branches = [branches];
-		}
-
-		return provider.deleteBranches(path, branches, {
+		return provider.deleteBranch(path, branch, {
 			force: options?.force,
 			remote: options?.remote,
 		});