refactor(utils): make get_backup_file_path to return a path for semantic correctness

Author: bearomorphism

commitizen/commands/commit.py

@@ -51,15 +51,15 @@ def __init__(self, config: BaseConfig, arguments: CommitArgs) -> None:
         self.encoding = config.settings["encoding"]
         self.cz = factory.committer_factory(self.config)
         self.arguments = arguments
-        self.temp_file: str = get_backup_file_path()
+        self.backup_file_path = get_backup_file_path()
 
     def _read_backup_message(self) -> str | None:
         # Check the commit backup file exists
-        if not os.path.isfile(self.temp_file):
+        if not self.backup_file_path.is_file():
             return None
 
         # Read commit message from backup
-        with open(self.temp_file, encoding=self.encoding) as f:
+        with open(self.backup_file_path, encoding=self.encoding) as f:
             return f.read().strip()
 
     def _prompt_commit_questions(self) -> str:
@@ -108,10 +108,10 @@ def manual_edit(self, message: str) -> str:
 
     def _get_message(self) -> str:
         if self.arguments.get("retry"):
-            m = self._read_backup_message()
-            if m is None:
+            commit_message = self._read_backup_message()
+            if commit_message is None:
                 raise NoCommitBackupError()
-            return m
+            return commit_message
 
         if self.config.settings.get("retry_after_failure") and not self.arguments.get(
             "no_retry"
@@ -139,29 +139,29 @@ def __call__(self) -> None:
         if write_message_to_file is not None and write_message_to_file.is_dir():
             raise NotAllowed(f"{write_message_to_file} is a directory")
 
-        m = self._get_message()
+        commit_message = self._get_message()
         if self.arguments.get("edit"):
-            m = self.manual_edit(m)
+            commit_message = self.manual_edit(commit_message)
 
-        out.info(f"\n{m}\n")
+        out.info(f"\n{commit_message}\n")
 
         if write_message_to_file:
             with smart_open(write_message_to_file, "w", encoding=self.encoding) as file:
-                file.write(m)
+                file.write(commit_message)
 
         if dry_run:
             raise DryRunExit()
 
         if self.config.settings["always_signoff"] or signoff:
             extra_args = f"{extra_args} -s".strip()
 
-        c = git.commit(m, args=extra_args)
+        c = git.commit(commit_message, args=extra_args)
         if c.return_code != 0:
             out.error(c.err)
 
             # Create commit backup
-            with smart_open(self.temp_file, "w", encoding=self.encoding) as f:
-                f.write(m)
+            with smart_open(self.backup_file_path, "w", encoding=self.encoding) as f:
+                f.write(commit_message)
 
             raise CommitError()
 
@@ -170,7 +170,7 @@ def __call__(self) -> None:
             return
 
         with contextlib.suppress(FileNotFoundError):
-            os.remove(self.temp_file)
+            self.backup_file_path.unlink()
         out.write(c.err)
         out.write(c.out)
         out.success("Commit successful!")

commitizen/cz/utils.py

@@ -1,6 +1,7 @@
 import os
 import re
 import tempfile
+from pathlib import Path
 
 from commitizen import git
 from commitizen.cz import exceptions
@@ -22,10 +23,9 @@ def strip_local_version(version: str) -> str:
     return _RE_LOCAL_VERSION.sub("", version)
 
 
-def get_backup_file_path() -> str:
+def get_backup_file_path() -> Path:
     project_root = git.find_git_project_root()
     project = project_root.as_posix().replace("/", "%") if project_root else ""
 
     user = os.environ.get("USER", "")
-
-    return os.path.join(tempfile.gettempdir(), f"cz.commit%{user}%{project}.backup")
+    return Path(tempfile.gettempdir(), f"cz.commit%{user}%{project}.backup")

hooks/post-commit.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-from pathlib import Path
 
 try:
     from commitizen.cz.utils import get_backup_file_path
@@ -9,11 +8,11 @@
 
 
 def post_commit() -> None:
-    backup_file = Path(get_backup_file_path())
+    backup_file_path = get_backup_file_path()
 
     # remove backup file if it exists
-    if backup_file.is_file():
-        backup_file.unlink()
+    if backup_file_path.is_file():
+        backup_file_path.unlink()
 
 
 if __name__ == "__main__":

hooks/prepare-commit-msg.py

@@ -2,7 +2,6 @@
 import shutil
 import subprocess
 import sys
-from pathlib import Path
 from subprocess import CalledProcessError
 
 try:
@@ -25,12 +24,12 @@ def prepare_commit_msg(commit_msg_file: str) -> int:
         capture_output=True,
     ).returncode
     if exit_code != 0:
-        backup_file = Path(get_backup_file_path())
-        if backup_file.is_file():
+        backup_file_path = get_backup_file_path()
+        if backup_file_path.is_file():
             # confirm if commit message from backup file should be reused
             answer = input("retry with previous message? [y/N]: ")
             if answer.lower() == "y":
-                shutil.copyfile(backup_file, commit_msg_file)
+                shutil.copyfile(backup_file_path, commit_msg_file)
                 return 0
 
         # use commitizen to generate the commit message
@@ -50,7 +49,7 @@ def prepare_commit_msg(commit_msg_file: str) -> int:
             return error.returncode
 
         # write message to backup file
-        shutil.copyfile(commit_msg_file, backup_file)
+        shutil.copyfile(commit_msg_file, backup_file_path)
     return 0
 
 

tests/commands/test_commit_command.py

@@ -73,7 +73,7 @@ def test_commit_backup_on_failure(config, mocker: MockFixture):
 
     with pytest.raises(CommitError):
         commit_cmd = commands.Commit(config, {})
-        temp_file = commit_cmd.temp_file
+        temp_file = commit_cmd.backup_file_path
         commit_cmd()
 
     prompt_mock.assert_called_once()
@@ -101,7 +101,7 @@ def test_commit_retry_works(config, mocker: MockFixture):
     success_mock = mocker.patch("commitizen.out.success")
 
     commit_cmd = commands.Commit(config, {"retry": True})
-    temp_file = commit_cmd.temp_file
+    temp_file = commit_cmd.backup_file_path
     commit_cmd()
 
     commit_mock.assert_called_with("backup commit", args="")
@@ -144,7 +144,7 @@ def test_commit_retry_after_failure_works(config, mocker: MockFixture):
 
     config.settings["retry_after_failure"] = True
     commit_cmd = commands.Commit(config, {})
-    temp_file = commit_cmd.temp_file
+    temp_file = commit_cmd.backup_file_path
     commit_cmd()
 
     commit_mock.assert_called_with("backup commit", args="")
@@ -171,7 +171,7 @@ def test_commit_retry_after_failure_with_no_retry_works(config, mocker: MockFixt
 
     config.settings["retry_after_failure"] = True
     commit_cmd = commands.Commit(config, {"no_retry": True})
-    temp_file = commit_cmd.temp_file
+    temp_file = commit_cmd.backup_file_path
     commit_cmd()
 
     commit_mock.assert_called_with("feat: user created\n\ncloses #21", args="")