Add git stash

jupyterlab_git/git.py

@@ -1772,6 +1772,146 @@ 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 stash_pop(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)
+
+        print(type(cmd[len(cmd) - 1]))
+        if code != 0:
+            return {"code": code, "command": " ".join(cmd), "message": error}
+
+        return {"code": code, "message": output, "command": " ".join(cmd)}
+
+    async def stash_drop(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"]
+        print(stash_index, type(stash_index))
+        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 stash_apply(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,113 @@ 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)
+
+        print(stash_index, type(stash_index))
+        # Choose what to erase
+        if (stash_index is None) and (stash_index != 0):
+            response = await self.git.stash_drop(local_path)
+        else:
+            response = await self.git.stash_drop(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.stash_pop(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.stash_apply(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 +1038,9 @@ def setup_handlers(web_app):
         ("/tags", GitTagHandler),
         ("/tag_checkout", GitTagCheckoutHandler),
         ("/add", GitAddHandler),
+        ("/stash", GitStashHandler),
+        ("/stash_pop", GitStashPopHandler),
+        ("/stash_apply", GitStashApplyHandler),
     ]
 
     handlers = [