feat: add custom regex back via message_pattern config option - #427

docs/configuration.rst (1)

388-392: 💤 Low value

Documentation is clear but could refine the "mutually exclusive" phrasing.

The description states:

This is mutually exclusive with conventional_commits — if message_pattern is non-empty it takes precedence.

"Mutually exclusive" typically means both cannot be set simultaneously, but here they can both be set—message_pattern simply takes precedence. Consider rewording for precision:

When set to a non-empty value, message_pattern takes precedence over the conventional_commits auto-generated regex.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@docs/configuration.rst` around lines 388 - 392, Update the phrasing
explaining the relationship between message_pattern and conventional_commits:
replace "This is mutually exclusive with ``conventional_commits`` — if
``message_pattern`` is non-empty it takes precedence." with a clearer statement
such as "When set to a non-empty value, ``message_pattern`` takes precedence
over the ``conventional_commits`` auto-generated regex." Ensure this change
references the same option names (``message_pattern`` and
``conventional_commits``) so readers understand precedence rather than mutual
exclusivity.

commit_check/rule_builder.py (2)

161-161: 💤 Low value

Consider including the pattern in the suggestion message.

The hardcoded suggestion "Commit message does not match the required pattern" doesn't tell users what pattern is expected. Including the actual regex would make debugging easier.

💡 Proposed enhancement

-        suggest="Commit message does not match the required pattern",
+        suggest=f"Commit message does not match the required pattern: {custom_pattern}",

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@commit_check/rule_builder.py` at line 161, Update the suggestion text so it
includes the actual regex pattern used for validation instead of the generic
message; locate the assignment to suggest (the `suggest="Commit message does not
match the required pattern"` entry) in rule_builder.py and interpolate/format
the rule's regex (the variable used for the commit message check, e.g., the
pattern/regex variable that the rule uses) into that string so users see the
exact pattern expected.

---

155-162: ⚡ Quick win

Consider validating the custom regex pattern at configuration time.

Currently, an invalid regex in message_pattern will fail at runtime when CommitMessageValidator calls re.match(). Validating the pattern here would provide earlier, clearer feedback.

🛡️ Proposed validation logic

 custom_pattern = self.commit_config.get("message_pattern", "")
 if custom_pattern:
+    # Validate regex syntax early
+    try:
+        import re
+        re.compile(custom_pattern)
+    except re.error as e:
+        raise ValueError(f"Invalid message_pattern regex: {e}")
     return ValidationRule(
         check=catalog_entry.check,
         regex=custom_pattern,
         error=catalog_entry.error,
         suggest="Commit message does not match the required pattern",
     )

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@commit_check/rule_builder.py` around lines 155 - 162, The custom regex in
commit_config["message_pattern"] should be validated when building the
ValidationRule to fail fast: in the block that creates ValidationRule
(referencing commit_config, ValidationRule and catalog_entry) try to compile the
pattern with re.compile() and catch re.error; if compilation fails raise or
propagate a clear configuration error (or log and skip rule) so
CommitMessageValidator's later re.match() cannot encounter an invalid pattern at
runtime; optionally store the compiled pattern in the ValidationRule so
validators reuse the precompiled regex.

tests/rule_builder_test.py (1)

242-242: 💤 Low value

Consider extracting the duplicated "Bad format" literal.

The literal "Bad format" appears 4 times across the three new tests (lines 242, 248, 263, 284). Extracting it to a module-level constant would reduce duplication.

♻️ Suggested refactor

+# Test constants
+_TEST_ERROR_MSG = "Bad format"
+
 class TestValidationRule:
     `@pytest.mark.benchmark`
     def test_validation_rule_to_dict_with_ignored(self):

Then replace each usage:

         catalog_entry = RuleCatalogEntry(
-            check="message", regex="", error="Bad format", suggest="Use JIRA format"
+            check="message", regex="", error=_TEST_ERROR_MSG, suggest="Use JIRA format"
         )

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/rule_builder_test.py` at line 242, Extract the duplicated literal "Bad
format" into a module-level constant (e.g., BAD_FORMAT_ERROR) at the top of
tests/rule_builder_test.py and replace all occurrences of the string in the new
tests with that constant; update the three tests that currently use "Bad format"
(the four usages noted in the diff) to reference BAD_FORMAT_ERROR so the message
is defined once and reused.

Source: Linters/SAST tools

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes