Add indicators on push/pull icons if actions is required (jupyterlab#813)

* Add badge on push/pull icons

* Add badges on push/pull if action is required

* correct test status

* Fix jest tests

* Update jest

* Test badges

* Downgrade jest to ^25.0.0

* Add fetch before status

* Add badge on push for new branch with no upstream

* Fixes jupyterlab#582

* Improve styling

* Fix unit tests

* Use separate Poll to fetch

* Clear signal when component unmounts

* Set model default values coherent of a clear state

* Fix unit tests

Author: fcollonval

jest.config.js

@@ -19,7 +19,7 @@ module.exports = {
   transformIgnorePatterns: ['/node_modules/(?!(@jupyterlab/.*)/)'],
   globals: {
     'ts-jest': {
-      tsConfig: tsOptions
+      tsconfig: tsOptions
     }
   }
 };

jupyterlab_git/git.py

@@ -30,6 +30,10 @@
 CHECK_LOCK_INTERVAL_S = 0.1
 # Parse Git version output
 GIT_VERSION_REGEX = re.compile(r"^git\sversion\s(?P<version>\d+(.\d+)*)")
+# Parse Git branch status
+GIT_BRANCH_STATUS = re.compile(
+    r"^## (?P<branch>([\w\-/]+|HEAD \(no branch\)|No commits yet on \w+))(\.\.\.(?P<remote>[\w\-/]+)( \[(ahead (?P<ahead>\d+))?(, )?(behind (?P<behind>\d+))?\])?)?$"
+)
 
 execution_lock = tornado.locks.Lock()
 
@@ -272,7 +276,7 @@ async def clone(self, current_path, repo_url, auth=None):
         env = os.environ.copy()
         if auth:
             env["GIT_TERMINAL_PROMPT"] = "1"
-            code, _, error = await execute(
+            code, output, error = await execute(
                 ["git", "clone", unquote(repo_url), "-q"],
                 username=auth["username"],
                 password=auth["password"],
@@ -281,28 +285,50 @@ async def clone(self, current_path, repo_url, auth=None):
             )
         else:
             env["GIT_TERMINAL_PROMPT"] = "0"
-            code, _, error = await execute(
+            code, output, error = await execute(
                 ["git", "clone", unquote(repo_url)],
                 cwd=os.path.join(self.root_dir, current_path),
                 env=env,
             )
 
-        response = {"code": code}
+        response = {"code": code, "message": output.strip()}
 
         if code != 0:
             response["message"] = error.strip()
 
         return response
 
+    async def fetch(self, current_path):
+        """
+        Execute git fetch command
+        """
+        cwd = os.path.join(self.root_dir, current_path)
+        # Start by fetching to get accurate ahead/behind status
+        cmd = [
+            "git",
+            "fetch",
+            "--all",
+            "--prune",
+        ]  # Run prune by default to help beginners
+
+        code, _, fetch_error = await execute(cmd, cwd=cwd)
+
+        result = {
+            "code": code,
+        }
+        if code != 0:
+            result["command"] = " ".join(cmd)
+            result["error"] = fetch_error
+
+        return result
+
     async def status(self, current_path):
         """
         Execute git status command & return the result.
         """
-        cmd = ["git", "status", "--porcelain", "-u", "-z"]
-        code, my_output, my_error = await execute(
-            cmd,
-            cwd=os.path.join(self.root_dir, current_path),
-        )
+        cwd = os.path.join(self.root_dir, current_path)
+        cmd = ["git", "status", "--porcelain", "-b", "-u", "-z"]
+        code, status, my_error = await execute(cmd, cwd=cwd)
 
         if code != 0:
             return {
@@ -320,32 +346,60 @@ async def status(self, current_path):
             "--cached",
             "4b825dc642cb6eb9a060e54bf8d69288fbee4904",
         ]
-        text_code, text_output, _ = await execute(
-            command,
-            cwd=os.path.join(self.root_dir, current_path),
-        )
+        text_code, text_output, _ = await execute(command, cwd=cwd)
 
         are_binary = dict()
         if text_code == 0:
             for line in filter(lambda l: len(l) > 0, strip_and_split(text_output)):
                 diff, name = line.rsplit("\t", maxsplit=1)
                 are_binary[name] = diff.startswith("-\t-")
 
+        data = {
+            "code": code,
+            "branch": None,
+            "remote": None,
+            "ahead": 0,
+            "behind": 0,
+            "files": [],
+        }
         result = []
-        line_iterable = (line for line in strip_and_split(my_output) if line)
-        for line in line_iterable:
-            name = line[3:]
-            result.append(
-                {
-                    "x": line[0],
-                    "y": line[1],
-                    "to": name,
-                    # if file was renamed, next line contains original path
-                    "from": next(line_iterable) if line[0] == "R" else name,
-                    "is_binary": are_binary.get(name, None),
-                }
-            )
-        return {"code": code, "files": result}
+        line_iterable = (line for line in strip_and_split(status) if line)
+
+        try:
+            first_line = next(line_iterable)
+            # Interpret branch line
+            match = GIT_BRANCH_STATUS.match(first_line)
+            if match is not None:
+                d = match.groupdict()
+                branch = d.get("branch")
+                if branch == "HEAD (no branch)":
+                    branch = "(detached)"
+                elif branch.startswith("No commits yet on "):
+                    branch = "(initial)"
+                data["branch"] = branch
+                data["remote"] = d.get("remote")
+                data["ahead"] = int(d.get("ahead") or 0)
+                data["behind"] = int(d.get("behind") or 0)
+
+            # Interpret file lines
+            for line in line_iterable:
+                name = line[3:]
+                result.append(
+                    {
+                        "x": line[0],
+                        "y": line[1],
+                        "to": name,
+                        # if file was renamed, next line contains original path
+                        "from": next(line_iterable) if line[0] == "R" else name,
+                        "is_binary": are_binary.get(name, None),
+                    }
+                )
+
+            data["files"] = result
+        except StopIteration:  # Raised if line_iterable is empty
+            pass
+
+        return data
 
     async def log(self, current_path, history_count=10):
         """
@@ -863,7 +917,7 @@ async def pull(self, curr_fb_path, auth=None, cancel_on_conflict=False):
                 cwd=os.path.join(self.root_dir, curr_fb_path),
             )
 
-        response = {"code": code}
+        response = {"code": code, "message": output.strip()}
 
         if code != 0:
             output = output.strip()
@@ -901,7 +955,7 @@ async def push(self, remote, branch, curr_fb_path, auth=None, set_upstream=False
         env = os.environ.copy()
         if auth:
             env["GIT_TERMINAL_PROMPT"] = "1"
-            code, _, error = await execute(
+            code, output, error = await execute(
                 command,
                 username=auth["username"],
                 password=auth["password"],
@@ -910,13 +964,13 @@ async def push(self, remote, branch, curr_fb_path, auth=None, set_upstream=False
             )
         else:
             env["GIT_TERMINAL_PROMPT"] = "0"
-            code, _, error = await execute(
+            code, output, error = await execute(
                 command,
                 env=env,
                 cwd=os.path.join(self.root_dir, curr_fb_path),
             )
 
-        response = {"code": code}
+        response = {"code": code, "message": output.strip()}
 
         if code != 0:
             response["message"] = error.strip()

jupyterlab_git/handlers.py

@@ -134,6 +134,24 @@ async def post(self):
         self.finish(json.dumps(result))
 
 
+class GitFetchHandler(GitHandler):
+    """
+    Handler for 'git fetch'
+    """
+
+    @web.authenticated
+    async def post(self):
+        """
+        POST request handler, fetch from remotes.
+        """
+        current_path = self.get_json_body()["current_path"]
+        result = await self.git.fetch(current_path)
+
+        if result["code"] != 0:
+            self.set_status(500)
+        self.finish(json.dumps(result))
+
+
 class GitStatusHandler(GitHandler):
     """
     Handler for 'git status --porcelain', fetches the git status.
@@ -787,6 +805,7 @@ def setup_handlers(web_app):
         ("/git/pull", GitPullHandler),
         ("/git/push", GitPushHandler),
         ("/git/remote/add", GitRemoteAddHandler),
+        ("/git/remote/fetch", GitFetchHandler),
         ("/git/reset", GitResetHandler),
         ("/git/reset_to_commit", GitResetToCommitHandler),
         ("/git/server_root", GitServerRootHandler),

jupyterlab_git/tests/test_clone.py

@@ -14,7 +14,8 @@ async def test_git_clone_success():
     with patch("os.environ", {"TEST": "test"}):
         with patch("jupyterlab_git.git.execute") as mock_execute:
             # Given
-            mock_execute.return_value = maybe_future((0, "output", "error"))
+            output = "output"
+            mock_execute.return_value = maybe_future((0, output, "error"))
 
             # When
             actual_response = await Git(FakeContentManager("/bin")).clone(
@@ -27,7 +28,7 @@ async def test_git_clone_success():
                 cwd=os.path.join("/bin", "test_curr_path"),
                 env={"TEST": "test", "GIT_TERMINAL_PROMPT": "0"},
             )
-            assert {"code": 0} == actual_response
+            assert {"code": 0, "message": output} == actual_response
 
 
 @pytest.mark.asyncio
@@ -66,7 +67,8 @@ async def test_git_clone_with_auth_success():
     with patch("os.environ", {"TEST": "test"}):
         with patch("jupyterlab_git.git.execute") as mock_authentication:
             # Given
-            mock_authentication.return_value = maybe_future((0, "", ""))
+            output = "output"
+            mock_authentication.return_value = maybe_future((0, output, ""))
 
             # When
             auth = {"username": "asdf", "password": "qwerty"}
@@ -82,7 +84,7 @@ async def test_git_clone_with_auth_success():
                 cwd=os.path.join("/bin", "test_curr_path"),
                 env={"TEST": "test", "GIT_TERMINAL_PROMPT": "1"},
             )
-            assert {"code": 0} == actual_response
+            assert {"code": 0, "message": output} == actual_response
 
 
 @pytest.mark.asyncio

jupyterlab_git/tests/test_pushpull.py

@@ -105,7 +105,8 @@ async def test_git_pull_success():
     with patch("os.environ", {"TEST": "test"}):
         with patch("jupyterlab_git.git.execute") as mock_execute:
             # Given
-            mock_execute.return_value = maybe_future((0, "output", ""))
+            output = "output"
+            mock_execute.return_value = maybe_future((0, output, ""))
 
             # When
             actual_response = await Git(FakeContentManager("/bin")).pull(
@@ -118,7 +119,7 @@ async def test_git_pull_success():
                 cwd=os.path.join("/bin", "test_curr_path"),
                 env={"TEST": "test", "GIT_TERMINAL_PROMPT": "0"},
             )
-            assert {"code": 0} == actual_response
+            assert {"code": 0, "message": output} == actual_response
 
 
 @pytest.mark.asyncio
@@ -127,8 +128,9 @@ async def test_git_pull_with_auth_success():
     with patch("os.environ", {"TEST": "test"}):
         with patch("jupyterlab_git.git.execute") as mock_execute_with_authentication:
             # Given
+            output = "output"
             mock_execute_with_authentication.return_value = maybe_future(
-                (0, "", "output")
+                (0, output, "")
             )
 
             # When
@@ -145,7 +147,7 @@ async def test_git_pull_with_auth_success():
                 cwd=os.path.join("/bin", "test_curr_path"),
                 env={"TEST": "test", "GIT_TERMINAL_PROMPT": "1"},
             )
-            assert {"code": 0} == actual_response
+            assert {"code": 0, "message": output} == actual_response
 
 
 @pytest.mark.asyncio
@@ -248,7 +250,8 @@ async def test_git_push_success():
     with patch("os.environ", {"TEST": "test"}):
         with patch("jupyterlab_git.git.execute") as mock_execute:
             # Given
-            mock_execute.return_value = maybe_future((0, "output", "does not matter"))
+            output = "output"
+            mock_execute.return_value = maybe_future((0, output, "does not matter"))
 
             # When
             actual_response = await Git(FakeContentManager("/bin")).push(
@@ -261,7 +264,7 @@ async def test_git_push_success():
                 cwd=os.path.join("/bin", "test_curr_path"),
                 env={"TEST": "test", "GIT_TERMINAL_PROMPT": "0"},
             )
-            assert {"code": 0} == actual_response
+            assert {"code": 0, "message": output} == actual_response
 
 
 @pytest.mark.asyncio
@@ -270,8 +273,9 @@ async def test_git_push_with_auth_success():
     with patch("os.environ", {"TEST": "test"}):
         with patch("jupyterlab_git.git.execute") as mock_execute_with_authentication:
             # Given
+            output = "output"
             mock_execute_with_authentication.return_value = maybe_future(
-                (0, "", "does not matter")
+                (0, output, "does not matter")
             )
 
             # When
@@ -288,4 +292,4 @@ async def test_git_push_with_auth_success():
                 cwd=os.path.join("/bin", "test_curr_path"),
                 env={"TEST": "test", "GIT_TERMINAL_PROMPT": "1"},
             )
-            assert {"code": 0} == actual_response
+            assert {"code": 0, "message": output} == actual_response