Allow users to ignore authors

* Added new env var for ignoring authors and added filter for
  the CSV gen, branches by date, new contributors, and suggest reviewers
* Various overall adjustments to handle new author filter
* Remove TODO.md
* Change name of the CSV output file to match the documentation
* Prep for 0.2.0 release

Closes #3

Author: tomice

README.md

@@ -313,6 +313,16 @@ Works with commands `--git-stats-by-branch` and `--csv-output-by-branch`.
 export _GIT_BRANCH="master"
 ```
 
+### Ignore Authors
+
+You can set the variable `_GIT_IGNORE_AUTHORS` to filter out specific
+authors. It will currently work with the "Code reviewers", "New contributors",
+"All branches", and "Output daily stats by branch in CSV format" options.
+
+```bash
+export _GIT_IGNORE_AUTHORS="(author@examle.com|username)"
+```
+
 ### Sorting Contribution Stats
 
 You can sort contribution stats by field `name`, `commits`, `insertions`,

TODO.md

@@ -3,11 +3,34 @@
 """
 
 import os
+import re
 from datetime import datetime
-from typing import Dict, Union, Optional
+from typing import Dict, Union, Optional, Callable
 from git_py_stats.git_operations import run_git_command
 
 
+def _build_author_exclusion_filter(pattern: str) -> Callable[[str], bool]:
+    """
+    Compile a string of authors that tells you whether an author
+    should be ignored based on a user-configured environment
+    variable.
+
+    Args:
+        pattern (str): A regex (Example: "(user@example.com|Some User)").
+                       No flags are injected automatically, but users can
+                       include them for case-insensitive matches.
+
+    Returns:
+        Callable[[str], bool]: Input string 's' that matches the pattern to be
+                               ignored. False otherwise.
+    """
+    pattern = (pattern or "").strip()
+    if not pattern:
+        return lambda _s: False
+    rx = re.compile(pattern)
+    return lambda s: bool(rx.search(s or ""))
+
+
 def _parse_git_sort_by(raw: str) -> tuple[str, str]:
     """
     Helper function for handling sorting features for contribution stats.
@@ -86,6 +109,7 @@ def get_config() -> Dict[str, Union[str, int]]:
         _GIT_DAYS (int): Defines number of days for the heatmap. Default is empty.
         _GIT_SORT_BY (str): Defines sort metric and direction for contribution stats.
                             Default is name-asc.
+        _GIT_IGNORE_AUTHORS (str): Defines authors to ignore. Default is empty.
         _MENU_THEME (str): Toggles between the default theme and legacy theme.
             - 'legacy' to set the legacy theme
             - 'none' to disable the menu theme
@@ -102,6 +126,9 @@ def get_config() -> Dict[str, Union[str, int]]:
             - 'merges' (str): Git command option for merge commit view strategy.
             - 'limit' (int): Git log output limit.
             - 'log_options' (str): Additional git log options.
+            - 'sort_by' (str): Sort by field and sort direction (asc/desc).
+            - 'days' (str): Number of days for the heatmap.
+            - 'ignore_authors': (str): Any author(s) to ignore.
             - 'menu_theme' (str): Menu theme color.
     """
     config: Dict[str, Union[str, int]] = {}
@@ -184,6 +211,10 @@ def get_config() -> Dict[str, Union[str, int]]:
     config["sort_by"] = sort_by
     config["sort_dir"] = sort_dir
 
+    # _GIT_IGNORE_AUTHORS
+    ignore_authors_pattern: Optional[str] = os.environ.get("_GIT_IGNORE_AUTHORS")
+    config["ignore_authors"] = _build_author_exclusion_filter(ignore_authors_pattern)
+
     # _MENU_THEME
     menu_theme: Optional[str] = os.environ.get("_MENU_THEME")
     if menu_theme == "legacy":

git_py_stats/config.py

@@ -451,6 +451,7 @@ def output_daily_stats_csv(config: Dict[str, Union[str, int]]) -> None:
     until = config.get("until", "")
     log_options = config.get("log_options", "")
     pathspec = config.get("pathspec", "")
+    ignore_authors = config.get("ignore_authors", lambda _s: False)
 
     branch = input("Enter branch name (leave empty for current branch): ")
 
@@ -478,22 +479,70 @@ def output_daily_stats_csv(config: Dict[str, Union[str, int]]) -> None:
     cmd = [arg for arg in cmd if arg]
 
     output = run_git_command(cmd)
-    if output:
-        dates = output.split("\n")
-        counter = collections.Counter(dates)
-        filename = "daily_stats.csv"
-        try:
-            with open(filename, "w", newline="") as csvfile:
-                fieldnames = ["Date", "Commits"]
-                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-                writer.writeheader()
-                for date, count in sorted(counter.items()):
-                    writer.writerow({"Date": date, "Commits": count})
-            print(f"Daily stats saved to {filename}")
-        except IOError as e:
-            print(f"Failed to write to {filename}: {e}")
-    else:
+
+    # Exit early if no output valid
+    if not output:
         print("No data available.")
+        return
+
+    # NOTE: This has to be expanded to handle the new ability to ignore
+    # authors, but there might be a better way to handle this...
+    kept_lines = []
+    current_block = []
+    current_ignored = False
+    have_seen_author = False
+
+    for line in output.splitlines():
+        # New commit starts
+        if line.startswith("commit "):
+            # Flush the previous block
+            if current_block and not current_ignored:
+                kept_lines.extend(current_block)
+            # Reset for the next block
+            current_block = [line]
+            current_ignored = False
+            have_seen_author = False
+            continue
+
+        # Only check author once per block
+        if not have_seen_author and line.startswith("Author: "):
+            author_line = line[len("Author: ") :].strip()
+            name = author_line
+            email = ""
+            if "<" in author_line and ">" in author_line:
+                name = author_line.split("<", 1)[0].strip()
+                email = author_line.split("<", 1)[1].split(">", 1)[0].strip()
+
+            # If any form matches (name or email), drop the whole block
+            if (
+                ignore_authors(author_line)
+                or ignore_authors(name)
+                or (email and ignore_authors(email))
+            ):
+                current_ignored = True
+            have_seen_author = True
+        current_block.append(line)
+
+    # Flush the last block
+    if current_block and not current_ignored:
+        kept_lines.extend(current_block)
+
+    # Found nothing worth keeping? Just exit then
+    if not kept_lines:
+        print("No data available.")
+        return
+
+    counter = collections.Counter(kept_lines)
+    filename = "git_daily_stats.csv"
+    try:
+        with open(filename, "w", newline="") as csvfile:
+            writer = csv.DictWriter(csvfile, fieldnames=["Date", "Commits"])
+            writer.writeheader()
+            for text, count in sorted(counter.items()):
+                writer.writerow({"Date": text, "Commits": count})
+        print(f"Daily stats saved to {filename}")
+    except IOError as e:
+        print(f"Failed to write to {filename}: {e}")
 
 
 # TODO: This doesn't match the original functionality as it uses some pretty

git_py_stats/generate_cmds.py

@@ -30,7 +30,7 @@ def handle_interactive_mode(config: Dict[str, Union[str, int]]) -> None:
         "6": lambda: generate_cmds.output_daily_stats_csv(config),
         "7": lambda: generate_cmds.save_git_log_output_json(config),
         "8": lambda: list_cmds.branch_tree(config),
-        "9": list_cmds.branches_by_date,
+        "9": lambda: list_cmds.branches_by_date(config),
         "10": lambda: list_cmds.contributors(config),
         "11": lambda: list_cmds.new_contributors(config, input("Enter cutoff date (YYYY-MM-DD): ")),
         "12": lambda: list_cmds.git_commits_per_author(config),

git_py_stats/interactive_mode.py

@@ -79,24 +79,32 @@ def branch_tree(config: Dict[str, Union[str, int]]) -> None:
         print("No data available.")
 
 
-def branches_by_date() -> None:
+def branches_by_date(config: Dict[str, Union[str, int]]) -> None:
     """
     Lists branches sorted by the latest commit date.
 
     Args:
-        None
+        config: Dict[str, Union[str, int]]: Config dictionary holding env vars.
 
     Returns:
         None
     """
 
+    # Grab the config options from our config.py.
+    ignore_authors = config.get("ignore_authors", lambda _s: False)
+    
     # Original command:
     # git for-each-ref --sort=committerdate refs/heads/ \
     #     --format='[%(authordate:relative)] %(authorname) %(refname:short)' | cat -n
     # TODO: Wouldn't git log --pretty=format:'%ad' --date=short be better here?
     #       Then we could pipe it through sort, uniq -c, sort -nr, etc.
     #       Possibly feed back into the parent project
-    format_str = "[%(authordate:relative)] %(authorname) %(refname:short)"
+
+    # Include the email so we can filter based off it, but keep the visible
+    # part the same as before.
+    visible_fmt = "[%(authordate:relative)] %(authorname) %(refname:short)"
+    format_str = f"{visible_fmt}|%(authoremail)"
+    
     cmd = [
         "git",
         "for-each-ref",
@@ -106,20 +114,35 @@ def branches_by_date() -> None:
     ]
 
     output = run_git_command(cmd)
-    if output:
-        # Split the output into lines
-        lines = output.split("\n")
+    if not output:
+        print("No commits found.")
+        return
 
-        # Number the lines similar to 'cat -n'
-        numbered_lines = [f"{idx + 1}  {line}" for idx, line in enumerate(lines)]
+    # Split lines and filter by author (both name and email), but keep
+    # visible text only.
+    visible_lines = []
+    for raw in output.split("\n"):
+        if not raw.strip():
+            continue
+        if "|" in raw:
+            visible, email = raw.split("|", 1)
+        else:
+            visible, email = raw, ""
 
-        # Output numbered lines
-        print("All branches (sorted by most recent commit):\n")
-        for line in numbered_lines:
-            print(f"\t{line}")
-    else:
+        # Filter by either email or the visible chunk.
+        if ignore_authors(email) or ignore_authors(visible):
+            continue
+
+        visible_lines.append(visible)
+
+    if not visible_lines:
         print("No commits found.")
+        return
 
+    # Number like `cat -n`
+    print("All branches (sorted by most recent commit):\n")
+    for idx, line in enumerate(visible_lines, 1):
+        print(f"\t{idx}  {line}")
 
 def contributors(config: Dict[str, Union[str, int]]) -> None:
     """
@@ -213,6 +236,7 @@ def new_contributors(config: Dict[str, Union[str, int]], new_date: str) -> None:
     until = config.get("until", "")
     log_options = config.get("log_options", "")
     pathspec = config.get("pathspec", "")
+    ignore_authors = config.get("ignore_authors", lambda _s: False)
 
     # Original command:
     # git -c log.showSignature=false log --use-mailmap $_merges \
@@ -245,6 +269,9 @@ def new_contributors(config: Dict[str, Union[str, int]], new_date: str) -> None:
             try:
                 email, timestamp = line.split("|")
                 timestamp = int(timestamp)
+                # Skip ignored by email
+                if ignore_authors(email):
+                    continue
                 # If the contributor is not in the dictionary or the current timestamp is earlier
                 if email not in contributors_dict or timestamp < contributors_dict[email]:
                     contributors_dict[email] = timestamp
@@ -283,12 +310,14 @@ def new_contributors(config: Dict[str, Union[str, int]], new_date: str) -> None:
                 name_cmd = [arg for arg in name_cmd if arg]
 
                 # Grab name + email if we can. Otherwise, just grab email
-                name = run_git_command(name_cmd)
-                if name:
-                    new_contributors_list.append((name, email))
-                else:
-                    new_contributors_list.append(("", email))
-
+                # while also making sure to ignore any authors that may be
+                # in our ignore_author env var
+                name = (run_git_command(name_cmd) or "").strip()
+                combo = f"{name} <{email}>" if name else f"<{email}>"
+                if ignore_authors(email) or ignore_authors(name) or ignore_authors(combo):
+                    continue
+
+                new_contributors_list.append((name, email))
         # Sort the list alphabetically by name to match the original
         # and print all of this out
         if new_contributors_list:

git_py_stats/list_cmds.py

@@ -30,7 +30,7 @@ def handle_non_interactive_mode(args: Namespace, config: Dict[str, Union[str, in
         "csv_output_by_branch": lambda: generate_cmds.output_daily_stats_csv(config),
         "json_output": lambda: generate_cmds.save_git_log_output_json(config),
         "branch_tree": lambda: list_cmds.branch_tree(config),
-        "branches_by_date": list_cmds.branches_by_date,
+        "branches_by_date": lambda: list_cmds.branches_by_date(config),
         "contributors": lambda: list_cmds.contributors(config),
         "new_contributors": lambda: list_cmds.new_contributors(config, args.new_contributors),
         "commits_per_author": lambda: list_cmds.git_commits_per_author(config),

git_py_stats/non_interactive_mode.py

@@ -34,6 +34,7 @@ def suggest_reviewers(config: Dict[str, Union[str, int]]) -> None:
     until = config.get("until", "")
     log_options = config.get("log_options", "")
     pathspec = config.get("pathspec", "")
+    ignore_authors = config.get("ignore_authors", lambda _s: False)
 
     cmd = [
         "git",
@@ -64,6 +65,9 @@ def suggest_reviewers(config: Dict[str, Union[str, int]]) -> None:
         lines = [line.strip() for line in output.splitlines()]
         lines = [line for line in lines if line]
 
+        # Drop ignored authors (name-or-email patterns both supported)
+        lines = [a for a in lines if not ignore_authors(a)]
+
         # Return early if nothing found
         if not lines:
             print("No potential reviewers found.")

git_py_stats/suggest_cmds.py

@@ -268,11 +268,11 @@ def test_output_daily_stats_csv(self, mock_print, mock_input, mock_run_git_comma
             generate_cmds.output_daily_stats_csv(self.mock_config)
 
             # Check that file was written
-            mocked_file.assert_called_with("daily_stats.csv", "w", newline="")
+            mocked_file.assert_called_with("git_daily_stats.csv", "w", newline="")
 
             # Check that print was called
             self.assertTrue(mock_print.called)
-            mock_print.assert_any_call("Daily stats saved to daily_stats.csv")
+            mock_print.assert_any_call("Daily stats saved to git_daily_stats.csv")
 
     @patch("git_py_stats.generate_cmds.run_git_command")
     @patch("builtins.input", return_value="")
@@ -378,7 +378,7 @@ def test_output_daily_stats_csv_io_error(self, mock_print, mock_input, mock_run_
         with patch("builtins.open", side_effect=IOError("Disk full")):
             generate_cmds.output_daily_stats_csv(self.mock_config)
 
-            mock_print.assert_any_call("Failed to write to daily_stats.csv: Disk full")
+            mock_print.assert_any_call("Failed to write to git_daily_stats.csv: Disk full")
 
     @patch("git_py_stats.generate_cmds.run_git_command")
     @patch("builtins.print")

git_py_stats/tests/test_generate_cmds.py

@@ -89,7 +89,7 @@ def test_option_8(self, mock_branch_tree, mock_interactive_menu):
     def test_option_9(self, mock_branches_by_date, mock_interactive_menu):
         mock_interactive_menu.side_effect = ["9", ""]
         interactive_mode.handle_interactive_mode(self.mock_config)
-        mock_branches_by_date.assert_called_once_with()
+        mock_branches_by_date.assert_called_once_with(self.mock_config)
 
     @patch("git_py_stats.interactive_mode.interactive_menu")
     @patch("git_py_stats.list_cmds.contributors")