feat: added strict regex for validation and ignored auto commits

aj3sh · aj3sh · commit d092c97235bc · 2024-01-15T11:06:12.000+05:45
diff --git a/src/commitlint/cli.py b/src/commitlint/cli.py
@@ -14,13 +14,22 @@
 """
 import argparse
 import os
+import sys
+from typing import List
 
 from .commitlint import check_commit_message
+from .messages import COMMIT_SUCCESSFUL
 
 
-def main() -> None:
+def get_args() -> argparse.Namespace:
     """
-    Main function for cli to check a commit message.
+    Parse CLI arguments for checking if a commit message.
+
+    Returns:
+        argparse.Namespace: The parsed CLI arguments.
+
+    Raises:
+        argparse.ArgumentError: If any argument error.
     """
     parser = argparse.ArgumentParser(
         description="Check if a commit message follows the conventional commit format."
@@ -34,16 +43,48 @@ def main() -> None:
 
     args = parser.parse_args()
 
+    if not args.file and not args.commit_message:
+        parser.error("Please provide either a commit message or a file.")
+
+    return args
+
+
+def _show_errors(errors: List[str]) -> None:
+    """
+    Display a formatted error message for a list of errors.
+
+    Args:
+        errors (List[str]): A list of error messages to be displayed.
+
+    Returns:
+        None
+    """
+    sys.stderr.write(f"✖ Found {len(errors)} errors.\n\n")
+    for error in errors:
+        sys.stderr.write(f"- {error}\n\n")
+
+
+def main() -> None:
+    """
+    Main function for cli to check a commit message.
+    """
+    args = get_args()
+
     if args.file:
         commit_message_filepath = os.path.abspath(args.file)
         with open(commit_message_filepath, encoding="utf-8") as commit_message_file:
-            commit_message = commit_message_file.read().strip().split("\n\n")[0]
-    elif args.commit_message:
-        commit_message = args.commit_message.strip()
+            commit_message = commit_message_file.read().strip()
     else:
-        parser.error("Please provide either a commit message or a file.")
+        commit_message = args.commit_message.strip()
+
+    success, errors = check_commit_message(commit_message)
+
+    if success:
+        sys.stdout.write(f"{COMMIT_SUCCESSFUL}\n")
+        sys.exit(0)
 
-    check_commit_message(commit_message)
+    _show_errors(errors)
+    sys.exit(1)
 
 
 if __name__ == "__main__":
diff --git a/src/commitlint/commitlint.py b/src/commitlint/commitlint.py
@@ -1,61 +1,124 @@
-"""This module contains source for commitlint"""
+"""
+This module provides functionality for validating commit messages according
+to conventional commit standards.
+
+Usage:
+------
+
+```python
+from commitlint import check_commit_message
+
+commit_message = "feat(module): add module documentation"
+success, errors = check_commit_message(commit_message)
+```
+"""
 import re
-import sys
+from typing import List, Tuple
+
+from .constants import COMMIT_MAX_LENGTH
+from .messages import HEADER_LENGTH_ERROR, INCORRECT_FORMAT_ERROR
+
+CONVENTIONAL_COMMIT_PATTERN = (
+    r"(?s)"  # To explicitly make . match new line
+    r"(?P<type>build|ci|docs|feat|fix|perf|refactor|style|test|chore|revert|bump)"
+    r"(?P<scope>\(\S+\))?!?:"
+    r"(?: (?P<description>[^\n\r]+))"
+    r"((\n\n(?P<body>.*))|(\s*))?$"
+)
 
-COMMIT_MAX_LENGTH = 72
+IGNORED_PATTERN = (
+    r"^((Merge pull request)|(Merge (.*?) into (.*?)|(Merge branch (.*?)))(?:\r?\n)*$)|"
+    r"^(Merge tag (.*?))(?:\r?\n)*$|"
+    r"^(R|r)evert (.*)|"
+    r"^(Merged (.*?)(in|into) (.*)|Merged PR (.*): (.*))$|"
+    r"^Merge remote-tracking branch(\s*)(.*)$|"
+    r"^Automatic merge(.*)$|"
+    r"^Auto-merged (.*?) into (.*)$"
+)
 
 
-def is_conventional_commit(commit_message: str) -> bool:
+def is_ignored(commit_message: str) -> bool:
     """
-    Checks if a commit message follows the conventional commit format.
+    Checks if a commit message should be ignored.
+
+    Some commit messages like merge, revert, auto merge, etc is ignored
+    from linting.
 
     Args:
-        commit_message (str): The commit message to be checked.
+        commit_message (str): The commit message to check.
 
     Returns:
