git-commitflow 1.0.9__tar.gz → 1.1.1__tar.gz

{git_commitflow-1.0.9 → git_commitflow-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: git-commitflow
-Version: 1.0.9
+Version: 1.1.1
 Summary: A git add/commit/push helper
 Home-page: https://github.com/jamescherti/git-commitflow
 Author: James Cherti
@@ -27,6 +27,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -39,9 +40,10 @@ Dynamic: summary
 The `git-commitflow` tool is an interactive command-line interface that assists with the Git operations.
 
 Running `git-commitflow` guides the user through the following interactive steps:
-- Prompting the user to add files (`git add`),
-- Displaying differences to ensure accuracy and prevent mistakes before committing (`git diff`),
-- Prompting the user to enter a commit message and then committing the changes (`git commit`),
+- Prompting the user to add files (`git add`).
+- Displaying differences to ensure accuracy and prevent mistakes before committing (`git diff`).
+- Prompting the user to enter a commit message and then committing the changes (`git commit`).
+- It first attempts to merge using `--ff-only`; if the merge fails, it prompts the user to confirm whether to proceed with a rebase using `--rebase` and `--autostash`. Afterward, it commits the changes.
 - Optional (`-p` flag): Pushing updates to the remote repository (`git push`). The references are only pushed when they have never been pushed before. The `git-commitflow` tool maintains a list of references that have been pushed, preventing multiple pushes of the same reference. This reduces unnecessary pushes.
 
 One significant benefit of the `git-commitflow` tool is that it enhances the user's awareness and control over their changes before committing. This reduces the likelihood of including unintended files or alterations in commits, promoting a cleaner and more organized version history.

{git_commitflow-1.0.9 → git_commitflow-1.1.1}/README.md

@@ -6,9 +6,10 @@
 The `git-commitflow` tool is an interactive command-line interface that assists with the Git operations.
 
 Running `git-commitflow` guides the user through the following interactive steps:
-- Prompting the user to add files (`git add`),
-- Displaying differences to ensure accuracy and prevent mistakes before committing (`git diff`),
-- Prompting the user to enter a commit message and then committing the changes (`git commit`),
+- Prompting the user to add files (`git add`).
+- Displaying differences to ensure accuracy and prevent mistakes before committing (`git diff`).
+- Prompting the user to enter a commit message and then committing the changes (`git commit`).
+- It first attempts to merge using `--ff-only`; if the merge fails, it prompts the user to confirm whether to proceed with a rebase using `--rebase` and `--autostash`. Afterward, it commits the changes.
 - Optional (`-p` flag): Pushing updates to the remote repository (`git push`). The references are only pushed when they have never been pushed before. The `git-commitflow` tool maintains a list of references that have been pushed, preventing multiple pushes of the same reference. This reduces unnecessary pushes.
 
 One significant benefit of the `git-commitflow` tool is that it enhances the user's awareness and control over their changes before committing. This reduces the likelihood of including unintended files or alterations in commits, promoting a cleaner and more organized version history.

{git_commitflow-1.0.9 → git_commitflow-1.1.1}/git_commitflow/__init__.py

@@ -29,28 +29,29 @@ import colorama
 from .git_commitflow import GitCommitFlow
 
 
-def git_commitflow_cli():
-    """The git-commitflow command-line interface."""
-    logging.basicConfig(level=logging.INFO, stream=sys.stdout,
-                        format="%(asctime)s %(name)s: %(message)s")
-    colorama.init()
+def flush_stdin():
+    """Clear any pending input from the standard input buffer.
 
+    This function ensures that no stale or unintended data remains in stdin
+    before reading user input interactively. On Windows, it uses the msvcrt
+    module to discard characters from the input buffer. On POSIX-compliant
+    systems (e.g., Linux, macOS...), it uses select to check for available
+    input without blocking and either discards the data by reading or flushes
+    it using termios.tcflush if stdin is a terminal.
+    """
     try:
-        import platform  # pylint: disable=import-outside-toplevel
         if os.name == "nt":
             import msvcrt  # pylint: disable=import-outside-toplevel
 
-            # Check if there's input in the buffer
+            # For Windows systems, Check if there is any pending input in the
+            # buffer Discard characters one at a time until the buffer is empty
             while msvcrt.kbhit():
-                # Read and discard one character at a time
                 msvcrt.getch()
-        elif os.name == "posix" or platform.system() in ["Linux", "Darwin"]:
-            # For Unix-like systems, check if there's any pending input in
-            # stdin without blocking
+        elif os.name == "posix":
             import select  # pylint: disable=import-outside-toplevel
 
-            # Check if there is any pending input in stdin without blocking
-            # If input is available, flush the stdin buffer
+            # For Unix-like systems, check if there's any pending input in
+            # stdin without blocking
             stdin, _, _ = select.select([sys.stdin], [], [], 0)
             if stdin:
                 if sys.stdin.isatty():
@@ -61,10 +62,20 @@ def git_commitflow_cli():
                     tcflush(sys.stdin.fileno(), TCIFLUSH)
                 else:
                     # Read and discard input (in chunks)
-                    sys.stdin.read(1024)
+                    while sys.stdin.read(1024):
+                        pass
     except ImportError:
         pass
 
+
+def git_commitflow_cli():
+    """The git-commitflow command-line interface."""
+    logging.basicConfig(level=logging.INFO, stream=sys.stdout,
+                        format="%(asctime)s %(name)s: %(message)s")
+    colorama.init()
+
+    flush_stdin()
+
     try:
         GitCommitFlow().main()
     except subprocess.CalledProcessError as main_proc_err:

{git_commitflow-1.0.9 → git_commitflow-1.1.1}/git_commitflow/git_commitflow.py

@@ -42,41 +42,38 @@ GIT_DIFF_OPTS: List[str] = []
 MIN_COMMIT_MESSAGE_SIZE = 1
 GIT_COMMITFLOW_DATA_DIR = Path("~/.config/git-commitflow").expanduser()
 CACHE_FILE = GIT_COMMITFLOW_DATA_DIR / "repo-data.json"
-IGNORE_FILENAMES_REGEX: List[str] = []
+IGNORE_FILENAMES_REGEX: list = []
 HISTORY_LENGTH = 256
 
 
 class GitCommitFlow:
     def __init__(self):
-        GIT_COMMITFLOW_DATA_DIR.mkdir(parents=True, exist_ok=True)
-
         self.args = self._parse_args()
+        GIT_COMMITFLOW_DATA_DIR.mkdir(parents=True, exist_ok=True)
 
-        self.git_repo_dir = None
-
-        self.git_repo_dir = None
-        self.find_git_repo_dir()  # Update self.git_repo_dir
-
-        self.amount_commits = self.count_commits()
-        self.cache = CacheFile(CACHE_FILE)
-
+        self.git_repo_dir = self._find_git_repo_dir()
         self.branch = self._get_first_line_cmd("git symbolic-ref --short HEAD")
+        self.amount_commits = self._count_commits()
+        self.readline_manager = self._init_prompt_and_history()
+        self.cache = CacheFile(CACHE_FILE)
 
+    def _init_prompt_and_history(self):
         # History
-        self.prompt_history_file = None
-
-        git_common_dir = \
+        prompt_history_file = None
+        dot_git_dir = \
             self._get_first_line_cmd("git rev-parse --git-common-dir").strip()
-        if git_common_dir:
-            self.prompt_history_file = \
-                Path(git_common_dir).joinpath("git-commitflow-history.rl")
+        if not dot_git_dir:
+            print("Error: The .git directory could not be located",
+                  file=sys.stderr)
+            sys.exit(1)
+
+        prompt_history_file = \
+            Path(dot_git_dir).joinpath("git-commitflow-history.rl")
 
-            logging.debug(
-                "[DEBUG] History file: %s", str(
-                    self.prompt_history_file))
-            self.readline_manager = \
-                ReadlineManager(history_file=self.prompt_history_file,
-                                history_length=HISTORY_LENGTH)
+        logging.debug("[DEBUG] History file: %s", str(prompt_history_file))
+
+        return ReadlineManager(history_file=prompt_history_file,
+                               history_length=HISTORY_LENGTH)
 
     def _parse_args(self):
         """Parse command-line arguments."""
@@ -89,7 +86,11 @@ class GitCommitFlow:
             default=False,
             action="store_true",
             required=False,
-            help="Git push after a successful commit",
+            help=("Git push after a successful commit. (The references are "
+                  "pushed only if they have not been pushed previously. The "
+                  "git-commitflow tool keeps track of the references that "
+                  "have been pushed, preventing the same reference from being "
+                  "pushed multiple times. This minimizes redundant pushes.)"),
         )
 
         parser.add_argument(
@@ -185,10 +186,6 @@ class GitCommitFlow:
             try:
                 subprocess.check_call(["git", "commit"] + git_commit_opts)
 
-                # TODO: maybe git show without a pager?
-                # print()
-                # subprocess.check_call(["git", "show"])
-
                 print()
                 print(Fore.GREEN + "[COMMIT] git commit was SUCCESSFUL." +
                       Fore.RESET)
@@ -207,7 +204,10 @@ class GitCommitFlow:
         # Load cache
         # --------------
         remote_url = self._get_first_line_cmd("git ls-remote  --get-url")
-        branch = self.branch
+
+        # ------------------------
+        # Init commit refs (cache)
+        # ------------------------
         git_push_commit_refs = self.cache.get("git_push_commit_refs", {})
 
         try:
@@ -216,14 +216,14 @@ class GitCommitFlow:
             git_push_commit_refs[remote_url] = {}
 
         try:
-            git_push_commit_refs[remote_url][branch]
+            git_push_commit_refs[remote_url][self.branch]
         except KeyError:
-            git_push_commit_refs[remote_url][branch] = ""
+            git_push_commit_refs[remote_url][self.branch] = ""
 
         commit_ref = \
             self._get_first_line_cmd("git rev-parse --verify HEAD")
 
-        if commit_ref == git_push_commit_refs[remote_url][branch]:
+        if commit_ref == git_push_commit_refs[remote_url][self.branch]:
             print(f"[PUSH] Already pushed: " f"{self.git_repo_dir}")
             return True
 
@@ -236,10 +236,12 @@ class GitCommitFlow:
             return True  # No git remote
 
         try:
-            # Show the remote branch that is tracked by the current local
+            # Display the remote branch that is tracked by the current local
             # branch The error message will be: fatal: no such branch: 'master'
             subprocess.check_call(["git", "rev-parse",
-                                   "--symbolic-full-name", "HEAD@{u}"])
+                                   "--symbolic-full-name", "HEAD@{u}"],
+                                  stdout=subprocess.DEVNULL,
+                                  stderr=subprocess.DEVNULL)
 
             subprocess.check_call(["git", "fetch", "-a"])
         except subprocess.CalledProcessError as proc_err:
