Implement ui to support multiple remotes

jupyterlab_git/git.py

@@ -1494,24 +1494,54 @@ async def remote_add(self, path, url, name=DEFAULT_REMOTE_NAME):
 
         return response
 
-    async def remote_show(self, path):
+    async def remote_show(self, path, verbose=False):
         """Handle call to `git remote show` command.
         Args:
             path (str): Git repository path
-
+            verbose (bool): true if details are needed, otherwise, false
         Returns:
-            List[str]: Known remotes
+            if not verbose: List[str]: Known remotes
+            if verbose: List[ { name: str, url: str } ]: Known remotes
         """
-        command = ["git", "remote", "show"]
+        command = ["git", "remote"]
+        if verbose:
+            command.extend(["-v", "show"])
+        else:
+            command.append("show")
+
         code, output, error = await execute(command, cwd=path)
         response = {"code": code, "command": " ".join(command)}
+
         if code == 0:
-            response["remotes"] = [r.strip() for r in output.splitlines()]
+            if verbose:
+                response["remotes"] = [
+                    {"name": r.split("\t")[0], "url": r.split("\t")[1][:-7]}
+                    for r in output.splitlines()
+                    if "(push)" in r
+                ]
+            else:
+                response["remotes"] = [r.strip() for r in output.splitlines()]
         else:
             response["message"] = error
 
         return response
 
+    async def remote_remove(self, path, name):
+        """Handle call to `git remote remove <name>` command.
+        Args:
+            path (str): Git repository path
+            name (str): Remote name
+        """
+        command = ["git", "remote", "remove", name]
+
+        code, _, error = await execute(command, cwd=path)
+        response = {"code": code, "command": " ".join(command)}
+
+        if code != 0:
+            response["message"] = error
+
+        return response
+
     async def ensure_gitignore(self, path):
         """Handle call to ensure .gitignore file exists and the
         next append will be on a new line (this means an empty file

jupyterlab_git/handlers.py

@@ -391,6 +391,39 @@ async def post(self, path: str = ""):
         self.finish(json.dumps(output))
 
 
+class GitRemoteDetailsShowHandler(GitHandler):
+    """Handler for 'git remote -v'."""
+
+    @tornado.web.authenticated
+    async def get(self, path: str = ""):
+        """GET request handler to retrieve existing remotes."""
+        local_path = self.url2localpath(path)
+        output = await self.git.remote_show(local_path, verbose=True)
+        if output["code"] == 0:
+            self.set_status(201)
+        else:
+            self.set_status(500)
+        self.finish(json.dumps(output))
+
+
+class GitRemoteRemoveHandler(GitHandler):
+    """Handler for 'git remote remote <name>'."""
+
+    @tornado.web.authenticated
+    async def post(self, path: str = ""):
+        """GET request handler to remove a remote."""
+        local_path = self.url2localpath(path)
+        data = self.get_json_body()
+        name = data.get("name", None)
+
+        output = await self.git.remote_remove(local_path, name)
+        if output["code"] == 0:
+            self.set_status(201)
+        else:
+            self.set_status(500)
+        self.finish(json.dumps(output))
+
+
 class GitResetHandler(GitHandler):
     """
     Handler for 'git reset <filename>'.
@@ -871,6 +904,8 @@ def setup_handlers(web_app):
         ("/push", GitPushHandler),
         ("/remote/add", GitRemoteAddHandler),
         ("/remote/fetch", GitFetchHandler),
+        ("/remote/show", GitRemoteDetailsShowHandler),
+        ("/remote/remove", GitRemoteRemoveHandler),
         ("/reset", GitResetHandler),
         ("/reset_to_commit", GitResetToCommitHandler),
         ("/show_prefix", GitShowPrefixHandler),

src/commandsAndMenu.tsx

@@ -1,7 +1,6 @@
 import { JupyterFrontEnd } from '@jupyterlab/application';
 import {
   Dialog,
-  InputDialog,
   MainAreaWidget,
   ReactWidget,
   showDialog,
@@ -47,7 +46,9 @@ import {
 } from './tokens';
 import { GitCredentialsForm } from './widgets/CredentialsBox';
 import { discardAllChanges } from './widgets/discardAllChanges';
+import { AddRemoteDialogue } from './components/AddRemoteDialogue';
 import { CheckboxForm } from './widgets/GitResetToRemoteForm';
+import { SingleSelectionForm } from './widgets/SelectRemoteForm';
 
 export interface IGitCloneArgs {
   /**
@@ -265,16 +266,36 @@ export function addCommands(
         return;
       }
       let url = args['url'] as string;
-      const name = args['name'] as string;
+      let name = args['name'] as string;
 
       if (!url) {
-        const result = await InputDialog.getText({
-          title: trans.__('Add a remote repository'),
-          placeholder: trans.__('Remote Git repository URL')
-        });
+        const widgetId = 'git-dialog-AddRemote';
+        let anchor = document.querySelector<HTMLDivElement>(`#${widgetId}`);
+        if (!anchor) {
+          anchor = document.createElement('div');
+          anchor.id = widgetId;
+          document.body.appendChild(anchor);
+        }
+
+        const waitForDialog = new PromiseDelegate<Git.IGitRemote | null>();
+        const dialog = ReactWidget.create(
+          <AddRemoteDialogue
+            trans={trans}
+            model={gitModel}
+            onClose={(remote?: Git.IGitRemote) => {
+              dialog.dispose();
+              waitForDialog.resolve(remote ?? null);
+            }}
+          />
+        );
+
+        Widget.attach(dialog, anchor);
+
+        const remote = await waitForDialog.promise;
 
-        if (result.button.accept) {
-          url = result.value;
+        if (remote) {
+          name = remote.name;
+          url = remote.url;
         }
       }
 
@@ -311,16 +332,40 @@ export function addCommands(
     caption: trans.__('Push code to remote repository'),
     isEnabled: () => gitModel.pathRepository !== null,
     execute: async args => {
-      logger.log({
-        level: Level.RUNNING,
-        message: trans.__('Pushing…')
-      });
       try {
+        const remotes = await gitModel.getRemotes();
+
+        let remote;
+        if (remotes.length > 1) {
+          const result = await showDialog({
+            title: trans.__('Pick a remote repository to push.'),
+            body: new SingleSelectionForm(
+              trans.__(''),
+              remotes.map(remote => remote.name)
+            ),
+            buttons: [
+              Dialog.cancelButton({ label: trans.__('Cancel') }),
+              Dialog.okButton({ label: trans.__('Proceed') })
+            ]
+          });
+          if (result.button.accept) {
+            remote = result.value.selection;
+          } else {
+            return;
+          }
+        }
+
+        logger.log({
+          level: Level.RUNNING,
+          message: trans.__('Pushing…')
+        });
         const details = await showGitOperationDialog(
           gitModel,
           args.force ? Operation.ForcePush : Operation.Push,
-          trans
+          trans,
+          (args = { remote })
         );
+
         logger.log({
           message: trans.__('Successfully pushed'),
           level: Level.SUCCESS,
@@ -1512,10 +1557,18 @@ export async function showGitOperationDialog<T>(
         result = await model.pull(authentication);
         break;
       case Operation.Push:
-        result = await model.push(authentication);
+        result = await model.push(
+          authentication,
+          false,
+          (args as unknown as { remote: string })['remote']
+        );
         break;
       case Operation.ForcePush:
-        result = await model.push(authentication, true);
+        result = await model.push(
+          authentication,
+          true,
+          (args as unknown as { remote: string })['remote']
+        );
         break;
       case Operation.Fetch:
         result = await model.fetch(authentication);