no-mistakes(review): Fix invalid custom bump-map increment handling

Author: bearomorphism

commitizen/version_increment.py

@@ -7,6 +7,8 @@
 if TYPE_CHECKING:
     from collections.abc import Iterable, Mapping
 
+RegexPattern = str | re.Pattern[str]
+
 
 class VersionIncrement(IntEnum):
     """Semantic versioning bump increments.
@@ -39,6 +41,30 @@ def from_value(cls, value: object) -> VersionIncrement:
         except KeyError:
             return VersionIncrement.NONE
 
+    @classmethod
+    def _compile_pattern(cls, regex: RegexPattern) -> re.Pattern[str]:
+        """Normalize a bump-pattern input into a compiled regular expression."""
+        if isinstance(regex, re.Pattern):
+            return regex
+        return re.compile(regex)
+
+    @classmethod
+    def _from_bump_map_value(cls, value: object) -> VersionIncrement:
+        """Resolve a configured bump-map value or reject invalid rule output.
+
+        This preserves the historical behavior where a matched custom bump-map
+        entry with an unsupported increment fails immediately instead of being
+        treated as a no-op.
+        """
+        if value is None:
+            return cls.NONE
+        if not isinstance(value, str):
+            raise ValueError(f"Invalid bump increment: {value!r}")
+        try:
+            return cls[value]
+        except KeyError as exc:
+            raise ValueError(f"Invalid bump increment: {value!r}") from exc
+
     @classmethod
     def from_match(
         cls, matched_text: str, increments_map: Mapping[str, object]
@@ -50,20 +76,20 @@ def from_match(
         """
         for match_pattern, increment in increments_map.items():
             if re.match(match_pattern, matched_text):
-                return cls.from_value(increment)
+                return cls._from_bump_map_value(increment)
         return cls.NONE
 
     @classmethod
     def from_message(
-        cls, message: str, regex: str, increments_map: Mapping[str, object]
+        cls, message: str, regex: RegexPattern, increments_map: Mapping[str, object]
     ) -> VersionIncrement:
         """Compute the highest increment contributed by one commit message.
 
         Commitizen historically evaluates each line of the full commit message
         against ``bump_pattern`` and then keeps the highest resulting bump.
         This method preserves that behavior while returning a comparable enum.
         """
-        select_pattern = re.compile(regex)
+        select_pattern = cls._compile_pattern(regex)
         increments = []
 
         for line in message.split("\n"):
@@ -75,15 +101,22 @@ def from_message(
 
     @classmethod
     def get_highest_by_messages(
-        cls, messages: Iterable[str], regex: str, increments_map: Mapping[str, object]
+        cls,
+        messages: Iterable[str],
+        regex: RegexPattern,
+        increments_map: Mapping[str, object],
     ) -> VersionIncrement:
         """Compute the highest increment across many commit messages.
 
         An empty iterable yields ``NONE`` so callers can preserve the existing
         "no increment" behavior explicitly instead of relying on exceptions from
         ``max()``.
         """
+        select_pattern = cls._compile_pattern(regex)
         return max(
-            (cls.from_message(message, regex, increments_map) for message in messages),
+            (
+                cls.from_message(message, select_pattern, increments_map)
+                for message in messages
+            ),
             default=cls.NONE,
         )

tests/commands/test_bump_command.py

@@ -1330,6 +1330,45 @@ def test_bump_allow_no_commit_with_no_eligible_commit(
     assert "bump: version 1.0.0 → 1.0.1" in out
 
 
+
+def test_bump_allow_no_commit_with_invalid_custom_bump_map_raises(
+    tmp_commitizen_project: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    util: UtilFixture,
+) -> None:
+    """An invalid matched custom bump-map value must fail before PATCH fallback."""
+    monkeypatch.chdir(tmp_commitizen_project)
+    (tmp_commitizen_project / "pyproject.toml").write_text(
+        dedent(
+            """
+            [tool.commitizen]
+            name = "cz_customize"
+            version = "0.1.0"
+
+            [tool.commitizen.customize]
+            bump_pattern = "^(new|fix|docs)"
+            bump_map = { new = "MINORR", fix = "PATCH", docs = "NONE" }
+            change_type_map = { new = "Features", fix = "Bugs", docs = "Docs" }
+            changelog_pattern = "^(new|fix|docs)"
+            commit_parser = '^(?P<change_type>new|fix|docs):\\s(?P<message>.+)$'
+            schema_pattern = ".*"
+            questions = []
+            """
+        ).strip()
+        + "\n",
+        encoding="utf-8",
+    )
+
+    util.create_file_and_commit("fix: seed release")
+    util.run_cli("bump", "--yes")
+    util.create_file_and_commit("new: add endpoint")
+
+    with pytest.raises(ValueError, match="MINORR"):
+        util.run_cli("bump", "--yes", "--allow-no-commit")
+
+    assert git.tag_exist("0.1.2") is False
+
+
 def test_bump_allow_no_commit_with_increment(
     tmp_commitizen_project, monkeypatch, util: UtilFixture, capsys
 ):

tests/test_version_increment.py

@@ -1,5 +1,7 @@
 """Tests for semantic-version increment ordering and extraction helpers."""
 
+import re
+
 import pytest
 
 from commitizen.cz.conventional_commits import ConventionalCommitsCz
@@ -205,3 +207,55 @@ def test_from_message_uses_highest_matching_line() -> None:
         )
         == VersionIncrement.MAJOR
     )
+
+
+def test_get_highest_by_messages_supports_custom_none_mapping() -> None:
+    """A matched custom rule can still explicitly opt out of bumping."""
+    assert (
+        VersionIncrement.get_highest_by_messages(
+            ["docs: update guide"],
+            r"^(docs)",
+            {"docs": None},
+        )
+        == VersionIncrement.NONE
+    )
+
+
+
+def test_get_highest_by_messages_raises_for_invalid_bump_map_value() -> None:
+    """A matched custom bump-map value must fail instead of becoming NONE."""
+    with pytest.raises(ValueError, match="MINORR"):
+        VersionIncrement.get_highest_by_messages(
+            ["new: add endpoint"],
+            r"^(new)",
+            {"new": "MINORR"},
+        )
+
+
+
+def test_get_highest_by_messages_compiles_pattern_once(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Scanning many messages reuses one compiled bump pattern."""
+    compile_calls = 0
+    original_compile = re.compile
+
+    def counted_compile(pattern: str, flags: int = 0) -> re.Pattern[str]:
+        """Record each pattern compilation while preserving regex behavior."""
+        nonlocal compile_calls
+        compile_calls += 1
+        return original_compile(pattern, flags)
+
+    monkeypatch.setattr("commitizen.version_increment.re.compile", counted_compile)
+
+    increment = VersionIncrement.get_highest_by_messages(
+        [
+            "fix: correct typo",
+            "feat(api): add endpoint\n\nBREAKING CHANGE: remove fallback",
+        ],
+        ConventionalCommitsCz.bump_pattern,
+        ConventionalCommitsCz.bump_map,
+    )
+
+    assert increment == VersionIncrement.MAJOR
+    assert compile_calls == 1