Add git stash (#1228)

* Add placeholders

* initial test setup

* clean stash handler

* Edit initial stash test parameters

* Fixed payload parameters and add env

* Added git stash failure test

* Add dummy button to stash changes

* Added placeholder stash section to GitPanel

* Add git stash UI for each file

* Added dummy button UI

* Added git stash pop draft

* Add refresh stash whenever git stash actions are callled

* Add git stash drop/clear

* Add git stash apply

* Add stash signal

* Add git stash message

* Revert stashed files on stash

* Fix revert files on stash

* Fix stash message

* Update stash signal

* Re-render files on git stash apply

* Fix stash pop

* Style Git Stash Files

* Style GitStash header label

* Style stash heading buttons appear only on hover

* Style stash entries

* Add PR feedback

* Refactor handler and git commands

* Refactor based on PR comments

* Finish handler tests

* Remove async mock dependency

* Update styles

* Fix stash signal failing

* Add PR feedback

* Clean up comments

* Fix prettier formatting

* Add integration test

* Add integration tests

* Finish integration tests

* Remove strict MacOS navigation

* Use expect.soft except for last expect

* Remove redundant aria label

* Add timeout for stash text to disappear

* Clean up code

* [skip ci] Improve naming and doc

* Better naming

* Fix errors

* Lint the code

---------

Co-authored-by: Frédéric Collonval <fcollonval@users.noreply.github.com>

Author: shawnesquivel

jupyterlab_git/git.py

@@ -1772,6 +1772,142 @@ def ensure_git_credential_cache_daemon(
         elif self._GIT_CREDENTIAL_CACHE_DAEMON_PROCESS.poll():
             self.ensure_git_credential_cache_daemon(socket, debug, True, cwd, env)
 
+    async def stash(self, path: str, stashMsg: str = "") -> dict:
+        """
+        Stash changes in a dirty working directory away
+        path: str            Git path repository
+        stashMsg (optional): str
+            A message that describes the stash entry
+        """
+        cmd = ["git", "stash"]
+
+        if len(stashMsg) > 0:
+            cmd.extend(["save", "-m", stashMsg])
+
+        env = os.environ.copy()
+        # if the git command is run in a non-interactive terminal, it will not prompt for user input
+        env["GIT_TERMINAL_PROMPT"] = "0"
+
+        code, output, error = await execute(cmd, cwd=path, env=env)
+
+        # code 0: no changes to stash
+        if code != 0:
+            return {"code": code, "command": " ".join(cmd), "message": error}
+        return {"code": code, "message": output, "command": " ".join(cmd)}
+
+    async def stash_list(self, path: str) -> dict:
+        """
+        Execute git stash list command
+        """
+        cmd = ["git", "stash", "list"]
+
+        env = os.environ.copy()
+        env["GIT_TERMINAL_PROMPT"] = "0"
+
+        code, output, error = await execute(cmd, cwd=path, env=env)
+
+        if code != 0:
+            return {"code": code, "command": " ".join(cmd), "message": error}
+
+        return {"code": code, "message": output, "command": " ".join(cmd)}
+
+    async def stash_show(self, path: str, index: int) -> dict:
+        """
+        Execute git stash show command
+        """
+        # stash_index = "stash@{" + str(index) + "}"
+        stash_index = f"stash@{{{index!s}}}"
+
+        cmd = ["git", "stash", "show", "-p", stash_index, "--name-only"]
+
+        env = os.environ.copy()
+        env["GIT_TERMINAL_PROMPT"] = "0"
+
+        code, output, error = await execute(cmd, cwd=path, env=env)
+
+        if code != 0:
+            return {"code": code, "command": " ".join(cmd), "message": error}
+
+        return {"code": code, "message": output, "command": " ".join(cmd)}
+
+    async def pop_stash(self, path: str, stash_index: Optional[int] = None) -> dict:
+        """
+        Execute git stash pop for a certain index of the stash list. If no index is provided, it will
+
+        path: str
+            Git path repository
+        stash_index: number
+            Index of the stash list is first applied to the current branch, then removed from the stash.
+            If the index is not provided, the most recent stash (index=0) will be removed from the stash.
+        """
+        cmd = ["git", "stash", "pop"]
+
+        if stash_index:
+            cmd.append(str(stash_index))
+
+        env = os.environ.copy()
+        env["GIT_TERMINAL_PROMPT"] = "0"
+
+        code, output, error = await execute(cmd, cwd=path, env=env)
+
+        if code != 0:
+            return {"code": code, "command": " ".join(cmd), "message": error}
+
+        return {"code": code, "message": output, "command": " ".join(cmd)}
+
+    async def drop_stash(self, path, stash_index: Optional[int] = None) -> dict:
+        """
+        Execute git stash drop to delete a single stash entry.
+        If not stash_index is provided, delete the entire stash.
+
+        path: Git path repository
+        stash_index: number or None
+            Index of the stash list to remove from the stash.
+            If None, the entire stash is removed.
+        """
+        cmd = ["git", "stash"]
+        if stash_index is None:
+            cmd.append("clear")
+        else:
+            cmd.extend(["drop", str(stash_index)])
+
+        env = os.environ.copy()
+        env["GIT_TERMINAL_PROMPT"] = "0"
+
+        code, output, error = await execute(cmd, cwd=path, env=env)
+
+        if code != 0:
+            return {"code": code, "command": " ".join(cmd), "message": error}
+
+        return {"code": code, "message": output, "command": " ".join(cmd)}
+
+    async def apply_stash(self, path: str, stash_index: Optional[int] = None) -> dict:
+        """
+        Execute git stash apply to apply a single stash entry to the repository.
+        If not stash_index is provided, apply the latest stash.
+
+        path: str
+            Git path repository
+        stash_index: number
+            Index of the stash list is applied to the repository.
+        """
+        # Clear
+        cmd = ["git", "stash", "apply"]
+
+        if stash_index is not None:
+            cmd.append("stash@{" + str(stash_index) + "}")
+
+        env = os.environ.copy()
+        env["GIT_TERMINAL_PROMPT"] = "0"
+
+        code, output, error = await execute(cmd, cwd=path, env=env)
+
+        # error:
+        if code != 0:
+            return {"code": code, "command": " ".join(cmd), "message": error}
+
+        return {"code": code, "message": output, "command": " ".join(cmd)}
+
     @property
     def excluded_paths(self) -> List[str]:
         """Wildcard-style path patterns that do not support git commands.

jupyterlab_git/handlers.py

@@ -892,6 +892,112 @@ async def post(self, path: str = ""):
         self.finish(json.dumps(result))
 
 
+class GitStashHandler(GitHandler):
+    """
+    Handler for 'git stash'. Stores the changes in the current branch
+    """
+
+    @tornado.web.authenticated
+    async def post(self, path: str = "", stashMsg: str = ""):
+        """
+        POST request handler for 'git stash'
+        """
+        local_path = self.url2localpath(path)
+        data = self.get_json_body()
+
+        response = await self.git.stash(local_path, data.get("stashMsg", ""))
+        if response["code"] == 0:
+            self.set_status(201)
+        else:
+            self.set_status(500)
+
+        self.finish(json.dumps(response))
+
+    @tornado.web.authenticated
+    async def delete(self, path: str = ""):
+        """
+        DELETE request handler to clear a single stash or the entire stash list in a Git repository
+        """
+        local_path = self.url2localpath(path)
+        stash_index = self.get_query_argument("stash_index", None)
+
+        # Choose what to erase
+        if (stash_index is None) and (stash_index != 0):
+            response = await self.git.drop_stash(local_path)
+        else:
+            response = await self.git.drop_stash(local_path, stash_index)
+
+        if response["code"] == 0:
+            self.set_status(204)
+        else:
+            self.set_status(500)
+        self.finish()
+
+    @tornado.web.authenticated
+    async def get(self, path: str = ""):
+        """
+        GET request handler for 'git stash list'
+        """
+        # pass the path to the git stash so it knows where to stash
+        local_path = self.url2localpath(path)
+        index = self.get_query_argument("index", None)
+        if index is None:
+            response = await self.git.stash_list(local_path)
+        else:
+            response = await self.git.stash_show(local_path, int(index))
+
+        if response["code"] == 0:
+            self.set_status(200)
+        else:
+            self.set_status(500)
+        self.finish(json.dumps(response))
+
+
+class GitStashPopHandler(GitHandler):
+    """
+    Grab all the files affected by each git stash
+    """
+
+    @tornado.web.authenticated
+    async def post(self, path: str = ""):
+        """
+        POST request handler to pop the latest stash unless an index was provided
+        """
+        local_path = self.url2localpath(path)
+        data = self.get_json_body()
+
+        response = await self.git.pop_stash(local_path, data.get("index"))
+
+        if response["code"] == 0:
+            self.set_status(204)
+            self.finish()
+        else:
+            self.set_status(500)
+            self.finish(json.dumps(response))
+
+
+class GitStashApplyHandler(GitHandler):
+    """
+    Apply the latest stash to the repository.
+    """
+
+    @tornado.web.authenticated
+    async def post(self, path: str = ""):
+        """
+        POST request handler to apply the latest stash unless an index was provided
+        """
+        local_path = self.url2localpath(path)
+        data = self.get_json_body()
+        response = await self.git.apply_stash(local_path, data.get("index"))
+
+        if response["code"] == 0:
+            self.set_status(201)
+        else:
+            self.set_status(500)
+
+        self.finish(json.dumps(response))
+
+
 def setup_handlers(web_app):
     """
     Setups all of the git command handlers.
@@ -931,6 +1037,9 @@ def setup_handlers(web_app):
         ("/tags", GitTagHandler),
         ("/tag_checkout", GitTagCheckoutHandler),
         ("/add", GitAddHandler),
+        ("/stash", GitStashHandler),
+        ("/stash_pop", GitStashPopHandler),
+        ("/stash_apply", GitStashApplyHandler),
     ]
 
     handlers = [