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,37 @@ 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(200)
+        else:
+            self.set_status(500)
+        self.finish(json.dumps(output))
+
+
+class GitRemoteRemoveHandler(GitHandler):
+    """Handler for 'git remote remove <name>'."""
+
+    @tornado.web.authenticated
+    async def delete(self, path: str = "", name: str = ""):
+        """DELETE request handler to remove a remote."""
+        local_path = self.url2localpath(path)
+
+        output = await self.git.remote_remove(local_path, name)
+        if output["code"] == 0:
+            self.set_status(204)
+        else:
+            self.set_status(500)
+            self.finish(json.dumps(output))
+
+
 class GitResetHandler(GitHandler):
     """
     Handler for 'git reset <filename>'.
@@ -871,6 +902,7 @@ def setup_handlers(web_app):
         ("/push", GitPushHandler),
         ("/remote/add", GitRemoteAddHandler),
         ("/remote/fetch", GitFetchHandler),
+        ("/remote/show", GitRemoteDetailsShowHandler),
         ("/reset", GitResetHandler),
         ("/reset_to_commit", GitResetToCommitHandler),
         ("/show_prefix", GitShowPrefixHandler),
@@ -890,12 +922,23 @@ def setup_handlers(web_app):
 
     # add the baseurl to our paths
     base_url = web_app.settings["base_url"]
-    git_handlers = [
-        (url_path_join(base_url, NAMESPACE + path_regex + endpoint), handler)
-        for endpoint, handler in handlers_with_path
-    ] + [
-        (url_path_join(base_url, NAMESPACE + endpoint), handler)
-        for endpoint, handler in handlers
-    ]
+    git_handlers = (
+        [
+            (url_path_join(base_url, NAMESPACE + path_regex + endpoint), handler)
+            for endpoint, handler in handlers_with_path
+        ]
+        + [
+            (url_path_join(base_url, NAMESPACE + endpoint), handler)
+            for endpoint, handler in handlers
+        ]
+        + [
+            (
+                url_path_join(
+                    base_url, NAMESPACE + path_regex + r"/remote/(?P<name>\w+)"
+                ),
+                GitRemoteRemoveHandler,
+            )
+        ]
+    )
 
     web_app.add_handlers(".*", git_handlers)

jupyterlab_git/tests/test_remote.py

@@ -1,11 +1,11 @@
 import json
 from unittest.mock import patch
-
+import os
 import pytest
 import tornado
 
+from jupyterlab_git.git import Git
 from jupyterlab_git.handlers import NAMESPACE
-
 from .testutils import assert_http_error, maybe_future
 
 
@@ -101,3 +101,81 @@ async def test_git_add_remote_failure(mock_execute, jp_fetch, jp_root_dir):
     mock_execute.assert_called_once_with(
         ["git", "remote", "add", "origin", url], cwd=str(local_path)
     )
+
+
+@patch("jupyterlab_git.git.execute")
+async def test_git_remote_show(mock_execute, jp_root_dir):
+    # Given
+    local_path = jp_root_dir / "test_path"
+    mock_execute.return_value = maybe_future(
+        (0, os.linesep.join(["origin", "test"]), "")
+    )
+
+    # When
+    output = await Git().remote_show(str(local_path), False)
+
+    # Then
+    command = ["git", "remote", "show"]
+    mock_execute.assert_called_once_with(command, cwd=str(local_path))
+    assert output == {
+        "code": 0,
+        "command": " ".join(command),
+        "remotes": ["origin", "test"],
+    }
+
+
+@patch("jupyterlab_git.git.execute")
+async def test_git_remote_show_verbose(mock_execute, jp_fetch, jp_root_dir):
+    # Given
+    local_path = jp_root_dir / "test_path"
+    url = "http://github.com/myid/myrepository.git"
+    process_output = os.linesep.join(
+        [f"origin\t{url} (fetch)", f"origin\t{url} (push)"]
+    )
+    mock_execute.return_value = maybe_future((0, process_output, ""))
+
+    # When
+    response = await jp_fetch(
+        NAMESPACE,
+        local_path.name,
+        "remote",
+        "show",
+        method="GET",
+    )
+
+    # Then
+    command = ["git", "remote", "-v", "show"]
+    mock_execute.assert_called_once_with(command, cwd=str(local_path))
+
+    assert response.code == 200
+    payload = json.loads(response.body)
+    assert payload == {
+        "code": 0,
+        "command": " ".join(command),
+        "remotes": [
+            {"name": "origin", "url": "http://github.com/myid/myrepository.git"}
+        ],
+    }
+
+
+@patch("jupyterlab_git.git.execute")
+async def test_git_remote_remove(mock_execute, jp_fetch, jp_root_dir):
+    # Given
+    local_path = jp_root_dir / "test_path"
+    mock_execute.return_value = maybe_future((0, "", ""))
+
+    # When
+    name = "origin"
+    response = await jp_fetch(
+        NAMESPACE,
+        local_path.name,
+        "remote",
+        name,
+        method="DELETE",
+    )
+
+    # Then
+    command = ["git", "remote", "remove", name]
+    mock_execute.assert_called_once_with(command, cwd=str(local_path))
+
+    assert response.code == 204

schema/plugin.json

@@ -100,7 +100,7 @@
           },
           {
             "command": "git:push",
-            "args": { "force": true }
+            "args": { "advanced": true }
           },
           {
             "command": "git:pull"

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 { AdvancedPushForm } from './widgets/AdvancedPushForm';
 
 export interface IGitCloneArgs {
   /**
@@ -254,8 +255,8 @@ export function addCommands(
 
   /** Command to add a remote Git repository */
   commands.addCommand(CommandIDs.gitAddRemote, {
-    label: trans.__('Add Remote Repository'),
-    caption: trans.__('Add a Git remote repository'),
+    label: trans.__('Manage Remote Repositories'),
+    caption: trans.__('Manage Remote Repositories'),
     isEnabled: () => gitModel.pathRepository !== null,
     execute: async args => {
       if (gitModel.pathRepository === null) {
@@ -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;
         }
       }
 
@@ -305,22 +326,44 @@ export function addCommands(
   /** Add git push command */
   commands.addCommand(CommandIDs.gitPush, {
     label: args =>
-      args.force
-        ? trans.__('Push to Remote (Force)')
+      (args['advanced'] as boolean)
+        ? trans.__('Push to Remote (Advanced)')
         : trans.__('Push to Remote'),
     caption: trans.__('Push code to remote repository'),
     isEnabled: () => gitModel.pathRepository !== null,
     execute: async args => {
-      logger.log({
-        level: Level.RUNNING,
-        message: trans.__('Pushing…')
-      });
       try {
+        let remote;
+        let force;
+
+        if (args['advanced'] as boolean) {
+          const result = await showDialog({
+            title: trans.__('Please select push options.'),
+            body: new AdvancedPushForm(trans, gitModel),
+            buttons: [
+              Dialog.cancelButton({ label: trans.__('Cancel') }),
+              Dialog.okButton({ label: trans.__('Proceed') })
+            ]
+          });
+          if (result.button.accept) {
+            remote = result.value.remoteName;
+            force = result.value.force;
+          } else {
+            return;
+          }
+        }
+
+        logger.log({
+          level: Level.RUNNING,
+          message: trans.__('Pushing…')
+        });
         const details = await showGitOperationDialog(
           gitModel,
-          args.force ? Operation.ForcePush : Operation.Push,
-          trans
+          force ? Operation.ForcePush : Operation.Push,
+          trans,
+          (args = { remote })
         );
+
         logger.log({
           message: trans.__('Successfully pushed'),
           level: Level.SUCCESS,
@@ -1275,7 +1318,7 @@ export function createGitMenu(
   ].forEach(command => {
     menu.addItem({ command });
     if (command === CommandIDs.gitPush) {
-      menu.addItem({ command, args: { force: true } });
+      menu.addItem({ command, args: { advanced: true } });
     }
     if (command === CommandIDs.gitPull) {
       menu.addItem({ command, args: { force: true } });
@@ -1512,10 +1555,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);