strongly refactor branchSequencer to work with simple boundaries (branch & commit)

Signed-off-by: Kipras Melnikovas <kipras@kipras.org>

Author: kiprasmel

apply.ts

@@ -4,7 +4,6 @@ import path from "path";
 import Git from "nodegit";
 
 import { createQuestion } from "./util/createQuestion";
-import { noop } from "./util/noop";
 
 import { filenames } from "./filenames";
 import { configKeys } from "./configKeys";
@@ -13,7 +12,6 @@ import {
 	BranchSequencerBase, //
 	branchSequencer,
 	ActionInsideEachCheckedOutBranch,
-	CallbackAfterDone,
 	BranchSequencerArgsBase,
 } from "./branchSequencer";
 import { combineRewrittenLists } from "./reducePath";
@@ -32,13 +30,12 @@ const defaultApplyAction: ActionInsideEachCheckedOutBranch = async ({
 	repo, //
 	// targetBranch,
 	targetCommitSHA,
-	cmd,
 	isFinalCheckout,
 	// execSyncInRepo,
 }) => {
 	const commit: Git.Commit = await Git.Commit.lookup(repo, targetCommitSHA);
 
-	console.log("will reset because", cmd.commandOrAliasName, "to commit", commit.summary(), commit.sha());
+	console.log("will reset to commit", commit.sha(), "(" + commit.summary() + ")");
 
 	console.log({ isFinalCheckout });
 
@@ -54,36 +51,6 @@ const defaultApplyAction: ActionInsideEachCheckedOutBranch = async ({
 export const getBackupPathOfPreviousStackedRebase = (pathToStackedRebaseDirInsideDotGit: string): string =>
 	pathToStackedRebaseDirInsideDotGit + ".previous";
 
-/**
- * disabled because `forcePush` also became a thing
- * and it's no longer clear what marks a stacked-rebase "done",
- *
- * thus making it hard to work with the temporary/previous directories
- * without introducing a good amount of bugs.
- *
- */
-const defaultApplyCallback__disabled: CallbackAfterDone = ({
-	pathToStackedRebaseDirInsideDotGit, //
-}): void => {
-	const backupPath: string = getBackupPathOfPreviousStackedRebase(pathToStackedRebaseDirInsideDotGit);
-
-	/**
-	 * backup dir just in case, but in inactive path
-	 * (so e.g --apply won't go off again accidently)
-	 */
-	if (fs.existsSync(backupPath)) {
-		fs.rmdirSync(backupPath, { recursive: true });
-	}
-	fs.renameSync(pathToStackedRebaseDirInsideDotGit, backupPath);
-
-	// diffCommands.forEach((cmd) => {
-	// 	console.log({ cmd });
-	// 	execSyncInRepo(cmd, { ...pipestdio(repo.workdir()) });
-	// });
-	//
-};
-noop(defaultApplyCallback__disabled);
-
 export type ReturnOfApplyIfNeedsToApply = {
 	markThatNeedsToApply: () => void;
 } & (

branchSequencer.ts

@@ -7,67 +7,26 @@ import { createExecSyncInRepo } from "./util/execSyncInRepo";
 import { Termination } from "./util/error";
 
 import { parseNewGoodCommands } from "./parse-todo-of-stacked-rebase/parseNewGoodCommands";
-import { GoodCommand } from "./parse-todo-of-stacked-rebase/validator";
+import { GoodCommand, GoodCommandStacked } from "./parse-todo-of-stacked-rebase/validator";
 
-export type ActionInsideEachCheckedOutBranch = (ctx: ArgsForActionInsideEachCheckedOutBranch) => void | Promise<void>;
-
-/**
- *
- */
-
-export type ArgsForActionInsideEachCheckedOutBranch = {
-	repo: Git.Repository; //
-	targetBranch: string;
-	targetCommitSHA: string;
-	cmd: GoodCommand;
-	isFinalCheckout: boolean;
-	execSyncInRepo: ReturnType<typeof createExecSyncInRepo>;
-};
-
-/**
- *
- */
-
-export type CtxForCallbackAfterDone = {
+export type GetBranchesCtx = {
 	pathToStackedRebaseDirInsideDotGit: string;
-};
-
-export type CallbackAfterDone = (ctx: CtxForCallbackAfterDone) => void | Promise<void>;
-
-/**
- *
- */
-
-export type BranchSequencerArgsBase = {
-	pathToStackedRebaseDirInsideDotGit: string; //
-	// goodCommands: GoodCommand[];
-	pathToStackedRebaseTodoFile: string;
-	repo: Git.Repository;
 	rootLevelCommandName: string;
-	gitCmd: string;
+	repo: Git.Repository;
+	pathToStackedRebaseTodoFile: string;
 };
-
-export type BranchSequencerArgs = BranchSequencerArgsBase & {
-	// callbackBeforeBegin?: CallbackAfterDone; // TODO
-	actionInsideEachCheckedOutBranch: ActionInsideEachCheckedOutBranch;
-	delayMsBetweenCheckouts?: number;
-	callbackAfterDone?: CallbackAfterDone;
+export type SimpleBranchAndCommit = {
+	commitSHA: string | null;
+	branchEndFullName: string;
+	// branchExistsYet: boolean; // TODO
 };
+export type GetBoundariesInclInitial = (ctx: GetBranchesCtx) => SimpleBranchAndCommit[];
 
-export type BranchSequencerBase = (args: BranchSequencerArgsBase) => Promise<void>;
-export type BranchSequencer = (args: BranchSequencerArgs) => Promise<void>;
-
-export const branchSequencer: BranchSequencer = async ({
+const defautlGetBoundariesInclInitial: GetBoundariesInclInitial = ({
 	pathToStackedRebaseDirInsideDotGit, //
-	// goodCommands,
-	pathToStackedRebaseTodoFile,
-	repo,
 	rootLevelCommandName,
-	delayMsBetweenCheckouts = 0,
-	// callbackBeforeBegin,
-	actionInsideEachCheckedOutBranch,
-	callbackAfterDone = (): void => {},
-	gitCmd,
+	repo,
+	pathToStackedRebaseTodoFile,
 }) => {
 	/**
 	 * TODO REMOVE / modify this logic (see next comment)
@@ -122,74 +81,102 @@ export const branchSequencer: BranchSequencer = async ({
 	 */
 	const stackedRebaseCommandsNew: GoodCommand[] = parseNewGoodCommands(repo, pathToStackedRebaseTodoFile);
 
-	// const remotes: Git.Remote[] = await repo.getRemotes();
-	// const remote: Git.Remote | undefined = remotes.find((r) =>
-	// 	stackedRebaseCommandsOld.find((cmd) => cmd.targets && cmd.targets[0].includes(r.name()))
-	// );
+	for (const cmd of stackedRebaseCommandsNew) {
+		assert(cmd.rebaseKind === "stacked");
+		assert(cmd.targets?.length);
+	}
 
-	// const diffCommands: string[] = stackedRebaseCommandsOld
-	// 	.map((cmd, idx) => {
-	// 		const otherCmd: GoodCommand = stackedRebaseCommandsNew[idx];
-	// 		assert(cmd.commandName === otherCmd.commandName);
-	// 		assert(cmd.targets?.length);
-	// 		assert(otherCmd.targets?.length);
-	// 		assert(cmd.targets.every((t) => otherCmd.targets?.every((otherT) => t === otherT)));
+	return (stackedRebaseCommandsNew //
+		.filter((cmd) => cmd.rebaseKind === "stacked") as GoodCommandStacked[]) //
+		.map(
+			(cmd): SimpleBranchAndCommit => ({
+				commitSHA: cmd.commitSHAThatBranchPointsTo,
+				branchEndFullName: cmd.targets![0],
+			})
+		);
+};
 
-	// 		const trim = (str: string): string => str.replace("refs/heads/", "").replace("refs/remotes/", "");
+/**
+ *
+ */
 
-	// 		return !remote || idx === 0 // || idx === stackedRebaseCommandsOld.length - 1
-	// 			? ""
-	// 			: `git -c core.pager='' diff -u ${remote.name()}/${trim(cmd.targets[0])} ${trim(
-	// 					otherCmd.targets[0]
-	// 			  )}`;
-	// 	})
-	// 	.filter((cmd) => !!cmd);
+export type ActionInsideEachCheckedOutBranchCtx = {
+	repo: Git.Repository; //
+	targetBranch: string;
+	targetCommitSHA: string;
+	isFinalCheckout: boolean;
+	execSyncInRepo: ReturnType<typeof createExecSyncInRepo>;
+};
+export type ActionInsideEachCheckedOutBranch = (ctx: ActionInsideEachCheckedOutBranchCtx) => void | Promise<void>;
 
+export type BranchSequencerArgsBase = {
+	pathToStackedRebaseDirInsideDotGit: string; //
+	// goodCommands: GoodCommand[];
+	pathToStackedRebaseTodoFile: string;
+	repo: Git.Repository;
+	rootLevelCommandName: string;
+	gitCmd: string;
+};
+export type BranchSequencerArgs = BranchSequencerArgsBase & {
+	// callbackBeforeBegin?: CallbackAfterDone; // TODO
+	actionInsideEachCheckedOutBranch: ActionInsideEachCheckedOutBranch;
+	delayMsBetweenCheckouts?: number;
 	/**
-	 * first actually reset, only then diff
+	 *
 	 */
+	getBoundariesInclInitial?: GetBoundariesInclInitial;
+};
 
-	// const commitsWithBranchBoundaries: CommitAndBranchBoundary[] = (
-	// 	await getWantedCommitsWithBranchBoundaries(
-	// 		repo, //
-	// 		initialBranch
-	// 	)
-	// ).reverse();
-
-	// const previousTargetBranchName: string = stackedRebaseCommandsNew[0]
-	// 	? stackedRebaseCommandsNew[0].targets?.[0] ?? ""
-	// 	: "";
+export type BranchSequencerBase = (args: BranchSequencerArgsBase) => Promise<void>;
+export type BranchSequencer = (args: BranchSequencerArgs) => Promise<void>;
 
+export const branchSequencer: BranchSequencer = async ({
+	pathToStackedRebaseDirInsideDotGit, //
+	pathToStackedRebaseTodoFile,
+	repo,
+	rootLevelCommandName,
+	delayMsBetweenCheckouts = 0,
+	// callbackBeforeBegin,
+	actionInsideEachCheckedOutBranch,
+	gitCmd,
+	//
+	getBoundariesInclInitial = defautlGetBoundariesInclInitial,
+}) => {
 	const execSyncInRepo = createExecSyncInRepo(repo);
 
-	const checkout = async (cmds: GoodCommand[]): Promise<void> => {
-		if (!cmds.length) {
+	const branchesAndCommits: SimpleBranchAndCommit[] = getBoundariesInclInitial({
+		pathToStackedRebaseDirInsideDotGit,
+		pathToStackedRebaseTodoFile,
+		repo,
+		rootLevelCommandName,
+	});
+
+	return checkout(branchesAndCommits.slice(1) as any); // TODO TS
+
+	async function checkout(boundaries: SimpleBranchAndCommit[]): Promise<void> {
+		if (!boundaries.length) {
 			return;
 		}
 
-		console.log("\ncheckout", cmds.length);
+		console.log("\ncheckout", boundaries.length);
 
 		const goNext = () =>
 			new Promise<void>((r) => {
 				setTimeout(() => {
-					checkout(cmds.slice(1)).then(() => r());
+					checkout(boundaries.slice(1)).then(() => r());
 				}, delayMsBetweenCheckouts);
 			});
 
-		const cmd = cmds[0];
-
-		assert(cmd.rebaseKind === "stacked");
-
-		const targetCommitSHA: string | null = cmd.commitSHAThatBranchPointsTo;
+		const boundary = boundaries[0];
+		const branch = boundary.branchEndFullName;
+		const targetCommitSHA: string | null = boundary.commitSHA;
 
 		if (!targetCommitSHA) {
 			return goNext();
 		}
 
-		assert(cmd.targets?.length);
-
-		let targetBranch = cmd.targets[0].replace("refs/heads/", "");
-		assert(targetBranch && typeof targetBranch === "string");
+		let targetBranch = branch.replace("refs/heads/", "");
+		assert(targetBranch);
 
 		/**
 		 * if we only have the remote branch, but it's not checked out locally,
@@ -246,7 +233,7 @@ export const branchSequencer: BranchSequencer = async ({
 		/**
 		 * meaning we're on the latest branch
 		 */
-		const isFinalCheckout: boolean = cmds.length === 1;
+		const isFinalCheckout: boolean = boundaries.length === 1;
 
 		/**
 		 * https://libgit2.org/libgit2/#HEAD/group/checkout/git_checkout_head
@@ -258,22 +245,10 @@ export const branchSequencer: BranchSequencer = async ({
 			repo, //
 			targetBranch,
 			targetCommitSHA,
-			cmd,
 			isFinalCheckout,
 			execSyncInRepo,
 		});
 
 		return goNext();
-
-		// for (const cmd of stackedRebaseCommandsNew) {
-		// 	};
-	};
-
-	await checkout(stackedRebaseCommandsNew.slice(1) as any); // TODO TS
-
-	await callbackAfterDone({
-		pathToStackedRebaseDirInsideDotGit,
-	});
-
-	return;
+	}
 };

parse-todo-of-stacked-rebase/validator.ts

@@ -267,7 +267,7 @@ type BadCommand = {
 	reasons: string[];
 };
 
-export type GoodCommand = {
+export type GoodCommandBase = {
 	commandOrAliasName: EitherRebaseEitherCommandOrAlias;
 	lineNumber: number;
 	fullLine: string;
@@ -280,17 +280,17 @@ export type GoodCommand = {
 	index: number;
 
 	// commandName: EitherRebaseCommand;
-} & (
-	| {
-			rebaseKind: "regular";
-			commandName: RegularRebaseCommand;
-	  }
-	| {
-			rebaseKind: "stacked";
-			commandName: StackedRebaseCommand;
-			commitSHAThatBranchPointsTo: string | null;
-	  }
-);
+};
+export type GoodCommandRegular = GoodCommandBase & {
+	rebaseKind: "regular";
+	commandName: RegularRebaseCommand;
+};
+export type GoodCommandStacked = GoodCommandBase & {
+	rebaseKind: "stacked";
+	commandName: StackedRebaseCommand;
+	commitSHAThatBranchPointsTo: string | null;
+};
+export type GoodCommand = GoodCommandRegular | GoodCommandStacked;
 
 export function validate(
 	linesOfEditedRebaseTodo: string[], //