@@ -273,10 +275,9 @@ class GitCommitFlow:
         # Update cache file
         # ------------------
         if success:
-            branch = self._get_first_line_cmd("git symbolic-ref --short HEAD")
             commit_ref = \
                 self._get_first_line_cmd("git rev-parse --verify HEAD")
-            git_push_commit_refs[remote_url][branch] = commit_ref
+            git_push_commit_refs[remote_url][self.branch] = commit_ref
             self.cache.set("git_push_commit_refs", git_push_commit_refs)
 
         return success
@@ -287,9 +288,9 @@ class GitCommitFlow:
         except subprocess.CalledProcessError:
             return default_value
 
-    def find_git_repo_dir(self):
+    def _find_git_repo_dir(self):
         try:
-            self.git_repo_dir = Path(
+            return Path(
                 self._get_first_line_cmd("git rev-parse --show-toplevel",
                                          check=True)
             )
@@ -302,7 +303,7 @@ class GitCommitFlow:
                   "is not a directory", file=sys.stderr)
             sys.exit(1)
 
-    def count_commits(self):
+    def _count_commits(self):
         return len(self._run("git rev-list --all --count"))
 
     def _get_first_line_cmd(self, cmd, **kwargs) -> str:
@@ -371,25 +372,24 @@ class GitCommitFlow:
 
         print(f"Author: {Fore.YELLOW + git_author + Fore.RESET} ")
         print("Branch:", Fore.YELLOW + self.branch + Fore.RESET)
