🐛 Fix remote detection with branch names containing slashes

Close #9

Author: lambdalisue

util.ts

@@ -1,19 +1,19 @@
-import { common } from "https://deno.land/[email protected]/path/mod.ts";
 import { execute, ExecuteOptions } from "./process.ts";
 
 export async function getRemoteContains(
   commitish: string,
   options: ExecuteOptions = {},
 ): Promise<string | undefined> {
-  const stdout = await execute(
+  const branches = (await execute(
     ["branch", "-r", "--contains", commitish, "--format=%(refname:short)"],
     options,
-  );
-  const result = common(stdout.trim().split("\n"));
-  if (!result) {
-    return undefined;
-  }
-  return result?.substring(0, result.length - 1);
+  )).trim().split("\n");
+  const remotes = (await execute(["remote"], options)).trim().split("\n");
+  const remoteContains = remotes.filter((remote) => {
+    return branches.some((branch) => branch.startsWith(`${remote}/`));
+  });
+  // Prefer "origin" if it exists
+  return remoteContains.includes("origin") ? "origin" : remoteContains.at(0);
 }
 
 export async function getRemoteFetchURL(

util_test.ts

@@ -16,6 +16,9 @@ Deno.test("getRemoteContains", async (t) => {
     "returns undefined if no remote contains the commitish",
     async () => {
       const executeStub = stub(_internals, "execute", (args, _options) => {
+        if (args.at(0) === "remote") {
+          return Promise.resolve("origin\nfork\n");
+        }
         if (args.at(0) === "branch") {
           return Promise.resolve("\n");
         }
@@ -34,6 +37,9 @@ Deno.test("getRemoteContains", async (t) => {
     "returns 'origin' if 'origin/my-awesome-branch' contains the commitish",
     async () => {
       const executeStub = stub(_internals, "execute", (args, _options) => {
+        if (args.at(0) === "remote") {
+          return Promise.resolve("origin\nfork\n");
+        }
         if (args.at(0) === "branch") {
           return Promise.resolve("origin/my-awesome-branch\n");
         }
@@ -52,11 +58,35 @@ Deno.test("getRemoteContains", async (t) => {
     "returns 'origin' if 'origin/HEAD' and 'origin/my-awesome-branch' contains the commitish",
     async () => {
       const executeStub = stub(_internals, "execute", (args, _options) => {
+        if (args.at(0) === "remote") {
+          return Promise.resolve("origin\nfork\n");
+        }
         if (args.at(0) === "branch") {
           return Promise.resolve("origin/HEAD\norigin/my-awesome-branch\n");
         }
         unreachable();
       });
+      try {
+        const remote = await getRemoteContains("<<commitish>>");
+        assertEquals(remote, "origin");
+      } finally {
+        executeStub.restore();
+      }
+    },
+  );
+
+  await t.step(
+    "returns 'fork' if 'fork/my-awesome-branch' contains the commitish",
+    async () => {
+      const executeStub = stub(_internals, "execute", (args, _options) => {
+        if (args.at(0) === "remote") {
+          return Promise.resolve("origin\nfork\n");
+        }
+        if (args.at(0) === "branch") {
+          return Promise.resolve("fork/my-awesome-branch\n");
+        }
+        unreachable();
+      });
       try {
         const remote = await getRemoteContains("<<commitish>>");
         assertEquals(remote, "fork");
@@ -65,6 +95,73 @@ Deno.test("getRemoteContains", async (t) => {
       }
     },
   );
+
+  await t.step(
+    "returns 'origin' if 'origin/feature/my-awesome-branch' contains the commitish (#9)",
+    async () => {
+      const executeStub = stub(_internals, "execute", (args, _options) => {
+        if (args.at(0) === "remote") {
+          return Promise.resolve("origin\nfork\n");
+        }
+        if (args.at(0) === "branch") {
+          return Promise.resolve("origin/feature/my-awesome-branch\n");
+        }
+        unreachable();
+      });
+      try {
+        const remote = await getRemoteContains("<<commitish>>");
+        assertEquals(remote, "origin");
+      } finally {
+        executeStub.restore();
+      }
+    },
+  );
+
+  await t.step(
+    "returns 'fork/my-awesome-fork' if 'fork/my-awesome-fork/feature/my-awesome-branch' contains the commitish",
+    async () => {
+      const executeStub = stub(_internals, "execute", (args, _options) => {
+        if (args.at(0) === "remote") {
+          return Promise.resolve("origin\nfork/my-awesome-fork\n");
+        }
+        if (args.at(0) === "branch") {
+          return Promise.resolve(
+            "fork/my-awesome-fork/feature/my-awesome-branch\n",
+          );
+        }
+        unreachable();
+      });
+      try {
+        const remote = await getRemoteContains("<<commitish>>");
+        assertEquals(remote, "fork/my-awesome-fork");
+      } finally {
+        executeStub.restore();
+      }
+    },
+  );
+
+  await t.step(
+    "returns 'origin' if 'origin/my-awesome-branch' and 'fork/my-awesome-branch' contains the commitish",
+    async () => {
+      const executeStub = stub(_internals, "execute", (args, _options) => {
+        if (args.at(0) === "remote") {
+          return Promise.resolve("origin\nfork\n");
+        }
+        if (args.at(0) === "branch") {
+          return Promise.resolve(
+            "fork/my-awesome-branch\norigin/my-awesome-branch\n",
+          );
+        }
+        unreachable();
+      });
+      try {
+        const remote = await getRemoteContains("<<commitish>>");
+        assertEquals(remote, "origin");
+      } finally {
+        executeStub.restore();
+      }
+    },
+  );
 });
 
 Deno.test("getRemoteFetchURL", async (t) => {