feat: enhanced error message

- Removed old `commitlint.py`.
- Added new module `linter` for linting and validation.
- Added detailed validation on `linter` for message enhancement.
- Added new error messages.
- Added option `--quick` for quick linting.
- Moved old validation to quick linting.
- Added `pytest.ini` for adding src as a python path.
- Updated test for both detailed and quick with same test data.

.github/workflows/ci.yaml

@@ -68,4 +68,4 @@ jobs:
         uses: liskin/gh-problem-matcher-wrap@v3
         with:
           linters: isort
-          run: isort --line-length=88 --check src/
+          run: isort --line-length=88 --check --profile black src/

github_actions/event.py

@@ -5,6 +5,7 @@
     This module relies on the presence of specific environment variables
     set by GitHub Actions.
 """
+
 import json
 import os
 from typing import Any, Dict

github_actions/run.py

@@ -2,6 +2,7 @@
 This script contains actions to be taken based on GitHub events,
 specifically for push and pull_request events.
 """
+
 import os
 import subprocess
 import sys

pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+pythonpath = src

src/commitlint/__init__.py

@@ -1,5 +1,5 @@
-"""Main module for commitlint"""
+"""Main module for commitlint."""
 
-from .commitlint import check_commit_message
+from .linter import lint_commit_message
 
-__all__ = ["check_commit_message"]
+__all__ = ["lint_commit_message"]

src/commitlint/cli.py

@@ -19,10 +19,11 @@
 from typing import List
 
 from .__version__ import __version__
-from .commitlint import check_commit_message, remove_comments
 from .exceptions import CommitlintException
 from .git_helpers import get_commit_message_of_hash, get_commit_messages_of_hash_range
-from .messages import VALIDATION_SUCCESSFUL
+from .linter import lint_commit_message
+from .linter.utils import remove_comments
+from .messages import VALIDATION_FAILED, VALIDATION_SUCCESSFUL
 
 
 def get_args() -> argparse.Namespace:
@@ -57,28 +58,43 @@ def get_args() -> argparse.Namespace:
     # --to-hash is optional
     parser.add_argument("--to-hash", type=str, help="To commit hash", default="HEAD")
 
+    # feature options
+    parser.add_argument(
+        "--quick", action="store_true", help="Check the commit message quickly."
+    )
+
     # parsing args
     args = parser.parse_args()
 
     return args
 
 
-def _show_errors(commit_message: str, errors: List[str]) -> None:
+def _show_errors(
+    commit_message: str,
+    errors: List[str],
+    short: bool = False,
+) -> None:
     """
     Display a formatted error message for a list of errors.
 
     Args:
+        commit_message (str): The commit message to display.
         errors (List[str]): A list of error messages to be displayed.
+        short (bool): Display the error message in short.
+
     """
     error_count = len(errors)
     commit_message = remove_comments(commit_message)
 
-    sys.stderr.write(
-        f"⧗ Input:\n{commit_message}\n\n✖ Found {error_count} error(s).\n\n"
-    )
-    for index, error in enumerate(errors):
-        end_char = "" if index == error_count - 1 else "\n"
-        sys.stderr.write(f"- {error}\n{end_char}")
+    sys.stderr.write(f"⧗ Input:\n{commit_message}\n\n")
+
+    if short:
+        sys.stderr.write(f"{VALIDATION_FAILED}\n")
+        return
+
+    sys.stderr.write(f"✖ Found {error_count} error(s).\n")
+    for error in errors:
+        sys.stderr.write(f"- {error}\n")
 
 
 def _get_commit_message_from_file(filepath: str) -> str:
@@ -101,26 +117,27 @@ def _get_commit_message_from_file(filepath: str) -> str:
         return commit_message
 
 
-def _handle_commit_message(commit_message: str) -> None:
+def _handle_commit_message(commit_message: str, quick: bool) -> None:
     """
     Handles a single commit message, checks its validity, and prints the result.
 
     Args:
         commit_message (str): The commit message to be handled.
+        quick (bool): True for quick linting.
 
     Raises:
         SystemExit: If the commit message is invalid.
     """
