TEMP

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

Author: kiprasmel

git-stacked-rebase.ts

@@ -38,6 +38,7 @@ import { assertNever } from "./util/assertNever";
 import { Single, Tuple } from "./util/tuple";
 import { isDirEmptySync } from "./util/fs";
 import {
+    getParseTargetsCtxFromLine,
 	GoodCommand,
 	GoodCommandRegular,
 	GoodCommandStacked, //
@@ -46,6 +47,8 @@ import {
 	RegularRebaseEitherCommandOrAlias,
 	StackedRebaseCommand,
 	StackedRebaseCommandAlias,
+    stackedRebaseCommands,
+    Targets,
 } from "./parse-todo-of-stacked-rebase/validator";
 
 export * from "./options";
@@ -514,16 +517,8 @@ export async function gitStackedRebase(
 				if (cmd.commandName === "branch-end-new") {
 					await createBranchForCommand(cmd as any); // TODO TS
 				} else if (cmd.commandName === "branch-end-new-from-remote") {
-					const nameWithoutRefsRemotesOriginPrefix: string = cmd.targets![0];
-					const remote: string = cmd.targets![1];
-					const fullNameOfBranchWithRemote: string =
-						"refs/remotes/" + remote + "/" + nameWithoutRefsRemotesOriginPrefix;
-
-					branchesWhoNeedLocalCheckout.push({
-						nameWithoutRefsRemotesOriginPrefix,
-						remote,
-						fullNameOfBranchWithRemote,
-					});
+					const b = parseBranchWhichNeedsLocalCheckout(cmd.targets!); // TODO TS NARROWER TYPES
+					branchesWhoNeedLocalCheckout.push(b);
 				}
 			} else {
 				assertNever(cmd);
@@ -883,13 +878,17 @@ async function createInitialEditTodoOfGitStackedRebase(
 						 *
 						 */
 						if (branch.isRemote() || branch.name().startsWith("refs/remotes/")) {
-							const nameWithoutRefsRemotesOriginPrefix: string = branch
+							const wantedLocalBranchName: string = branch
 								.name()
 								.replace(removeRemoteRegex, "");
 
-							const remote: string = branch.name().match(removeRemoteRegex)![1];
+							const remoteName: string = branch.name().match(removeRemoteRegex)![1];
 
-							return `branch-end-new-from-remote ${nameWithoutRefsRemotesOriginPrefix} ${remote}`;
+							return encodeCmdToLine({
+								wantedLocalBranchName,
+								remoteName,
+								fullNameOfBranchWithRemote: getFullNameOfBranchWithRemote({ wantedLocalBranchName, remoteName })
+							})
 						} else {
 							return `branch-end ${branch.name()}`;
 						}
@@ -909,12 +908,49 @@ async function createInitialEditTodoOfGitStackedRebase(
 	return;
 }
 
-type BranchWhoNeedsLocalCheckout = {
-	nameWithoutRefsRemotesOriginPrefix: string; //
-	remote: string;
+export type BranchWhoNeedsLocalCheckout = {
+	wantedLocalBranchName: string; //
+	remoteName: string;
 	fullNameOfBranchWithRemote: string;
 };
 
+/**
+ * expects targets from the format of "branch-end-new-from-remote"
+ * TODO TS NARROWER TYPES (specific targets for each type of cmd)
+ */
+export function parseBranchWhichNeedsLocalCheckout(targets: NonNullable<Targets>): BranchWhoNeedsLocalCheckout {
+	const wantedLocalBranchName: string = targets[0];
+	const remoteAndRemoteBranchName: string = targets[1];
+	const remoteName: string = remoteAndRemoteBranchName.split("/")[0];
+	const fullNameOfBranchWithRemote: string = getFullNameOfBranchWithRemote({ fullNameOfBranchWithRemote: remoteAndRemoteBranchName });
+
+	return {
+		wantedLocalBranchName,
+		remoteName,
+		fullNameOfBranchWithRemote,
+	}
+}
+
+function getFullNameOfBranchWithRemote(b: Pick<BranchWhoNeedsLocalCheckout, "fullNameOfBranchWithRemote"> | Pick<BranchWhoNeedsLocalCheckout, "wantedLocalBranchName" | "remoteName">): string {
+	return "refs/remotes/" + (
+		"fullNameOfBranchWithRemote" in b
+			? b.fullNameOfBranchWithRemote
+			: b.remoteName + "/" + b.wantedLocalBranchName
+	);
+}
+
+// TODO RENAME
+export function encodeCmdToLine(b: BranchWhoNeedsLocalCheckout) {
+	return `branch-end-new-from-remote ${b.wantedLocalBranchName} ${b.fullNameOfBranchWithRemote}`;
+}
+
+// TODO RENAME
+export function decodeLineToCmd(line: string): BranchWhoNeedsLocalCheckout {
+	// TODO TS NARROWER TYPES
+	const targets: NonNullable<Targets> = stackedRebaseCommands["branch-end-new-from-remote"].parseTargets(getParseTargetsCtxFromLine(line))!
+	return parseBranchWhichNeedsLocalCheckout(targets);
+}
+
 function checkoutRemotePartialBranchesLocally(
 	repo: Git.Repository, //
 	currentBranch: Git.Reference,
@@ -929,7 +965,7 @@ function checkoutRemotePartialBranchesLocally(
 	const execSyncInRepo = createExecSyncInRepo(repo);
 
 	for (const b of branchesWhoNeedLocalCheckout) {
-		const cmd = `git checkout -b ${b.nameWithoutRefsRemotesOriginPrefix} --track ${b.fullNameOfBranchWithRemote}`;
+		const cmd = `git checkout -b ${b.wantedLocalBranchName} --track ${b.fullNameOfBranchWithRemote}`;
 		execSyncInRepo(cmd);
 	}
 

humanOp.ts

@@ -59,6 +59,12 @@ export function humanOpRemoveLineOfCommit({ filePath, commitSHA }: CommonArgs):
 	writeLines(filePath, lines);
 }
 
+export function modifyLines(filePath: string, modifier = (lines: string[]) => lines): void {
+	const lines: string[] = readLines(filePath);
+	const modifiedLines: string[] = modifier(lines);
+	writeLines(filePath, modifiedLines);
+};
+
 export function readLines(filePath: string): string[] {
 	const file = fs.readFileSync(filePath, { encoding: "utf-8" });
 	const lines = file.split("\n");

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

@@ -10,11 +10,14 @@ import { Termination } from "../util/error";
  */
 type Validator = (ctx: { rest: string; reasonsIfBad: string[] }) => boolean;
 
-type ParseTargets = (ctx: {
+export type Targets = string[] | null;
+
+type ParseTargetsCtx = {
 	line: string; //
 	split: string[];
 	rest: string;
-}) => string[] | null;
+}
+type ParseTargets = (ctx: ParseTargetsCtx) => Targets
 
 type Command = {
 	/**
@@ -428,7 +431,7 @@ export function validate(
 		nthCommand++;
 
 		const [commandOrAliasName, ..._rest] = fullLine.split(" ");
-		const rest = _rest.join(" ");
+		const rest = getRest(fullLine);
 
 		if (!commandOrAliasExists(commandOrAliasName)) {
 			badCommands.push({
@@ -482,13 +485,11 @@ export function validate(
 
 		const command: Command = allEitherRebaseCommands[commandName];
 
+		/**
+		 * TODO TS NARROWER TYPES: combine the 2 below:
+		 */
 		command.isRestValid({ rest, reasonsIfBad });
-
-		const targets: string[] | null = command.parseTargets({
-			line: fullLine, //
-			split: fullLine.split(" ").filter((word) => !!word),
-			rest,
-		});
+		const targets: Targets = command.parseTargets(getParseTargetsCtxFromLine(fullLine));
 
 		if (reasonsIfBad.length) {
 			badCommands.push({
@@ -548,3 +549,16 @@ export function validate(
 
 	return goodCommands;
 }
+
+export function getParseTargetsCtxFromLine(fullLine: string): ParseTargetsCtx {
+	return {
+		line: fullLine, //
+		split: fullLine.split(" ").filter((word) => !!word),
+		rest: getRest(fullLine),
+	}
+}
+
+export function getRest(fullLine: string): ParseTargetsCtx["rest"] {
+	return fullLine.split(" ").slice(1).join(" ")
+}
+

test/auto-checkout-remote-partial-branches.spec.ts

@@ -5,14 +5,19 @@
 
 import assert from "assert";
 
-import { gitStackedRebase } from "../git-stacked-rebase";
+import { BranchWhoNeedsLocalCheckout, decodeLineToCmd, encodeCmdToLine, gitStackedRebase } from "../git-stacked-rebase";
 import { editor__internal } from "../internal";
 import { nativeGetBranchNames } from "../native-git/branch";
+import { modifyLines } from "../humanOp";
 
 import { setupRemoteRepo } from "./util/setupRemoteRepo";
+import { noop } from "../util/noop";
 
 export default async function run() {
 	await auto_checks_out_remote_partial_branches();
+	//noop(auto_checks_out_remote_partial_branches)
+	noop(give_chosen_name_to_local_branch)
+	//await give_chosen_name_to_local_branch();
 }
 
 async function auto_checks_out_remote_partial_branches() {
@@ -39,8 +44,8 @@ async function auto_checks_out_remote_partial_branches() {
 	);
 
 	await gitStackedRebase(RemoteAlice.initialBranch, {
-		[editor__internal]: () => void 0 /** no edit */,
 		gitDir: LocalBob.repo.workdir(),
+		[editor__internal]: () => void 0 /** no edit */,
 	});
 
 	const localPartialBranchesInBobAfter: string[] = findPartialBranchesThatArePresentLocally();
@@ -58,6 +63,70 @@ async function auto_checks_out_remote_partial_branches() {
 	);
 }
 
+async function give_chosen_name_to_local_branch() {
+	const { RemoteAlice, LocalBob } = await setupRemoteRepo();
+
+	/**
+	 * switch to latest branch to perform stacked rebase
+	 */
+	LocalBob.execSyncInRepo(`git checkout ${RemoteAlice.latestStackedBranchName}`);
+
+	const remotePartialBranchesInAlice: string[] = RemoteAlice.partialBranches.map((b) => b.shorthand());
+	const localPartialBranchesInBobBefore: string[] = findPartialBranchesThatArePresentLocally();
+
+	function findPartialBranchesThatArePresentLocally(
+		localBranches: string[] = nativeGetBranchNames(LocalBob.repo.workdir())("local")
+	) {
+		return remotePartialBranchesInAlice.filter((partial) => localBranches.includes(partial));
+	}
+
+	assert.deepStrictEqual(
+		localPartialBranchesInBobBefore.length,
+		0,
+		"expected partial branches to __not be__ checked out locally, to be able to test later that they will be."
+	);
+	
+	const renamedLocalBranch = "renamed-local-branch-hehe" as const;
+
+	await gitStackedRebase(RemoteAlice.initialBranch, {
+		gitDir: LocalBob.repo.workdir(),
+		[editor__internal]: ({filePath}) => {
+			const branchNameOf2ndBranch: string = RemoteAlice.newPartialBranches[1][0];
+			modifyLines(filePath, (lines) => {
+				const lineIdx: number = lines.findIndex(l => l.includes(branchNameOf2ndBranch))!
+				const line: string = lines[lineIdx];
+				const cmd: BranchWhoNeedsLocalCheckout = decodeLineToCmd(line)
+				console.log({
+					lineIdx,
+					line,
+					cmd
+				})
+				const newCmd: BranchWhoNeedsLocalCheckout = {
+					...cmd,
+					wantedLocalBranchName: renamedLocalBranch,
+				}
+				const newLine: string = encodeCmdToLine(newCmd)
+				const newLines: string[] = lines.map((oldLine, i) => i === lineIdx ? newLine : oldLine)
+				return newLines;
+			})
+		},
+	});
+
+	const localPartialBranchesInBobAfter: string[] = findPartialBranchesThatArePresentLocally();
+
+	console.log({
+		remotePartialBranchesInAlice,
+		localPartialBranchesInBobBefore,
+		localPartialBranchesInBobAfter,
+	});
+
+	assert.deepStrictEqual(
+		localPartialBranchesInBobAfter.length,
+		remotePartialBranchesInAlice.length,
+		"expected partial branches to __be__ checked out locally by git-stacked-rebase."
+	);
+};
+
 if (!module.parent) {
 	run();
 }