-        bool: True if the commit message follows the conventional commit format,
-              False otherwise.
+        bool: True if the commit message should be ignored, False otherwise.
     """
-    pattern = re.compile(r"^(\w+)(\([^\)]+\))?: .+")
-    return bool(pattern.match(commit_message))
+    return bool(re.match(IGNORED_PATTERN, commit_message))
 
 
-def is_valid_length(commit_message: str, max_length: int) -> bool:
-    """
-    Checks if a commit message has a valid length.
+def remove_comments(msg: str) -> str:
+    """Removes comments from the commit message.
+
+    For `git commit --verbose`, excluding the diff generated message,
+    for example:
+
+    ```bash
+    ...
+    # ------------------------ >8 ------------------------
+    # Do not modify or remove the line above.
+    # Everything below it will be ignored.
+    diff --git a/... b/...
+    ...
+    ```
 
     Args:
-        commit_message (str): The commit message to be checked.
-        max_length (int): The maximum allowed length for the commit message.
+        msg(str): The commit message to remove comments.
 
     Returns:
-        bool: True if the commit message length is valid, False otherwise.
+        str: The commit message without comments.
     """
-    return len(commit_message) <= max_length
 
+    lines: List[str] = []
+    for line in msg.split("\n"):
+        if "# ------------------------ >8 ------------------------" in line:
+            # ignoring all the verbose message below this line
+            break
+        if not line.startswith("#"):
+            lines.append(line)
 
-def check_commit_message(commit_message: str) -> None:
+    return "\n".join(lines)
+
+
+def check_commit_message(commit_message: str) -> Tuple[bool, List[str]]:
     """
-    Check the validity of a commit message.
+    Checks the validity of a commit message. Returns success and error list.
 
     Args:
         commit_message (str): The commit message to be validated.
 
-    Raises:
-        SystemExit: Exits the program with status code 1 if the commit message
-                    violates length or conventional commit format rules.
-
     Returns:
-        None: This function does not return any value; it either exits or
-              continues based on the validity of the commit message.
+        Tuple[bool, List[str]]: Returns success as a first element and list
+        of errors on the second elements. If success is true, errors will be
+        empty.
     """
-    if not is_valid_length(commit_message, max_length=COMMIT_MAX_LENGTH):
-        sys.stderr.write(
-            "Commit message is too long. "
-            f"Max length is {COMMIT_MAX_LENGTH} characters.\n"
-        )
-        sys.exit(1)
-
-    if not is_conventional_commit(commit_message):
-        sys.stderr.write("Commit message does not follow conventional commit format.\n")
-        sys.exit(1)
+    # default values
+    success = True
+    errors: List[str] = []
+
+    # removing unnecessary commit comments
+    commit_message = remove_comments(commit_message)
+
+    # checking if commit message should be ignored
+    if is_ignored(commit_message):
+        return success, errors
+
+    # checking the length of header
+    header = commit_message.split("\n").pop()
+    if len(header) > COMMIT_MAX_LENGTH:
+        success = False
+        errors.append(HEADER_LENGTH_ERROR)
+
+    # matching commit message with the commit pattern
+    pattern_match = re.match(CONVENTIONAL_COMMIT_PATTERN, commit_message)
+    if pattern_match is None:
+        success = False
+        errors.append(INCORRECT_FORMAT_ERROR)
+
+    return success, errors
diff --git a/src/commitlint/constants.py b/src/commitlint/constants.py
@@ -0,0 +1,3 @@
+"""This module defines constants used throughout the application."""
+
+COMMIT_MAX_LENGTH = 72
diff --git a/src/commitlint/messages.py b/src/commitlint/messages.py
@@ -0,0 +1,21 @@
+"""
+This module provides constant messages used in the application for various scenarios.
+"""
+
+from .constants import COMMIT_MAX_LENGTH
+
+COMMIT_SUCCESSFUL = "Commit validation: successful!"
+
+CORRECT_OUTPUT_FORMAT = (
+    "Correct commit format:\n"
+    "---------------------------------------\n"
+    "<type>(<optional scope>): <description>\n"
+    "---------------------------------------\n"
+    "For more details visit "
+    "https://www.conventionalcommits.org/en/v1.0.0/"
+)
+INCORRECT_FORMAT_ERROR = (
+    "Commit message does not follow conventional commits format."
+    f"\n{CORRECT_OUTPUT_FORMAT}"
+)
+HEADER_LENGTH_ERROR = f"Header must not be longer than {COMMIT_MAX_LENGTH} characters."

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+"""This module defines constants used throughout the application."""`
	`2`	`+`
	`3`	`+COMMIT_MAX_LENGTH = 72`