-    success, errors = check_commit_message(commit_message)
+    success, errors = lint_commit_message(commit_message, quick=quick)
 
     if success:
         sys.stdout.write(f"{VALIDATION_SUCCESSFUL}\n")
     else:
-        _show_errors(commit_message, errors)
+        _show_errors(commit_message, errors, short=quick)
         sys.exit(1)
 
 
-def _handle_multiple_commit_messages(commit_messages: List[str]) -> None:
+def _handle_multiple_commit_messages(commit_messages: List[str], quick: bool) -> None:
     """
     Handles multiple commit messages, checks their validity, and prints the result.
 
@@ -132,10 +149,10 @@ def _handle_multiple_commit_messages(commit_messages: List[str]) -> None:
     """
     has_error = False
     for commit_message in commit_messages:
-        success, errors = check_commit_message(commit_message)
+        success, errors = lint_commit_message(commit_message, quick=quick)
         if not success:
             has_error = True
-            _show_errors(commit_message, errors)
+            _show_errors(commit_message, errors, short=quick)
             sys.stderr.write("\n")
 
     if has_error:
@@ -153,18 +170,18 @@ def main() -> None:
     try:
         if args.file:
             commit_message = _get_commit_message_from_file(args.file)
-            _handle_commit_message(commit_message)
+            _handle_commit_message(commit_message, quick=args.quick)
         elif args.hash:
             commit_message = get_commit_message_of_hash(args.hash)
-            _handle_commit_message(commit_message)
+            _handle_commit_message(commit_message, quick=args.quick)
         elif args.from_hash:
             commit_messages = get_commit_messages_of_hash_range(
                 args.from_hash, args.to_hash
             )
-            _handle_multiple_commit_messages(commit_messages)
+            _handle_multiple_commit_messages(commit_messages, quick=args.quick)
         else:
             commit_message = args.commit_message.strip()
-            _handle_commit_message(commit_message)
+            _handle_commit_message(commit_message, quick=args.quick)
     except CommitlintException as ex:
         sys.stderr.write(f"{ex}\n")
         sys.exit(1)

src/commitlint/constants.py

@@ -1,3 +1,28 @@
 """This module defines constants used throughout the application."""
 
 COMMIT_HEADER_MAX_LENGTH = 72
+
+COMMIT_TYPES = (
+    "build",
+    "ci",
+    "docs",
+    "feat",
+    "fix",
+    "perf",
+    "refactor",
+    "style",
+    "test",
+    "chore",
+    "revert",
+    "bump",
+)
+
+IGNORE_COMMIT_PATTERNS = (
+    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 (.*)$"
+)

src/commitlint/git_helpers.py

@@ -1,6 +1,7 @@
 """
 This module contains the git related helper functions.
 """
+
 import subprocess
 from typing import List
 

src/commitlint/linter/__init__.py

@@ -0,0 +1,7 @@
+"""Main module for commit linters and validators"""
+
+from ._linter import lint_commit_message
+
+__all__ = [
+    "lint_commit_message",
+]

src/commitlint/linter/_linter.py

@@ -0,0 +1,50 @@
+"""
+This module provides detailed functionality for linting commit messages according
+to conventional commit standards.
+"""
+
+from typing import List, Tuple
+
+from .utils import is_ignored, remove_comments
+from .validators import (
+    HeaderLengthValidator,
+    PatternValidator,
+    QuickPatternValidator,
+    run_validators,
+)
+
+
+def lint_commit_message(
+    commit_message: str, quick: bool = False
+) -> Tuple[bool, List[str]]:
+    """
+    Lints a commit message.
+
+    Args:
+        commit_message (str): The commit message to be linted.
+        quick (bool, optional): Whether to perform a quick linting (default is False).
+
+    Returns:
+        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.
+    """
+
+    # perform processing and pre checks
+    # removing unnecessary commit comments
+    commit_message = remove_comments(commit_message)
+
+    # checking if commit message should be ignored
+    if is_ignored(commit_message):
+        return True, []
+
+    # for quick check
+    if quick:
+        return run_validators(
+            commit_message,
+            validator_classes=[HeaderLengthValidator, QuickPatternValidator],
+            fail_fast=True,
+        )
+
+    return run_validators(
+        commit_message, validator_classes=[HeaderLengthValidator, PatternValidator]
+    )