-        print("Git message: ", end="")
+        # print("Git message: ", end="")
 
-        commit_message = self.git_config_get("custom.commit-message").strip()
-        previous_message = ""
-        if commit_message:
-            print(Fore.YELLOW + commit_message + Fore.RESET)
-        elif self.amount_commits > 0:
-            previous_message = \
-                "\n".join(
-                    self._run("git --no-pager log -1 --pretty=%B")).rstrip()
-            print(Fore.YELLOW + previous_message + Fore.RESET)
+        # commit_message = self.git_config_get("custom.commit-message").strip()
+        # previous_message = ""
+        # if commit_message:
+        #     print(Fore.YELLOW + commit_message + Fore.RESET)
+        # elif self.amount_commits > 0:
+        #     previous_message = \
+        #         "\n".join(
+        #             self._run("git --no-pager log -1 --pretty=%B")).rstrip()
+        #     print(Fore.YELLOW + previous_message + Fore.RESET)
 
-        commit_message = self.prompt_git_commit_message(commit_message)
+        # commit_message = self.prompt_git_commit_message(commit_message)
+        commit_message = self.prompt_git_commit_message("")
 
         # TODO: move this to a function
-        logging.debug("[DEBUG] Previous message: %s", previous_message)
+        # logging.debug("[DEBUG] Previous message: %s", previous_message)
         logging.debug("[DEBUG] Commit message: %s", commit_message)
