refactor(bump): replace find_increment with VersionIncrement max

Author: bearomorphism

commitizen/bump.py

@@ -2,64 +2,18 @@
 
 import os
 import re
-from collections import OrderedDict
 from glob import iglob
-from logging import getLogger
 from string import Template
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
-from commitizen.defaults import BUMP_MESSAGE, MAJOR, MINOR, PATCH
+from commitizen.defaults import BUMP_MESSAGE
 from commitizen.exceptions import CurrentVersionNotFoundError
-from commitizen.git import GitCommit, smart_open
+from commitizen.git import smart_open
 
 if TYPE_CHECKING:
     from collections.abc import Generator, Iterable
 
-    from commitizen.version_schemes import Increment, VersionProtocol
-
-VERSION_TYPES = [None, PATCH, MINOR, MAJOR]
-
-logger = getLogger("commitizen")
-
-
-def find_increment(
-    commits: list[GitCommit], regex: str, increments_map: dict | OrderedDict
-) -> Increment | None:
-    if isinstance(increments_map, dict):
-        increments_map = OrderedDict(increments_map)
-
-    # Most important cases are major and minor.
-    # Everything else will be considered patch.
-    select_pattern = re.compile(regex)
-    increment: str | None = None
-
-    for commit in commits:
-        for message in commit.message.split("\n"):
-            result = select_pattern.search(message)
-
-            if result:
-                found_keyword = result.group(1)
-                new_increment = None
-                for match_pattern in increments_map.keys():
-                    if re.match(match_pattern, found_keyword):
-                        new_increment = increments_map[match_pattern]
-                        break
-
-                if new_increment is None:
-                    logger.debug(
-                        f"no increment needed for '{found_keyword}' in '{message}'"
-                    )
-
-                if VERSION_TYPES.index(increment) < VERSION_TYPES.index(new_increment):
-                    logger.debug(
-                        f"increment detected is '{new_increment}' due to '{found_keyword}' in '{message}'"
-                    )
-                    increment = new_increment
-
-                if increment == MAJOR:
-                    break
-
-    return cast("Increment", increment)
+    from commitizen.version_schemes import VersionProtocol
 
 
 def update_version_in_files(

commitizen/commands/bump.py

@@ -24,6 +24,7 @@
 )
 from commitizen.providers import get_provider
 from commitizen.tags import TagRules
+from commitizen.version_increment import VersionIncrement
 from commitizen.version_schemes import (
     Increment,
     InvalidVersion,
@@ -145,8 +146,8 @@ def _is_initial_tag(
         return bool(questionary.confirm("Is this the first tag created?").ask())
 
     def _find_increment(self, commits: list[git.GitCommit]) -> Increment | None:
+        """Determine the highest configured increment across candidate commits."""
         # Update the bump map to ensure major version doesn't increment.
-        # self.cz.bump_map = defaults.bump_map_major_version_zero
         bump_map = (
             self.cz.bump_map_major_version_zero
             if self.bump_settings["major_version_zero"]
@@ -158,11 +159,15 @@ def _find_increment(self, commits: list[git.GitCommit]) -> Increment | None:
             raise NoPatternMapError(
                 f"'{self.config.settings['name']}' rule does not support bump"
             )
-        return bump.find_increment(
-            self.cz.filter_commits_before_bump(commits),
-            regex=bump_pattern,
-            increments_map=bump_map,
+
+        increment = VersionIncrement.get_highest_by_messages(
+            (commit.message for commit in self.cz.filter_commits_before_bump(commits)),
+            bump_pattern,
+            bump_map,
         )
+        if increment == VersionIncrement.NONE:
+            return None
+        return cast("Increment", str(increment))
 
     def _validate_arguments(self, current_version: VersionProtocol) -> None:
         errors: list[str] = []

commitizen/commands/version.py

@@ -4,7 +4,7 @@
 
 from packaging.version import InvalidVersion
 
-from commitizen import bump, factory, git, out
+from commitizen import factory, git, out
 from commitizen.__version__ import __version__
 from commitizen.config import BaseConfig
 from commitizen.exceptions import (
@@ -180,11 +180,20 @@ def _get_next_git_version(
             raise NoPatternMapError(
                 f"'{self.config.settings['name']}' rule does not support bump"
             )
-        increment = bump.find_increment(
-            self.cz.filter_commits_before_bump(commits),
-            regex=bump_pattern,
-            increments_map=bump_map,
+        next_increment = VersionIncrement.get_highest_by_messages(
+            (commit.message for commit in self.cz.filter_commits_before_bump(commits)),
+            bump_pattern,
+            bump_map,
         )
+        increment: Increment | None
+        if next_increment == VersionIncrement.NONE:
+            increment = None
+        elif next_increment == VersionIncrement.PATCH:
+            increment = "PATCH"
+        elif next_increment == VersionIncrement.MINOR:
+            increment = "MINOR"
+        else:
+            increment = "MAJOR"
 
         # TODO: Consider adding all the parameters `.bump` supports:
         # prerelease, prerelease_offset,exact_increment, etc..

commitizen/version_increment.py

@@ -1,6 +1,11 @@
 from __future__ import annotations
 
+import re
 from enum import IntEnum
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
 
 
 class VersionIncrement(IntEnum):
@@ -21,13 +26,64 @@ class VersionIncrement(IntEnum):
     MAJOR = 3
 
     def __str__(self) -> str:
+        """Return the legacy string representation used by existing callers."""
         return self.name
 
     @classmethod
     def from_value(cls, value: object) -> VersionIncrement:
+        """Convert a possibly-invalid external value into a known increment."""
         if not isinstance(value, str):
             return VersionIncrement.NONE
         try:
             return cls[value]
         except KeyError:
             return VersionIncrement.NONE
+
+    @classmethod
+    def from_match(
+        cls, matched_text: str, increments_map: Mapping[str, object]
+    ) -> VersionIncrement:
+        """Resolve one extracted bump token against a configured bump map.
+
+        The first regular-expression key that matches wins, preserving the
+        current user-visible behavior of ``bump_map`` ordering.
+        """
+        for match_pattern, increment in increments_map.items():
+            if re.match(match_pattern, matched_text):
+                return cls.from_value(increment)
+        return cls.NONE
+
+    @classmethod
+    def from_message(
+        cls, message: str, regex: str, 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)
+        increments = []
+
+        for line in message.split("\n"):
+            result = select_pattern.search(line)
+            if result:
+                increments.append(cls.from_match(result.group(1), increments_map))
+
+        return max(increments, default=cls.NONE)
+
+    @classmethod
+    def get_highest_by_messages(
+        cls, messages: Iterable[str], regex: str, 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()``.
+        """
+        return max(
+            (cls.from_message(message, regex, increments_map) for message in messages),
+            default=cls.NONE,
+        )