convert git rebase into git cmd

Author: sergiolms

src/commands/git/rebase.ts

@@ -4,10 +4,12 @@ import type { GitLog } from '../../git/models/log';
 import type { GitReference } from '../../git/models/reference';
 import { createRevisionRange, getReferenceLabel, isRevisionReference } from '../../git/models/reference';
 import type { Repository } from '../../git/models/repository';
+import { showGenericErrorMessage } from '../../messages';
 import type { DirectiveQuickPickItem } from '../../quickpicks/items/directive';
 import { createDirectiveQuickPickItem, Directive } from '../../quickpicks/items/directive';
 import type { FlagsQuickPickItem } from '../../quickpicks/items/flags';
 import { createFlagsQuickPickItem } from '../../quickpicks/items/flags';
+import { Logger } from '../../system/logger';
 import { pluralize } from '../../system/string';
 import { getEditorCommand } from '../../system/vscode/utils';
 import type { ViewsWithRepositoryFolders } from '../../views/viewBase';
@@ -79,15 +81,18 @@ export class RebaseGitCommand extends QuickCommand<State> {
 	}
 
 	async execute(state: RebaseStepState) {
-		let configs: string[] | undefined;
+		const configs: { sequenceEditor?: string } = {};
 		if (state.flags.includes('--interactive')) {
 			await this.container.rebaseEditor.enableForNextUse();
-
-			const editor = getEditorCommand();
-			configs = ['-c', `"sequence.editor=${editor}"`];
+			configs.sequenceEditor = getEditorCommand();
 		}
 
-		state.repo.rebase(configs, ...state.flags, state.destination.ref);
+		try {
+			await state.repo.git.rebase(state.destination.ref, configs, state.flags);
+		} catch (ex) {
+			Logger.error(ex, this.title);
+			void showGenericErrorMessage(ex);
+		}
 	}
 
 	protected async *steps(state: PartialStepState<State>): StepGenerator {

src/env/node/git/git.ts

@@ -20,6 +20,8 @@ import {
 	PullErrorReason,
 	PushError,
 	PushErrorReason,
+	RebaseError,
+	RebaseErrorReason,
 	StashPushError,
 	StashPushErrorReason,
 	TagError,
@@ -173,6 +175,11 @@ const tagErrorAndReason: [RegExp, TagErrorReason][] = [
 	[GitErrors.remoteRejected, TagErrorReason.RemoteRejected],
 ];
 
+const rebaseErrorAndReason: [RegExp, RebaseErrorReason][] = [
+	[GitErrors.uncommittedChanges, RebaseErrorReason.WorkingChanges],
+	[GitErrors.changesWouldBeOverwritten, RebaseErrorReason.OverwrittenChanges],
+];
+
 export class Git {
 	/** Map of running git commands -- avoids running duplicate overlaping commands */
 	private readonly pendingCommands = new Map<string, Promise<string | Buffer>>();
@@ -1092,6 +1099,21 @@ export class Git {
 		}
 	}
 
+	async rebase(repoPath: string, args: string[] | undefined = [], configs: string[] | undefined = []): Promise<void> {
+		try {
+			void (await this.git<string>({ cwd: repoPath }, ...configs, 'rebase', '--autostash', ...args));
+		} catch (ex) {
+			const msg: string = ex?.toString() ?? '';
+			for (const [regex, reason] of rebaseErrorAndReason) {
+				if (regex.test(msg) || regex.test(ex.stderr ?? '')) {
+					throw new RebaseError(reason, ex);
+				}
+			}
+
+			throw new RebaseError(RebaseErrorReason.Other, ex);
+		}
+	}
+
 	for_each_ref__branch(repoPath: string, options: { all: boolean } = { all: false }) {
 		const params = ['for-each-ref', `--format=${parseGitBranchesDefaultFormat}`, 'refs/heads'];
 		if (options.all) {

src/env/node/git/localGitProvider.ts

@@ -31,6 +31,7 @@ import {
 	PullError,
 	PushError,
 	PushErrorReason,
+	RebaseError,
 	StashApplyError,
 	StashApplyErrorReason,
 	StashPushError,
@@ -1658,6 +1659,37 @@ export class LocalGitProvider implements GitProvider, Disposable {
 		}
 	}
 
+	@log()
+	async rebase(
+		repoPath: string,
+		ref: string,
+		configs?: { sequenceEditor?: string },
+		options?: { interactive?: boolean } = {},
+	): Promise<void> {
+		const configFlags = [];
+		const args = [];
+
+		if (configs?.sequenceEditor != null) {
+			configFlags.push('-c', `sequence.editor="${configs.sequenceEditor}"`);
+		}
+
+		if (options?.interactive) {
+			args.push('--interactive');
+		}
+
+		args.push(ref);
+
+		try {
+			await this.git.rebase(repoPath, args, configFlags);
+		} catch (ex) {
+			if (RebaseError.is(ex)) {
+				throw ex.WithRef(ref);
+			}
+
+			throw ex;
+		}
+	}
+
 	private readonly toCanonicalMap = new Map<string, Uri>();
 	private readonly fromCanonicalMap = new Map<string, Uri>();
 	protected readonly unsafePaths = new Set<string>();

src/git/errors.ts

@@ -567,3 +567,65 @@ export class TagError extends Error {
 		return this;
 	}
 }
+
+export const enum RebaseErrorReason {
+	WorkingChanges,
+	OverwrittenChanges,
+	Other,
+}
+
+export class RebaseError extends Error {
+	static is(ex: unknown, reason?: RebaseErrorReason): ex is RebaseError {
+		return ex instanceof RebaseError && (reason == null || ex.reason === reason);
+	}
+
+	private static buildRebaseErrorMessage(reason?: RebaseErrorReason, ref?: string): string {
+		let baseMessage: string;
+		if (ref != null) {
+			baseMessage = `Unable to rebase onto ${ref}`;
+		} else {
+			baseMessage = `Unable to rebase`;
+		}
+
+		switch (reason) {
+			case RebaseErrorReason.WorkingChanges:
+				return `${baseMessage} because there are uncommitted changes`;
+			case RebaseErrorReason.OverwrittenChanges:
+				return `${baseMessage} because some local changes would be overwritten`;
+			default:
+				return baseMessage;
+		}
+	}
+
+	readonly original?: Error;
+	readonly reason: RebaseErrorReason | undefined;
+	ref?: string;
+
+	constructor(reason?: RebaseErrorReason, original?: Error);
+	constructor(message?: string, original?: Error);
+	constructor(messageOrReason: string | RebaseErrorReason | undefined, original?: Error, ref?: string) {
+		let reason: RebaseErrorReason | undefined;
+		if (typeof messageOrReason !== 'string') {
+			reason = messageOrReason as RebaseErrorReason;
+		} else {
+			super(messageOrReason);
+		}
+
+		const message =
+			typeof messageOrReason === 'string'
+				? messageOrReason
+				: RebaseError.buildRebaseErrorMessage(messageOrReason as RebaseErrorReason, ref);
+		super(message);
+
+		this.original = original;
+		this.reason = reason;
+		this.ref = ref;
+		Error.captureStackTrace?.(this, RebaseError);
+	}
+
+	WithRef(ref: string) {
+		this.ref = ref;
+		this.message = RebaseError.buildRebaseErrorMessage(this.reason, ref);
+		return this;
+	}
+}

src/git/gitProvider.ts

@@ -125,6 +125,12 @@ export interface GitProviderRepository {
 	addRemote?(repoPath: string, name: string, url: string, options?: { fetch?: boolean }): Promise<void>;
 	pruneRemote?(repoPath: string, name: string): Promise<void>;
 	removeRemote?(repoPath: string, name: string): Promise<void>;
+	rebase?(
+		repoPath: string,
+		ref: string,
+		configs?: { sequenceEditor?: string },
+		options?: { interactive?: boolean },
+	): Promise<void>;
 
 	applyUnreachableCommitForPatch?(
 		repoPath: string,

src/git/gitProviderService.ts

@@ -1342,6 +1342,21 @@ export class GitProviderService implements Disposable {
 		return provider.applyChangesToWorkingFile(uri, ref1, ref2);
 	}
 
+	@log()
+	rebase(repoPath: string | Uri, ref: string, configs: { sequenceEditor?: string }, args: string[] | undefined = []) {
+		const { provider, path } = this.getProvider(repoPath);
+		if (provider.rebase == null) throw new ProviderNotSupportedError(provider.descriptor.name);
+
+		const options: { interactive?: boolean } = {};
+		for (const arg of args) {
+			if (arg === '--interactive') {
+				options.interactive = true;
+			}
+		}
+
+		return provider.rebase(path, ref, configs, options);
+	}
+
 	@log()
 	async applyUnreachableCommitForPatch(
 		repoPath: string | Uri,

src/git/models/repository.ts

@@ -842,14 +842,6 @@ export class Repository implements Disposable {
 		}
 	}
 
-	@log()
-	rebase(configs: string[] | undefined, ...args: string[]) {
-		void this.runTerminalCommand(
-			configs != null && configs.length !== 0 ? `${configs.join(' ')} rebase` : 'rebase',
-			...args,
-		);
-	}
-
 	@log()
 	reset(...args: string[]) {
 		void this.runTerminalCommand('reset', ...args);