-        # if self.prompt_history_file and not commit_message and previous_message:
-        #     self.readline_manager.append_to_history(previous_message)
 
         return commit_message
 

{git_commitflow-1.0.9 → git_commitflow-1.1.1}/git_commitflow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: git-commitflow
-Version: 1.0.9
+Version: 1.1.1
 Summary: A git add/commit/push helper
 Home-page: https://github.com/jamescherti/git-commitflow
 Author: James Cherti
@@ -27,6 +27,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -39,9 +40,10 @@ Dynamic: summary
 The `git-commitflow` tool is an interactive command-line interface that assists with the Git operations.
 
 Running `git-commitflow` guides the user through the following interactive steps:
-- Prompting the user to add files (`git add`),
-- Displaying differences to ensure accuracy and prevent mistakes before committing (`git diff`),
-- Prompting the user to enter a commit message and then committing the changes (`git commit`),
+- Prompting the user to add files (`git add`).
+- Displaying differences to ensure accuracy and prevent mistakes before committing (`git diff`).
+- Prompting the user to enter a commit message and then committing the changes (`git commit`).
+- It first attempts to merge using `--ff-only`; if the merge fails, it prompts the user to confirm whether to proceed with a rebase using `--rebase` and `--autostash`. Afterward, it commits the changes.
 - Optional (`-p` flag): Pushing updates to the remote repository (`git push`). The references are only pushed when they have never been pushed before. The `git-commitflow` tool maintains a list of references that have been pushed, preventing multiple pushes of the same reference. This reduces unnecessary pushes.
 
 One significant benefit of the `git-commitflow` tool is that it enhances the user's awareness and control over their changes before committing. This reduces the likelihood of including unintended files or alterations in commits, promoting a cleaner and more organized version history.

{git_commitflow-1.0.9 → git_commitflow-1.1.1}/setup.py

@@ -23,7 +23,7 @@ from setuptools import find_packages, setup
 
 setup(
     name="git-commitflow",
-    version="1.0.9",
+    version="1.1.1",
     packages=find_packages(),
     description="A git add/commit/push helper",
     long_description=((Path(__file__).parent.resolve().joinpath("README.md"))